diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 8316d7dc165e..bd5803a70f69 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -4,7 +4,7 @@ on:
push:
branches:
- master
- - llvm18
+ - llvm19
concurrency:
# Cancels pending runs when a PR gets updated.
group: ${{ github.head_ref || github.run_id }}-${{ github.actor }}
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8348b45cfd41..ebdce53228c9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -137,9 +137,9 @@ else()
set(ZIG_SYSTEM_LIBCXX "stdc++" CACHE STRING "system libcxx name for build.zig")
endif()
-find_package(llvm 18)
-find_package(clang 18)
-find_package(lld 18)
+find_package(llvm 19)
+find_package(clang 19)
+find_package(lld 19)
if(ZIG_STATIC_ZLIB)
if (MSVC)
@@ -600,6 +600,7 @@ set(ZIG_STAGE2_SOURCES
src/link/Elf.zig
src/link/Elf/Archive.zig
src/link/Elf/Atom.zig
+ src/link/Elf/AtomList.zig
src/link/Elf/LdScript.zig
src/link/Elf/LinkerDefined.zig
src/link/Elf/Object.zig
@@ -833,6 +834,11 @@ else()
endif()
endif()
+option(ZIG2_NO_RTLIB "Build zig2 without linking to a compiler runtime library (for `zig cc` only)" OFF)
+if(ZIG2_NO_RTLIB)
+ set(ZIG2_LINK_FLAGS "${ZIG2_LINK_FLAGS} -rtlib=none")
+endif()
+
set(ZIG1_WASM_MODULE "${PROJECT_SOURCE_DIR}/stage1/zig1.wasm")
set(ZIG1_C_SOURCE "${PROJECT_BINARY_DIR}/zig1.c")
set(ZIG2_C_SOURCE "${PROJECT_BINARY_DIR}/zig2.c")
@@ -888,9 +894,7 @@ set(BUILD_COMPILER_RT_ARGS
--name compiler_rt
-femit-bin="${ZIG_COMPILER_RT_C_SOURCE}"
-target "${ZIG_HOST_TARGET_TRIPLE}"
- --dep "build_options"
"-Mroot=lib/compiler_rt.zig"
- "-Mbuild_options=${ZIG_CONFIG_ZIG_OUT}"
)
add_custom_command(
diff --git a/README.md b/README.md
index 865bd178b3b3..818a7d67f830 100644
--- a/README.md
+++ b/README.md
@@ -47,7 +47,7 @@ Ensure you have the required dependencies:
* CMake >= 3.15
* System C/C++ Toolchain
- * LLVM, Clang, LLD development libraries == 18.x
+ * LLVM, Clang, LLD development libraries == 19.x
Then it is the standard CMake build process:
diff --git a/bootstrap.c b/bootstrap.c
index fca6ce108123..e1684df19a13 100644
--- a/bootstrap.c
+++ b/bootstrap.c
@@ -170,9 +170,7 @@ int main(int argc, char **argv) {
"-ofmt=c", "-OReleaseSmall",
"--name", "compiler_rt", "-femit-bin=compiler_rt.c",
"-target", host_triple,
- "--dep", "build_options",
"-Mroot=lib/compiler_rt.zig",
- "-Mbuild_options=config.zig",
NULL,
};
print_and_run(child_argv);
diff --git a/build.zig b/build.zig
index 264cbe0405c6..731b825c07b4 100644
--- a/build.zig
+++ b/build.zig
@@ -1099,6 +1099,8 @@ const clang_libs = [_][]const u8{
"clangToolingCore",
"clangExtractAPI",
"clangSupport",
+ "clangInstallAPI",
+ "clangAST",
};
const lld_libs = [_][]const u8{
"lldMinGW",
@@ -1120,6 +1122,7 @@ const llvm_libs = [_][]const u8{
"LLVMTextAPIBinaryReader",
"LLVMCoverage",
"LLVMLineEditor",
+ "LLVMSandboxIR",
"LLVMXCoreDisassembler",
"LLVMXCoreCodeGen",
"LLVMXCoreDesc",
@@ -1255,6 +1258,7 @@ const llvm_libs = [_][]const u8{
"LLVMDWARFLinkerParallel",
"LLVMDWARFLinkerClassic",
"LLVMDWARFLinker",
+ "LLVMCodeGenData",
"LLVMGlobalISel",
"LLVMMIRParser",
"LLVMAsmPrinter",
diff --git a/ci/aarch64-linux-debug.sh b/ci/aarch64-linux-debug.sh
index 27effea36a12..bb99a3044af3 100644
--- a/ci/aarch64-linux-debug.sh
+++ b/ci/aarch64-linux-debug.sh
@@ -8,7 +8,7 @@ set -e
ARCH="$(uname -m)"
TARGET="$ARCH-linux-musl"
MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.14.0-dev.418+ebd9efa85"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
PREFIX="$HOME/deps/$CACHE_BASENAME"
ZIG="$PREFIX/bin/zig"
diff --git a/ci/aarch64-linux-release.sh b/ci/aarch64-linux-release.sh
index 947694ce393d..5f43bfcc5f18 100644
--- a/ci/aarch64-linux-release.sh
+++ b/ci/aarch64-linux-release.sh
@@ -8,7 +8,7 @@ set -e
ARCH="$(uname -m)"
TARGET="$ARCH-linux-musl"
MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.14.0-dev.418+ebd9efa85"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
PREFIX="$HOME/deps/$CACHE_BASENAME"
ZIG="$PREFIX/bin/zig"
diff --git a/ci/aarch64-macos-debug.sh b/ci/aarch64-macos-debug.sh
index 9283321c1f54..4d44401a9924 100755
--- a/ci/aarch64-macos-debug.sh
+++ b/ci/aarch64-macos-debug.sh
@@ -9,7 +9,7 @@ set -e
ZIGDIR="$PWD"
TARGET="$ARCH-macos-none"
MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.13.0-dev.130+98a30acad"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
PREFIX="$HOME/$CACHE_BASENAME"
ZIG="$PREFIX/bin/zig"
diff --git a/ci/aarch64-macos-release.sh b/ci/aarch64-macos-release.sh
index 396aa1d46469..e8ce56eaea2d 100755
--- a/ci/aarch64-macos-release.sh
+++ b/ci/aarch64-macos-release.sh
@@ -9,7 +9,7 @@ set -e
ZIGDIR="$PWD"
TARGET="$ARCH-macos-none"
MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.13.0-dev.130+98a30acad"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
PREFIX="$HOME/$CACHE_BASENAME"
ZIG="$PREFIX/bin/zig"
diff --git a/ci/aarch64-windows.ps1 b/ci/aarch64-windows.ps1
index bf68a6443c01..b0e7c474ca8c 100644
--- a/ci/aarch64-windows.ps1
+++ b/ci/aarch64-windows.ps1
@@ -1,5 +1,5 @@
$TARGET = "$($Env:ARCH)-windows-gnu"
-$ZIG_LLVM_CLANG_LLD_NAME = "zig+llvm+lld+clang-$TARGET-0.13.0-dev.130+98a30acad"
+$ZIG_LLVM_CLANG_LLD_NAME = "zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
$MCPU = "baseline"
$ZIG_LLVM_CLANG_LLD_URL = "https://ziglang.org/deps/$ZIG_LLVM_CLANG_LLD_NAME.zip"
$PREFIX_PATH = "$(Get-Location)\..\$ZIG_LLVM_CLANG_LLD_NAME"
diff --git a/ci/x86_64-linux-debug.sh b/ci/x86_64-linux-debug.sh
index 8e9929bc22f9..4ad0fa7061ca 100755
--- a/ci/x86_64-linux-debug.sh
+++ b/ci/x86_64-linux-debug.sh
@@ -8,7 +8,7 @@ set -e
ARCH="$(uname -m)"
TARGET="$ARCH-linux-musl"
MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.14.0-dev.418+ebd9efa85"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
PREFIX="$HOME/deps/$CACHE_BASENAME"
ZIG="$PREFIX/bin/zig"
@@ -64,7 +64,7 @@ stage3-debug/bin/zig build \
stage3-debug/bin/zig build test docs \
--maxrss 21000000000 \
- -Dlldb=$HOME/deps/lldb-zig/Debug-befcd57a8/bin/lldb \
+ -Dlldb=$HOME/deps/lldb-zig/Debug-4a44163df/bin/lldb \
-fqemu \
-fwasmtime \
-Dstatic-llvm \
diff --git a/ci/x86_64-linux-release.sh b/ci/x86_64-linux-release.sh
index 346e942602c8..c4d9c9ddb7c1 100755
--- a/ci/x86_64-linux-release.sh
+++ b/ci/x86_64-linux-release.sh
@@ -8,7 +8,7 @@ set -e
ARCH="$(uname -m)"
TARGET="$ARCH-linux-musl"
MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.14.0-dev.418+ebd9efa85"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
PREFIX="$HOME/deps/$CACHE_BASENAME"
ZIG="$PREFIX/bin/zig"
@@ -64,7 +64,7 @@ stage3-release/bin/zig build \
stage3-release/bin/zig build test docs \
--maxrss 21000000000 \
- -Dlldb=$HOME/deps/lldb-zig/Release-befcd57a8/bin/lldb \
+ -Dlldb=$HOME/deps/lldb-zig/Release-4a44163df/bin/lldb \
-fqemu \
-fwasmtime \
-Dstatic-llvm \
diff --git a/ci/x86_64-macos-release.sh b/ci/x86_64-macos-release.sh
index acf2b91d9a1a..838952b181bb 100755
--- a/ci/x86_64-macos-release.sh
+++ b/ci/x86_64-macos-release.sh
@@ -6,7 +6,7 @@ set -e
ZIGDIR="$PWD"
TARGET="$ARCH-macos-none"
MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.13.0-dev.130+98a30acad"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
PREFIX="$HOME/$CACHE_BASENAME"
JOBS="-j3"
ZIG="$PREFIX/bin/zig"
diff --git a/ci/x86_64-windows-debug.ps1 b/ci/x86_64-windows-debug.ps1
index db8be82d8985..8fd4db222c52 100644
--- a/ci/x86_64-windows-debug.ps1
+++ b/ci/x86_64-windows-debug.ps1
@@ -1,5 +1,5 @@
$TARGET = "$($Env:ARCH)-windows-gnu"
-$ZIG_LLVM_CLANG_LLD_NAME = "zig+llvm+lld+clang-$TARGET-0.13.0-dev.130+98a30acad"
+$ZIG_LLVM_CLANG_LLD_NAME = "zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
$MCPU = "baseline"
$ZIG_LLVM_CLANG_LLD_URL = "https://ziglang.org/deps/$ZIG_LLVM_CLANG_LLD_NAME.zip"
$PREFIX_PATH = "$($Env:USERPROFILE)\$ZIG_LLVM_CLANG_LLD_NAME"
diff --git a/ci/x86_64-windows-release.ps1 b/ci/x86_64-windows-release.ps1
index 3d8938ce1982..432d0649beb1 100644
--- a/ci/x86_64-windows-release.ps1
+++ b/ci/x86_64-windows-release.ps1
@@ -1,5 +1,5 @@
$TARGET = "$($Env:ARCH)-windows-gnu"
-$ZIG_LLVM_CLANG_LLD_NAME = "zig+llvm+lld+clang-$TARGET-0.13.0-dev.130+98a30acad"
+$ZIG_LLVM_CLANG_LLD_NAME = "zig+llvm+lld+clang-$TARGET-0.14.0-dev.1622+2ac543388"
$MCPU = "baseline"
$ZIG_LLVM_CLANG_LLD_URL = "https://ziglang.org/deps/$ZIG_LLVM_CLANG_LLD_NAME.zip"
$PREFIX_PATH = "$($Env:USERPROFILE)\$ZIG_LLVM_CLANG_LLD_NAME"
diff --git a/cmake/Findclang.cmake b/cmake/Findclang.cmake
index c21fe188374c..a95a8c903b67 100644
--- a/cmake/Findclang.cmake
+++ b/cmake/Findclang.cmake
@@ -17,10 +17,10 @@ find_path(CLANG_INCLUDE_DIRS NAMES clang/Frontend/ASTUnit.h
if(${LLVM_LINK_MODE} STREQUAL "shared")
find_library(CLANG_LIBRARIES
NAMES
- libclang-cpp.so.18
- libclang-cpp.so.18.1
- clang-cpp-18.0
- clang-cpp180
+ libclang-cpp.so.19
+ libclang-cpp.so.19.1
+ clang-cpp-19.0
+ clang-cpp190
clang-cpp
NAMES_PER_DIR
HINTS "${LLVM_LIBDIRS}"
@@ -68,6 +68,8 @@ else()
FIND_AND_ADD_CLANG_LIB(clangToolingCore)
FIND_AND_ADD_CLANG_LIB(clangExtractAPI)
FIND_AND_ADD_CLANG_LIB(clangSupport)
+ FIND_AND_ADD_CLANG_LIB(clangInstallAPI)
+ FIND_AND_ADD_CLANG_LIB(clangAST)
endif()
if (MSVC)
diff --git a/cmake/Findlld.cmake b/cmake/Findlld.cmake
index abe29b5fcefe..7c86aaed0711 100644
--- a/cmake/Findlld.cmake
+++ b/cmake/Findlld.cmake
@@ -9,21 +9,21 @@
find_path(LLD_INCLUDE_DIRS NAMES lld/Common/Driver.h
HINTS ${LLVM_INCLUDE_DIRS}
PATHS
- /usr/lib/llvm-18/include
- /usr/local/llvm180/include
- /usr/local/llvm18/include
- /usr/local/opt/llvm@18/include
- /opt/homebrew/opt/llvm@18/include
+ /usr/lib/llvm-19/include
+ /usr/local/llvm190/include
+ /usr/local/llvm19/include
+ /usr/local/opt/llvm@19/include
+ /opt/homebrew/opt/llvm@19/include
/mingw64/include)
-find_library(LLD_LIBRARY NAMES lld-18.0 lld180 lld NAMES_PER_DIR
+find_library(LLD_LIBRARY NAMES lld-19.0 lld190 lld NAMES_PER_DIR
HINTS ${LLVM_LIBDIRS}
PATHS
- /usr/lib/llvm-18/lib
- /usr/local/llvm180/lib
- /usr/local/llvm18/lib
- /usr/local/opt/llvm@18/lib
- /opt/homebrew/opt/llvm@18/lib
+ /usr/lib/llvm-19/lib
+ /usr/local/llvm190/lib
+ /usr/local/llvm19/lib
+ /usr/local/opt/llvm@19/lib
+ /opt/homebrew/opt/llvm@19/lib
)
if(EXISTS ${LLD_LIBRARY})
set(LLD_LIBRARIES ${LLD_LIBRARY})
@@ -34,11 +34,11 @@ else()
HINTS ${LLVM_LIBDIRS}
PATHS
${LLD_LIBDIRS}
- /usr/lib/llvm-18/lib
- /usr/local/llvm180/lib
- /usr/local/llvm18/lib
- /usr/local/opt/llvm@18/lib
- /opt/homebrew/opt/llvm@18/lib
+ /usr/lib/llvm-19/lib
+ /usr/local/llvm190/lib
+ /usr/local/llvm19/lib
+ /usr/local/opt/llvm@19/lib
+ /opt/homebrew/opt/llvm@19/lib
/mingw64/lib
/c/msys64/mingw64/lib
c:/msys64/mingw64/lib)
diff --git a/cmake/Findllvm.cmake b/cmake/Findllvm.cmake
index c4eb49fe7600..5bc874ec4279 100644
--- a/cmake/Findllvm.cmake
+++ b/cmake/Findllvm.cmake
@@ -17,12 +17,12 @@ if(ZIG_USE_LLVM_CONFIG)
# terminate when the right LLVM version is not found.
unset(LLVM_CONFIG_EXE CACHE)
find_program(LLVM_CONFIG_EXE
- NAMES llvm-config-18 llvm-config-18.0 llvm-config180 llvm-config18 llvm-config NAMES_PER_DIR
+ NAMES llvm-config-19 llvm-config-19.0 llvm-config190 llvm-config19 llvm-config NAMES_PER_DIR
PATHS
"/mingw64/bin"
"/c/msys64/mingw64/bin"
"c:/msys64/mingw64/bin"
- "C:/Libraries/llvm-18.0.0/bin")
+ "C:/Libraries/llvm-19.0.0/bin")
if ("${LLVM_CONFIG_EXE}" STREQUAL "LLVM_CONFIG_EXE-NOTFOUND")
if (NOT LLVM_CONFIG_ERROR_MESSAGES STREQUAL "")
@@ -40,9 +40,9 @@ if(ZIG_USE_LLVM_CONFIG)
OUTPUT_STRIP_TRAILING_WHITESPACE)
get_filename_component(LLVM_CONFIG_DIR "${LLVM_CONFIG_EXE}" DIRECTORY)
- if("${LLVM_CONFIG_VERSION}" VERSION_LESS 18 OR "${LLVM_CONFIG_VERSION}" VERSION_EQUAL 19 OR "${LLVM_CONFIG_VERSION}" VERSION_GREATER 19)
+ if("${LLVM_CONFIG_VERSION}" VERSION_LESS 19 OR "${LLVM_CONFIG_VERSION}" VERSION_EQUAL 20 OR "${LLVM_CONFIG_VERSION}" VERSION_GREATER 20)
# Save the error message, in case this is the last llvm-config we find
- list(APPEND LLVM_CONFIG_ERROR_MESSAGES "expected LLVM 18.x but found ${LLVM_CONFIG_VERSION} using ${LLVM_CONFIG_EXE}")
+ list(APPEND LLVM_CONFIG_ERROR_MESSAGES "expected LLVM 19.x but found ${LLVM_CONFIG_VERSION} using ${LLVM_CONFIG_EXE}")
# Ignore this directory and try the search again
list(APPEND CMAKE_IGNORE_PATH "${LLVM_CONFIG_DIR}")
@@ -63,12 +63,12 @@ if(ZIG_USE_LLVM_CONFIG)
ERROR_VARIABLE LLVM_CONFIG_ERROR
ERROR_STRIP_TRAILING_WHITESPACE)
- if (LLVM_CONFIG_ERROR)
+ if (LLVM_CONFIG_ERROR)
# Save the error message, in case this is the last llvm-config we find
if (ZIG_SHARED_LLVM)
- list(APPEND LLVM_CONFIG_ERROR_MESSAGES "LLVM 18.x found at ${LLVM_CONFIG_EXE} does not support linking as a shared library")
+ list(APPEND LLVM_CONFIG_ERROR_MESSAGES "LLVM 19.x found at ${LLVM_CONFIG_EXE} does not support linking as a shared library")
else()
- list(APPEND LLVM_CONFIG_ERROR_MESSAGES "LLVM 18.x found at ${LLVM_CONFIG_EXE} does not support linking as a static library")
+ list(APPEND LLVM_CONFIG_ERROR_MESSAGES "LLVM 19.x found at ${LLVM_CONFIG_EXE} does not support linking as a static library")
endif()
# Ignore this directory and try the search again
@@ -200,6 +200,7 @@ else()
FIND_AND_ADD_LLVM_LIB(LLVMTextAPIBinaryReader)
FIND_AND_ADD_LLVM_LIB(LLVMCoverage)
FIND_AND_ADD_LLVM_LIB(LLVMLineEditor)
+ FIND_AND_ADD_LLVM_LIB(LLVMSandboxIR)
FIND_AND_ADD_LLVM_LIB(LLVMXCoreDisassembler)
FIND_AND_ADD_LLVM_LIB(LLVMXCoreCodeGen)
FIND_AND_ADD_LLVM_LIB(LLVMXCoreDesc)
@@ -335,6 +336,7 @@ else()
FIND_AND_ADD_LLVM_LIB(LLVMDWARFLinkerParallel)
FIND_AND_ADD_LLVM_LIB(LLVMDWARFLinkerClassic)
FIND_AND_ADD_LLVM_LIB(LLVMDWARFLinker)
+ FIND_AND_ADD_LLVM_LIB(LLVMCodeGenData)
FIND_AND_ADD_LLVM_LIB(LLVMGlobalISel)
FIND_AND_ADD_LLVM_LIB(LLVMMIRParser)
FIND_AND_ADD_LLVM_LIB(LLVMAsmPrinter)
diff --git a/doc/langref.html.in b/doc/langref.html.in
index cea86e895541..9f12829349fa 100644
--- a/doc/langref.html.in
+++ b/doc/langref.html.in
@@ -2495,6 +2495,53 @@ or
{#code|test_exhaustive_switch.zig#}
+ {#header_close#}
+
+ {#header_open|Labeled switch#}
+
+ When a switch statement is labeled, it can be referenced from a
+ {#syntax#}break{#endsyntax#} or {#syntax#}continue{#endsyntax#}.
+ {#syntax#}break{#endsyntax#} will return a value from the {#syntax#}
+ switch{#endsyntax#}.
+
+
+ A {#syntax#}continue{#endsyntax#} targeting a switch must have an
+ operand. When executed, it will jump to the matching prong, as if the
+ {#syntax#}switch{#endsyntax#} were executed again with the {#syntax#}
+ continue{#endsyntax#}'s operand replacing the initial switch value.
+
+
+ {#code|test_switch_continue.zig#}
+
+
+ Semantically, this is equivalent to the following loop:
+
+ {#code|test_switch_continue_equivalent.zig#}
+
+
+ This can improve clarity of (for example) state machines, where the syntax {#syntax#}continue :sw .next_state{#endsyntax#} is unambiguous, explicit, and immediately understandable.
+
+
+ However, the motivating example is a switch on each element of an array, where using a single switch can improve clarity and performance:
+
+ {#code|test_switch_dispatch_loop.zig#}
+
+
+ If the operand to {#syntax#}continue{#endsyntax#} is
+ {#link|comptime#}-known, then it can be lowered to an unconditional branch
+ to the relevant case. Such a branch is perfectly predicted, and hence
+ typically very fast to execute.
+
+
+
+ If the operand is runtime-known, each {#syntax#}continue{#endsyntax#} can
+ embed a conditional branch inline (ideally through a jump table), which
+ allows a CPU to predict its target independently of any other prong. A
+ loop-based lowering would force every branch through the same dispatch
+ point, hindering branch prediction.
+
+
+
{#header_close#}
{#header_open|Inline Switch Prongs#}
diff --git a/doc/langref/test_switch_continue.zig b/doc/langref/test_switch_continue.zig
new file mode 100644
index 000000000000..dc6ba67b0e1c
--- /dev/null
+++ b/doc/langref/test_switch_continue.zig
@@ -0,0 +1,26 @@
+const std = @import("std");
+
+test "switch continue" {
+ sw: switch (@as(i32, 5)) {
+ 5 => continue :sw 4,
+
+ // `continue` can occur multiple times within a single switch prong.
+ 2...4 => |v| {
+ if (v > 3) {
+ continue :sw 2;
+ } else if (v == 3) {
+
+ // `break` can target labeled loops.
+ break :sw;
+ }
+
+ continue :sw 1;
+ },
+
+ 1 => return,
+
+ else => unreachable,
+ }
+}
+
+// test
diff --git a/doc/langref/test_switch_continue_equivalent.zig b/doc/langref/test_switch_continue_equivalent.zig
new file mode 100644
index 000000000000..8e2fce8f70b9
--- /dev/null
+++ b/doc/langref/test_switch_continue_equivalent.zig
@@ -0,0 +1,28 @@
+const std = @import("std");
+
+test "switch continue, equivalent loop" {
+ var sw: i32 = 5;
+ while (true) {
+ switch (sw) {
+ 5 => {
+ sw = 4;
+ continue;
+ },
+ 2...4 => |v| {
+ if (v > 3) {
+ sw = 2;
+ continue;
+ } else if (v == 3) {
+ break;
+ }
+
+ sw = 1;
+ continue;
+ },
+ 1 => return,
+ else => unreachable,
+ }
+ }
+}
+
+// test
diff --git a/doc/langref/test_switch_dispatch_loop.zig b/doc/langref/test_switch_dispatch_loop.zig
new file mode 100644
index 000000000000..cc7af1704e65
--- /dev/null
+++ b/doc/langref/test_switch_dispatch_loop.zig
@@ -0,0 +1,38 @@
+const std = @import("std");
+const expectEqual = std.testing.expectEqual;
+
+const Instruction = enum {
+ add,
+ mul,
+ end,
+};
+
+fn evaluate(initial_stack: []const i32, code: []const Instruction) !i32 {
+ var stack = try std.BoundedArray(i32, 8).fromSlice(initial_stack);
+ var ip: usize = 0;
+
+ return vm: switch (code[ip]) {
+ // Because all code after `continue` is unreachable, this branch does
+ // not provide a result.
+ .add => {
+ try stack.append(stack.pop() + stack.pop());
+
+ ip += 1;
+ continue :vm code[ip];
+ },
+ .mul => {
+ try stack.append(stack.pop() * stack.pop());
+
+ ip += 1;
+ continue :vm code[ip];
+ },
+ .end => stack.pop(),
+ };
+}
+
+test "evaluate" {
+ const result = try evaluate(&.{ 7, 2, -3 }, &.{ .mul, .add, .end });
+ try expectEqual(1, result);
+}
+
+// test
diff --git a/doc/langref/test_tagged_union.zig b/doc/langref/test_tagged_union.zig
index 20e06c64b11f..dbe765f5b832 100644
--- a/doc/langref/test_tagged_union.zig
+++ b/doc/langref/test_tagged_union.zig
@@ -15,8 +15,8 @@ test "switch on tagged union" {
try expect(@as(ComplexTypeTag, c) == ComplexTypeTag.ok);
switch (c) {
- ComplexTypeTag.ok => |value| try expect(value == 42),
- ComplexTypeTag.not_ok => unreachable,
+ .ok => |value| try expect(value == 42),
+ .not_ok => unreachable,
}
}
diff --git a/doc/langref/wasi_args.zig b/doc/langref/wasi_args.zig
index b1e7e7cbb15d..6801e67f0c7a 100644
--- a/doc/langref/wasi_args.zig
+++ b/doc/langref/wasi_args.zig
@@ -1,7 +1,7 @@
const std = @import("std");
pub fn main() !void {
- var general_purpose_allocator = std.heap.GeneralPurposeAllocator(.{}){};
+ var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .init;
const gpa = general_purpose_allocator.allocator();
const args = try std.process.argsAlloc(gpa);
defer std.process.argsFree(gpa, args);
diff --git a/doc/langref/wasi_preopens.zig b/doc/langref/wasi_preopens.zig
index 2a2f8dcd1bca..5a167bc8dbd9 100644
--- a/doc/langref/wasi_preopens.zig
+++ b/doc/langref/wasi_preopens.zig
@@ -2,7 +2,7 @@ const std = @import("std");
const fs = std.fs;
pub fn main() !void {
- var general_purpose_allocator = std.heap.GeneralPurposeAllocator(.{}){};
+ var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .init;
const gpa = general_purpose_allocator.allocator();
var arena_instance = std.heap.ArenaAllocator.init(gpa);
diff --git a/lib/compiler/aro/aro.zig b/lib/compiler/aro/aro.zig
index c39972f5c933..8e3da2aa9763 100644
--- a/lib/compiler/aro/aro.zig
+++ b/lib/compiler/aro/aro.zig
@@ -23,6 +23,7 @@ pub const version_str = backend.version_str;
pub const version = backend.version;
test {
+ _ = @import("aro/annex_g.zig");
_ = @import("aro/Builtins.zig");
_ = @import("aro/char_info.zig");
_ = @import("aro/Compilation.zig");
diff --git a/lib/compiler/aro/aro/Attribute.zig b/lib/compiler/aro/aro/Attribute.zig
index 4671028b8fa5..a5b78b8463a4 100644
--- a/lib/compiler/aro/aro/Attribute.zig
+++ b/lib/compiler/aro/aro/Attribute.zig
@@ -38,12 +38,64 @@ pub const Kind = enum {
}
};
+pub const Iterator = struct {
+ source: union(enum) {
+ ty: Type,
+ slice: []const Attribute,
+ },
+ index: usize,
+
+ pub fn initSlice(slice: ?[]const Attribute) Iterator {
+ return .{ .source = .{ .slice = slice orelse &.{} }, .index = 0 };
+ }
+
+ pub fn initType(ty: Type) Iterator {
+ return .{ .source = .{ .ty = ty }, .index = 0 };
+ }
+
+ /// returns the next attribute as well as its index within the slice or current type
+ /// The index can be used to determine when a nested type has been recursed into
+ pub fn next(self: *Iterator) ?struct { Attribute, usize } {
+ switch (self.source) {
+ .slice => |slice| {
+ if (self.index < slice.len) {
+ defer self.index += 1;
+ return .{ slice[self.index], self.index };
+ }
+ },
+ .ty => |ty| {
+ switch (ty.specifier) {
+ .typeof_type => {
+ self.* = .{ .source = .{ .ty = ty.data.sub_type.* }, .index = 0 };
+ return self.next();
+ },
+ .typeof_expr => {
+ self.* = .{ .source = .{ .ty = ty.data.expr.ty }, .index = 0 };
+ return self.next();
+ },
+ .attributed => {
+ if (self.index < ty.data.attributed.attributes.len) {
+ defer self.index += 1;
+ return .{ ty.data.attributed.attributes[self.index], self.index };
+ }
+ self.* = .{ .source = .{ .ty = ty.data.attributed.base }, .index = 0 };
+ return self.next();
+ },
+ else => {},
+ }
+ },
+ }
+ return null;
+ }
+};
+
pub const ArgumentType = enum {
string,
identifier,
int,
alignment,
float,
+ complex_float,
expression,
nullptr_t,
@@ -54,6 +106,7 @@ pub const ArgumentType = enum {
.int, .alignment => "an integer constant",
.nullptr_t => "nullptr",
.float => "a floating point number",
+ .complex_float => "a complex floating point number",
.expression => "an expression",
};
}
@@ -65,7 +118,7 @@ pub fn requiredArgCount(attr: Tag) u32 {
inline else => |tag| {
comptime var needed = 0;
comptime {
- const fields = std.meta.fields(@field(attributes, @tagName(tag)));
+ const fields = @typeInfo(@field(attributes, @tagName(tag))).@"struct".fields;
for (fields) |arg_field| {
if (!mem.eql(u8, arg_field.name, "__name_tok") and @typeInfo(arg_field.type) != .optional) needed += 1;
}
@@ -81,7 +134,7 @@ pub fn maxArgCount(attr: Tag) u32 {
inline else => |tag| {
comptime var max = 0;
comptime {
- const fields = std.meta.fields(@field(attributes, @tagName(tag)));
+ const fields = @typeInfo(@field(attributes, @tagName(tag))).@"struct".fields;
for (fields) |arg_field| {
if (!mem.eql(u8, arg_field.name, "__name_tok")) max += 1;
}
@@ -106,7 +159,7 @@ pub const Formatting = struct {
switch (attr) {
.calling_convention => unreachable,
inline else => |tag| {
- const fields = std.meta.fields(@field(attributes, @tagName(tag)));
+ const fields = @typeInfo(@field(attributes, @tagName(tag))).@"struct".fields;
if (fields.len == 0) unreachable;
const Unwrapped = UnwrapOptional(fields[0].type);
@@ -123,14 +176,13 @@ pub const Formatting = struct {
switch (attr) {
.calling_convention => unreachable,
inline else => |tag| {
- const fields = std.meta.fields(@field(attributes, @tagName(tag)));
+ const fields = @typeInfo(@field(attributes, @tagName(tag))).@"struct".fields;
if (fields.len == 0) unreachable;
const Unwrapped = UnwrapOptional(fields[0].type);
if (@typeInfo(Unwrapped) != .@"enum") unreachable;
const enum_fields = @typeInfo(Unwrapped).@"enum".fields;
- @setEvalBranchQuota(3000);
const quote = comptime quoteChar(@enumFromInt(@intFromEnum(tag)));
comptime var values: []const u8 = quote ++ enum_fields[0].name ++ quote;
inline for (enum_fields[1..]) |enum_field| {
@@ -148,7 +200,7 @@ pub fn wantsIdentEnum(attr: Tag) bool {
switch (attr) {
.calling_convention => return false,
inline else => |tag| {
- const fields = std.meta.fields(@field(attributes, @tagName(tag)));
+ const fields = @typeInfo(@field(attributes, @tagName(tag))).@"struct".fields;
if (fields.len == 0) return false;
const Unwrapped = UnwrapOptional(fields[0].type);
@@ -162,7 +214,7 @@ pub fn wantsIdentEnum(attr: Tag) bool {
pub fn diagnoseIdent(attr: Tag, arguments: *Arguments, ident: []const u8) ?Diagnostics.Message {
switch (attr) {
inline else => |tag| {
- const fields = std.meta.fields(@field(attributes, @tagName(tag)));
+ const fields = @typeInfo(@field(attributes, @tagName(tag))).@"struct".fields;
if (fields.len == 0) unreachable;
const Unwrapped = UnwrapOptional(fields[0].type);
if (@typeInfo(Unwrapped) != .@"enum") unreachable;
@@ -181,7 +233,7 @@ pub fn diagnoseIdent(attr: Tag, arguments: *Arguments, ident: []const u8) ?Diagn
pub fn wantsAlignment(attr: Tag, idx: usize) bool {
switch (attr) {
inline else => |tag| {
- const fields = std.meta.fields(@field(attributes, @tagName(tag)));
+ const fields = @typeInfo(@field(attributes, @tagName(tag))).@"struct".fields;
if (fields.len == 0) return false;
return switch (idx) {
@@ -195,7 +247,7 @@ pub fn wantsAlignment(attr: Tag, idx: usize) bool {
pub fn diagnoseAlignment(attr: Tag, arguments: *Arguments, arg_idx: u32, res: Parser.Result, p: *Parser) !?Diagnostics.Message {
switch (attr) {
inline else => |tag| {
- const arg_fields = std.meta.fields(@field(attributes, @tagName(tag)));
+ const arg_fields = @typeInfo(@field(attributes, @tagName(tag))).@"struct".fields;
if (arg_fields.len == 0) unreachable;
switch (arg_idx) {
@@ -249,8 +301,7 @@ fn diagnoseField(
},
.bytes => |bytes| {
if (Wanted == Value) {
- std.debug.assert(node.tag == .string_literal_expr);
- if (!node.ty.elemType().is(.char) and !node.ty.elemType().is(.uchar)) {
+ if (node.tag != .string_literal_expr or (!node.ty.elemType().is(.char) and !node.ty.elemType().is(.uchar))) {
return .{
.tag = .attribute_requires_string,
.extra = .{ .str = decl.name },
@@ -264,7 +315,6 @@ fn diagnoseField(
@field(@field(arguments, decl.name), field.name) = enum_val;
return null;
} else {
- @setEvalBranchQuota(3000);
return .{
.tag = .unknown_attr_enum,
.extra = .{ .attr_enum = .{ .tag = std.meta.stringToEnum(Tag, decl.name).? } },
@@ -278,8 +328,19 @@ fn diagnoseField(
.int => .int,
.bytes => .string,
.float => .float,
+ .complex => .complex_float,
.null => .nullptr_t,
- else => unreachable,
+ .int_ty,
+ .float_ty,
+ .complex_ty,
+ .ptr_ty,
+ .noreturn_ty,
+ .void_ty,
+ .func_ty,
+ .array_ty,
+ .vector_ty,
+ .record_ty,
+ => unreachable,
});
}
@@ -309,7 +370,7 @@ pub fn diagnose(attr: Tag, arguments: *Arguments, arg_idx: u32, res: Parser.Resu
.tag = .attribute_too_many_args,
.extra = .{ .attr_arg_count = .{ .attribute = attr, .expected = max_arg_count } },
};
- const arg_fields = std.meta.fields(@field(attributes, decl.name));
+ const arg_fields = @typeInfo(@field(attributes, decl.name)).@"struct".fields;
switch (arg_idx) {
inline 0...arg_fields.len - 1 => |arg_i| {
return diagnoseField(decl, arg_fields[arg_i], UnwrapOptional(arg_fields[arg_i].type), arguments, res, node, p);
@@ -645,7 +706,7 @@ pub const Arguments = blk: {
var union_fields: [decls.len]ZigType.UnionField = undefined;
for (decls, &union_fields) |decl, *field| {
field.* = .{
- .name = decl.name ++ "",
+ .name = decl.name,
.type = @field(attributes, decl.name),
.alignment = 0,
};
@@ -730,7 +791,6 @@ pub fn applyVariableAttributes(p: *Parser, ty: Type, attr_buf_start: usize, tag:
const toks = p.attr_buf.items(.tok)[attr_buf_start..];
p.attr_application_buf.items.len = 0;
var base_ty = ty;
- if (base_ty.specifier == .attributed) base_ty = base_ty.data.attributed.base;
var common = false;
var nocommon = false;
for (attrs, toks) |attr, tok| switch (attr.tag) {
@@ -772,15 +832,10 @@ pub fn applyVariableAttributes(p: *Parser, ty: Type, attr_buf_start: usize, tag:
.copy,
.tls_model,
.visibility,
- => std.debug.panic("apply variable attribute {s}", .{@tagName(attr.tag)}),
+ => |t| try p.errExtra(.attribute_todo, tok, .{ .attribute_todo = .{ .tag = t, .kind = .variables } }),
else => try ignoredAttrErr(p, tok, attr.tag, "variables"),
};
- const existing = ty.getAttributes();
- if (existing.len == 0 and p.attr_application_buf.items.len == 0) return base_ty;
- if (existing.len == 0) return base_ty.withAttributes(p.arena, p.attr_application_buf.items);
-
- const attributed_type = try Type.Attributed.create(p.arena, base_ty, existing, p.attr_application_buf.items);
- return Type{ .specifier = .attributed, .data = .{ .attributed = attributed_type } };
+ return base_ty.withAttributes(p.arena, p.attr_application_buf.items);
}
pub fn applyFieldAttributes(p: *Parser, field_ty: *Type, attr_buf_start: usize) ![]const Attribute {
@@ -789,7 +844,7 @@ pub fn applyFieldAttributes(p: *Parser, field_ty: *Type, attr_buf_start: usize)
p.attr_application_buf.items.len = 0;
for (attrs, toks) |attr, tok| switch (attr.tag) {
// zig fmt: off
- .@"packed", .may_alias, .deprecated, .unavailable, .unused, .warn_if_not_aligned, .mode,
+ .@"packed", .may_alias, .deprecated, .unavailable, .unused, .warn_if_not_aligned, .mode, .warn_unused_result, .nodiscard,
=> try p.attr_application_buf.append(p.gpa, attr),
// zig fmt: on
.vector_size => try attr.applyVectorSize(p, tok, field_ty),
@@ -805,7 +860,6 @@ pub fn applyTypeAttributes(p: *Parser, ty: Type, attr_buf_start: usize, tag: ?Di
const toks = p.attr_buf.items(.tok)[attr_buf_start..];
p.attr_application_buf.items.len = 0;
var base_ty = ty;
- if (base_ty.specifier == .attributed) base_ty = base_ty.data.attributed.base;
for (attrs, toks) |attr, tok| switch (attr.tag) {
// zig fmt: off
.@"packed", .may_alias, .deprecated, .unavailable, .unused, .warn_if_not_aligned, .mode,
@@ -823,22 +877,10 @@ pub fn applyTypeAttributes(p: *Parser, ty: Type, attr_buf_start: usize, tag: ?Di
.copy,
.scalar_storage_order,
.nonstring,
- => std.debug.panic("apply type attribute {s}", .{@tagName(attr.tag)}),
+ => |t| try p.errExtra(.attribute_todo, tok, .{ .attribute_todo = .{ .tag = t, .kind = .types } }),
else => try ignoredAttrErr(p, tok, attr.tag, "types"),
};
-
- const existing = ty.getAttributes();
- // TODO: the alignment annotation on a type should override
- // the decl it refers to. This might not be true for others. Maybe bug.
-
- // if there are annotations on this type def use those.
- if (p.attr_application_buf.items.len > 0) {
- return try base_ty.withAttributes(p.arena, p.attr_application_buf.items);
- } else if (existing.len > 0) {
- // else use the ones on the typedef decl we were refering to.
- return try base_ty.withAttributes(p.arena, existing);
- }
- return base_ty;
+ return base_ty.withAttributes(p.arena, p.attr_application_buf.items);
}
pub fn applyFunctionAttributes(p: *Parser, ty: Type, attr_buf_start: usize) !Type {
@@ -846,7 +888,6 @@ pub fn applyFunctionAttributes(p: *Parser, ty: Type, attr_buf_start: usize) !Typ
const toks = p.attr_buf.items(.tok)[attr_buf_start..];
p.attr_application_buf.items.len = 0;
var base_ty = ty;
- if (base_ty.specifier == .attributed) base_ty = base_ty.data.attributed.base;
var hot = false;
var cold = false;
var @"noinline" = false;
@@ -896,6 +937,13 @@ pub fn applyFunctionAttributes(p: *Parser, ty: Type, attr_buf_start: usize) !Typ
else => try p.errStr(.callconv_not_supported, tok, p.tok_ids[tok].lexeme().?),
},
},
+ .malloc => {
+ if (base_ty.returnType().isPtr()) {
+ try p.attr_application_buf.append(p.gpa, attr);
+ } else {
+ try ignoredAttrErr(p, tok, attr.tag, "functions that do not return pointers");
+ }
+ },
.access,
.alloc_align,
.alloc_size,
@@ -908,7 +956,6 @@ pub fn applyFunctionAttributes(p: *Parser, ty: Type, attr_buf_start: usize) !Typ
.ifunc,
.interrupt,
.interrupt_handler,
- .malloc,
.no_address_safety_analysis,
.no_icf,
.no_instrument_function,
@@ -937,7 +984,7 @@ pub fn applyFunctionAttributes(p: *Parser, ty: Type, attr_buf_start: usize) !Typ
.visibility,
.weakref,
.zero_call_used_regs,
- => std.debug.panic("apply type attribute {s}", .{@tagName(attr.tag)}),
+ => |t| try p.errExtra(.attribute_todo, tok, .{ .attribute_todo = .{ .tag = t, .kind = .functions } }),
else => try ignoredAttrErr(p, tok, attr.tag, "functions"),
};
return ty.withAttributes(p.arena, p.attr_application_buf.items);
@@ -1043,11 +1090,14 @@ fn applyTransparentUnion(attr: Attribute, p: *Parser, tok: TokenIndex, ty: Type)
}
fn applyVectorSize(attr: Attribute, p: *Parser, tok: TokenIndex, ty: *Type) !void {
- if (!(ty.isInt() or ty.isFloat()) or !ty.isReal()) {
- const orig_ty = try p.typeStr(ty.*);
- ty.* = Type.invalid;
- return p.errStr(.invalid_vec_elem_ty, tok, orig_ty);
+ const base = ty.base();
+ const is_enum = ty.is(.@"enum");
+ if (!(ty.isInt() or ty.isFloat()) or !ty.isReal() or (is_enum and p.comp.langopts.emulate == .gcc)) {
+ try p.errStr(.invalid_vec_elem_ty, tok, try p.typeStr(ty.*));
+ return error.ParsingFailed;
}
+ if (is_enum) return;
+
const vec_bytes = attr.args.vector_size.bytes;
const ty_size = ty.sizeof(p.comp).?;
if (vec_bytes % ty_size != 0) {
@@ -1057,7 +1107,7 @@ fn applyVectorSize(attr: Attribute, p: *Parser, tok: TokenIndex, ty: *Type) !voi
const arr_ty = try p.arena.create(Type.Array);
arr_ty.* = .{ .elem = ty.*, .len = vec_size };
- ty.* = Type{
+ base.* = .{
.specifier = .vector,
.data = .{ .array = arr_ty },
};
diff --git a/lib/compiler/aro/aro/Attribute/names.zig b/lib/compiler/aro/aro/Attribute/names.zig
index d31538906664..c0732b6118be 100644
--- a/lib/compiler/aro/aro/Attribute/names.zig
+++ b/lib/compiler/aro/aro/Attribute/names.zig
@@ -69,6 +69,7 @@ pub const longest_name = 30;
/// If found, returns the index of the node within the `dafsa` array.
/// Otherwise, returns `null`.
pub fn findInList(first_child_index: u16, char: u8) ?u16 {
+ @setEvalBranchQuota(206);
var index = first_child_index;
while (true) {
if (dafsa[index].char == char) return index;
@@ -787,7 +788,7 @@ const dafsa = [_]Node{
.{ .char = 'i', .end_of_word = false, .end_of_list = true, .number = 1, .child_index = 215 },
};
pub const data = blk: {
- @setEvalBranchQuota(103);
+ @setEvalBranchQuota(721);
break :blk [_]@This(){
// access
.{ .tag = @enumFromInt(0), .properties = .{ .tag = .access, .gnu = true } },
diff --git a/lib/compiler/aro/aro/Builtins.zig b/lib/compiler/aro/aro/Builtins.zig
index be24a3ff6091..fa92de328a2d 100644
--- a/lib/compiler/aro/aro/Builtins.zig
+++ b/lib/compiler/aro/aro/Builtins.zig
@@ -350,7 +350,7 @@ test Iterator {
}
test "All builtins" {
- var comp = Compilation.init(std.testing.allocator);
+ var comp = Compilation.init(std.testing.allocator, std.fs.cwd());
defer comp.deinit();
_ = try comp.generateBuiltinMacros(.include_system_defines);
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
@@ -373,7 +373,7 @@ test "All builtins" {
test "Allocation failures" {
const Test = struct {
fn testOne(allocator: std.mem.Allocator) !void {
- var comp = Compilation.init(allocator);
+ var comp = Compilation.init(allocator, std.fs.cwd());
defer comp.deinit();
_ = try comp.generateBuiltinMacros(.include_system_defines);
var arena = std.heap.ArenaAllocator.init(comp.gpa);
diff --git a/lib/compiler/aro/aro/Builtins/Builtin.zig b/lib/compiler/aro/aro/Builtins/Builtin.zig
index c5cf98608b41..6e5217b4da32 100644
--- a/lib/compiler/aro/aro/Builtins/Builtin.zig
+++ b/lib/compiler/aro/aro/Builtins/Builtin.zig
@@ -71,6 +71,7 @@ pub const longest_name = 43;
/// If found, returns the index of the node within the `dafsa` array.
/// Otherwise, returns `null`.
pub fn findInList(first_child_index: u16, char: u8) ?u16 {
+ @setEvalBranchQuota(7972);
var index = first_child_index;
while (true) {
if (dafsa[index].char == char) return index;
@@ -5165,7 +5166,7 @@ const dafsa = [_]Node{
.{ .char = 'e', .end_of_word = false, .end_of_list = true, .number = 1, .child_index = 4913 },
};
pub const data = blk: {
- @setEvalBranchQuota(30_000);
+ @setEvalBranchQuota(27902);
break :blk [_]@This(){
// _Block_object_assign
.{ .tag = @enumFromInt(0), .properties = .{ .param_str = "vv*vC*iC", .header = .blocks, .attributes = .{ .lib_function_without_prefix = true } } },
diff --git a/lib/compiler/aro/aro/Builtins/eval.zig b/lib/compiler/aro/aro/Builtins/eval.zig
new file mode 100644
index 000000000000..008da152d4a9
--- /dev/null
+++ b/lib/compiler/aro/aro/Builtins/eval.zig
@@ -0,0 +1,86 @@
+const std = @import("std");
+const backend = @import("../../backend.zig");
+const Interner = backend.Interner;
+const Builtins = @import("../Builtins.zig");
+const Builtin = Builtins.Builtin;
+const Parser = @import("../Parser.zig");
+const Tree = @import("../Tree.zig");
+const NodeIndex = Tree.NodeIndex;
+const Type = @import("../Type.zig");
+const Value = @import("../Value.zig");
+
+fn makeNan(comptime T: type, str: []const u8) T {
+ const UnsignedSameSize = std.meta.Int(.unsigned, @bitSizeOf(T));
+ const parsed = std.fmt.parseUnsigned(UnsignedSameSize, str[0 .. str.len - 1], 0) catch 0;
+ const bits: switch (T) {
+ f32 => u23,
+ f64 => u52,
+ f80 => u63,
+ f128 => u112,
+ else => @compileError("Invalid type for makeNan"),
+ } = @truncate(parsed);
+ return @bitCast(@as(UnsignedSameSize, bits) | @as(UnsignedSameSize, @bitCast(std.math.nan(T))));
+}
+
+pub fn eval(tag: Builtin.Tag, p: *Parser, args: []const NodeIndex) !Value {
+ const builtin = Builtin.fromTag(tag);
+ if (!builtin.properties.attributes.const_evaluable) return .{};
+
+ switch (tag) {
+ Builtin.tagFromName("__builtin_inff").?,
+ Builtin.tagFromName("__builtin_inf").?,
+ Builtin.tagFromName("__builtin_infl").?,
+ => {
+ const ty: Type = switch (tag) {
+ Builtin.tagFromName("__builtin_inff").? => .{ .specifier = .float },
+ Builtin.tagFromName("__builtin_inf").? => .{ .specifier = .double },
+ Builtin.tagFromName("__builtin_infl").? => .{ .specifier = .long_double },
+ else => unreachable,
+ };
+ const f: Interner.Key.Float = switch (ty.bitSizeof(p.comp).?) {
+ 32 => .{ .f32 = std.math.inf(f32) },
+ 64 => .{ .f64 = std.math.inf(f64) },
+ 80 => .{ .f80 = std.math.inf(f80) },
+ 128 => .{ .f128 = std.math.inf(f128) },
+ else => unreachable,
+ };
+ return Value.intern(p.comp, .{ .float = f });
+ },
+ Builtin.tagFromName("__builtin_isinf").? => blk: {
+ if (args.len == 0) break :blk;
+ const val = p.value_map.get(args[0]) orelse break :blk;
+ return Value.fromBool(val.isInf(p.comp));
+ },
+ Builtin.tagFromName("__builtin_isinf_sign").? => blk: {
+ if (args.len == 0) break :blk;
+ const val = p.value_map.get(args[0]) orelse break :blk;
+ switch (val.isInfSign(p.comp)) {
+ .unknown => {},
+ .finite => return Value.zero,
+ .positive => return Value.one,
+ .negative => return Value.int(@as(i64, -1), p.comp),
+ }
+ },
+ Builtin.tagFromName("__builtin_isnan").? => blk: {
+ if (args.len == 0) break :blk;
+ const val = p.value_map.get(args[0]) orelse break :blk;
+ return Value.fromBool(val.isNan(p.comp));
+ },
+ Builtin.tagFromName("__builtin_nan").? => blk: {
+ if (args.len == 0) break :blk;
+ const val = p.getDecayedStringLiteral(args[0]) orelse break :blk;
+ const bytes = p.comp.interner.get(val.ref()).bytes;
+
+ const f: Interner.Key.Float = switch ((Type{ .specifier = .double }).bitSizeof(p.comp).?) {
+ 32 => .{ .f32 = makeNan(f32, bytes) },
+ 64 => .{ .f64 = makeNan(f64, bytes) },
+ 80 => .{ .f80 = makeNan(f80, bytes) },
+ 128 => .{ .f128 = makeNan(f128, bytes) },
+ else => unreachable,
+ };
+ return Value.intern(p.comp, .{ .float = f });
+ },
+ else => {},
+ }
+ return .{};
+}
diff --git a/lib/compiler/aro/aro/CodeGen.zig b/lib/compiler/aro/aro/CodeGen.zig
index 0c87e7f744df..bfffb4117eea 100644
--- a/lib/compiler/aro/aro/CodeGen.zig
+++ b/lib/compiler/aro/aro/CodeGen.zig
@@ -42,11 +42,11 @@ node_tag: []const Tree.Tag,
node_data: []const Tree.Node.Data,
node_ty: []const Type,
wip_switch: *WipSwitch = undefined,
-symbols: std.ArrayListUnmanaged(Symbol) = .{},
-ret_nodes: std.ArrayListUnmanaged(Ir.Inst.Phi.Input) = .{},
-phi_nodes: std.ArrayListUnmanaged(Ir.Inst.Phi.Input) = .{},
-record_elem_buf: std.ArrayListUnmanaged(Interner.Ref) = .{},
-record_cache: std.AutoHashMapUnmanaged(*Type.Record, Interner.Ref) = .{},
+symbols: std.ArrayListUnmanaged(Symbol) = .empty,
+ret_nodes: std.ArrayListUnmanaged(Ir.Inst.Phi.Input) = .empty,
+phi_nodes: std.ArrayListUnmanaged(Ir.Inst.Phi.Input) = .empty,
+record_elem_buf: std.ArrayListUnmanaged(Interner.Ref) = .empty,
+record_cache: std.AutoHashMapUnmanaged(*Type.Record, Interner.Ref) = .empty,
cond_dummy_ty: ?Interner.Ref = null,
bool_invert: bool = false,
bool_end_label: Ir.Ref = .none,
diff --git a/lib/compiler/aro/aro/Compilation.zig b/lib/compiler/aro/aro/Compilation.zig
index f04df5001ef1..22ca9c00ed89 100644
--- a/lib/compiler/aro/aro/Compilation.zig
+++ b/lib/compiler/aro/aro/Compilation.zig
@@ -93,13 +93,13 @@ gpa: Allocator,
diagnostics: Diagnostics,
environment: Environment = .{},
-sources: std.StringArrayHashMapUnmanaged(Source) = .{},
-include_dirs: std.ArrayListUnmanaged([]const u8) = .{},
-system_include_dirs: std.ArrayListUnmanaged([]const u8) = .{},
+sources: std.StringArrayHashMapUnmanaged(Source) = .empty,
+include_dirs: std.ArrayListUnmanaged([]const u8) = .empty,
+system_include_dirs: std.ArrayListUnmanaged([]const u8) = .empty,
target: std.Target = @import("builtin").target,
-pragma_handlers: std.StringArrayHashMapUnmanaged(*Pragma) = .{},
+pragma_handlers: std.StringArrayHashMapUnmanaged(*Pragma) = .empty,
langopts: LangOpts = .{},
-generated_buf: std.ArrayListUnmanaged(u8) = .{},
+generated_buf: std.ArrayListUnmanaged(u8) = .empty,
builtins: Builtins = .{},
types: struct {
wchar: Type = undefined,
@@ -127,22 +127,27 @@ types: struct {
} = .{},
string_interner: StrInt = .{},
interner: Interner = .{},
+/// If this is not null, the directory containing the specified Source will be searched for includes
+/// Used by MS extensions which allow searching for includes relative to the directory of the main source file.
ms_cwd_source_id: ?Source.Id = null,
+cwd: std.fs.Dir,
-pub fn init(gpa: Allocator) Compilation {
+pub fn init(gpa: Allocator, cwd: std.fs.Dir) Compilation {
return .{
.gpa = gpa,
.diagnostics = Diagnostics.init(gpa),
+ .cwd = cwd,
};
}
/// Initialize Compilation with default environment,
/// pragma handlers and emulation mode set to target.
-pub fn initDefault(gpa: Allocator) !Compilation {
+pub fn initDefault(gpa: Allocator, cwd: std.fs.Dir) !Compilation {
var comp: Compilation = .{
.gpa = gpa,
.environment = try Environment.loadAll(gpa),
.diagnostics = Diagnostics.init(gpa),
+ .cwd = cwd,
};
errdefer comp.deinit();
try comp.addDefaultPragmaHandlers();
@@ -534,7 +539,7 @@ pub fn generateBuiltinMacros(comp: *Compilation, system_defines_mode: SystemDefi
if (system_defines_mode == .include_system_defines) {
try buf.appendSlice(
\\#define __VERSION__ "Aro
- ++ @import("../backend.zig").version_str ++ "\"\n" ++
+ ++ " " ++ @import("../backend.zig").version_str ++ "\"\n" ++
\\#define __Aro__
\\
);
@@ -550,6 +555,9 @@ pub fn generateBuiltinMacros(comp: *Compilation, system_defines_mode: SystemDefi
\\#define __STDC_NO_VLA__ 1
\\#define __STDC_UTF_16__ 1
\\#define __STDC_UTF_32__ 1
+ \\#define __STDC_EMBED_NOT_FOUND__ 0
+ \\#define __STDC_EMBED_FOUND__ 1
+ \\#define __STDC_EMBED_EMPTY__ 2
\\
);
if (comp.langopts.standard.StdCVersionMacro()) |stdc_version| {
@@ -719,8 +727,13 @@ fn generateBuiltinTypes(comp: *Compilation) !void {
try comp.generateNsConstantStringType();
}
+pub fn float80Type(comp: *const Compilation) ?Type {
+ if (comp.langopts.emulate != .gcc) return null;
+ return target_util.float80Type(comp.target);
+}
+
/// Smallest integer type with at least N bits
-fn intLeastN(comp: *const Compilation, bits: usize, signedness: std.builtin.Signedness) Type {
+pub fn intLeastN(comp: *const Compilation, bits: usize, signedness: std.builtin.Signedness) Type {
if (bits == 64 and (comp.target.isDarwin() or comp.target.isWasm())) {
// WebAssembly and Darwin use `long long` for `int_least64_t` and `int_fast64_t`.
return .{ .specifier = if (signedness == .signed) .long_long else .ulong_long };
@@ -903,7 +916,7 @@ fn generateNsConstantStringType(comp: *Compilation) !void {
comp.types.ns_constant_string.fields[2] = .{ .name = try StrInt.intern(comp, "str"), .ty = const_char_ptr };
comp.types.ns_constant_string.fields[3] = .{ .name = try StrInt.intern(comp, "length"), .ty = .{ .specifier = .long } };
comp.types.ns_constant_string.ty = .{ .specifier = .@"struct", .data = .{ .record = &comp.types.ns_constant_string.record } };
- record_layout.compute(&comp.types.ns_constant_string.record, comp.types.ns_constant_string.ty, comp, null);
+ record_layout.compute(&comp.types.ns_constant_string.record, comp.types.ns_constant_string.ty, comp, null) catch unreachable;
}
fn generateVaListType(comp: *Compilation) !Type {
@@ -911,12 +924,12 @@ fn generateVaListType(comp: *Compilation) !Type {
const kind: Kind = switch (comp.target.cpu.arch) {
.aarch64 => switch (comp.target.os.tag) {
.windows => @as(Kind, .char_ptr),
- .ios, .macos, .tvos, .watchos, .visionos => .char_ptr,
+ .ios, .macos, .tvos, .watchos => .char_ptr,
else => .aarch64_va_list,
},
.sparc, .wasm32, .wasm64, .bpfel, .bpfeb, .riscv32, .riscv64, .avr, .spirv32, .spirv64 => .void_ptr,
.powerpc => switch (comp.target.os.tag) {
- .ios, .macos, .tvos, .watchos, .visionos, .aix => @as(Kind, .char_ptr),
+ .ios, .macos, .tvos, .watchos, .aix => @as(Kind, .char_ptr),
else => return Type{ .specifier = .void }, // unknown
},
.x86, .msp430 => .char_ptr,
@@ -951,7 +964,7 @@ fn generateVaListType(comp: *Compilation) !Type {
record_ty.fields[3] = .{ .name = try StrInt.intern(comp, "__gr_offs"), .ty = .{ .specifier = .int } };
record_ty.fields[4] = .{ .name = try StrInt.intern(comp, "__vr_offs"), .ty = .{ .specifier = .int } };
ty = .{ .specifier = .@"struct", .data = .{ .record = record_ty } };
- record_layout.compute(record_ty, ty, comp, null);
+ record_layout.compute(record_ty, ty, comp, null) catch unreachable;
},
.x86_64_va_list => {
const record_ty = try arena.create(Type.Record);
@@ -969,7 +982,7 @@ fn generateVaListType(comp: *Compilation) !Type {
record_ty.fields[2] = .{ .name = try StrInt.intern(comp, "overflow_arg_area"), .ty = void_ptr };
record_ty.fields[3] = .{ .name = try StrInt.intern(comp, "reg_save_area"), .ty = void_ptr };
ty = .{ .specifier = .@"struct", .data = .{ .record = record_ty } };
- record_layout.compute(record_ty, ty, comp, null);
+ record_layout.compute(record_ty, ty, comp, null) catch unreachable;
},
}
if (kind == .char_ptr or kind == .void_ptr) {
@@ -988,13 +1001,28 @@ fn generateVaListType(comp: *Compilation) !Type {
fn generateIntMax(comp: *const Compilation, w: anytype, name: []const u8, ty: Type) !void {
const bit_count: u8 = @intCast(ty.sizeof(comp).? * 8);
const unsigned = ty.isUnsignedInt(comp);
- const max = if (bit_count == 128)
- @as(u128, if (unsigned) std.math.maxInt(u128) else std.math.maxInt(u128))
- else
- ty.maxInt(comp);
+ const max: u128 = switch (bit_count) {
+ 8 => if (unsigned) std.math.maxInt(u8) else std.math.maxInt(i8),
+ 16 => if (unsigned) std.math.maxInt(u16) else std.math.maxInt(i16),
+ 32 => if (unsigned) std.math.maxInt(u32) else std.math.maxInt(i32),
+ 64 => if (unsigned) std.math.maxInt(u64) else std.math.maxInt(i64),
+ 128 => if (unsigned) std.math.maxInt(u128) else std.math.maxInt(i128),
+ else => unreachable,
+ };
try w.print("#define __{s}_MAX__ {d}{s}\n", .{ name, max, ty.intValueSuffix(comp) });
}
+/// Largest value that can be stored in wchar_t
+pub fn wcharMax(comp: *const Compilation) u32 {
+ const unsigned = comp.types.wchar.isUnsignedInt(comp);
+ return switch (comp.types.wchar.bitSizeof(comp).?) {
+ 8 => if (unsigned) std.math.maxInt(u8) else std.math.maxInt(i8),
+ 16 => if (unsigned) std.math.maxInt(u16) else std.math.maxInt(i16),
+ 32 => if (unsigned) std.math.maxInt(u32) else std.math.maxInt(i32),
+ else => unreachable,
+ };
+}
+
fn generateExactWidthIntMax(comp: *const Compilation, w: anytype, specifier: Type.Specifier) !void {
var ty = Type{ .specifier = specifier };
const bit_count: u8 = @intCast(ty.sizeof(comp).? * 8);
@@ -1039,6 +1067,12 @@ pub fn nextLargestIntSameSign(comp: *const Compilation, ty: Type) ?Type {
return null;
}
+/// Maximum size of an array, in bytes
+pub fn maxArrayBytes(comp: *const Compilation) u64 {
+ const max_bits = @min(61, comp.target.ptrBitWidth());
+ return (@as(u64, 1) << @truncate(max_bits)) - 1;
+}
+
/// If `enum E { ... }` syntax has a fixed underlying integer type regardless of the presence of
/// __attribute__((packed)) or the range of values of the corresponding enumerator constants,
/// specify it here.
@@ -1060,7 +1094,7 @@ pub fn getCharSignedness(comp: *const Compilation) std.builtin.Signedness {
pub fn addBuiltinIncludeDir(comp: *Compilation, aro_dir: []const u8) !void {
var search_path = aro_dir;
while (std.fs.path.dirname(search_path)) |dirname| : (search_path = dirname) {
- var base_dir = std.fs.cwd().openDir(dirname, .{}) catch continue;
+ var base_dir = comp.cwd.openDir(dirname, .{}) catch continue;
defer base_dir.close();
base_dir.access("include/stddef.h", .{}) catch continue;
@@ -1266,7 +1300,7 @@ fn addSourceFromPathExtra(comp: *Compilation, path: []const u8, kind: Source.Kin
return error.FileNotFound;
}
- const file = try std.fs.cwd().openFile(path, .{});
+ const file = try comp.cwd.openFile(path, .{});
defer file.close();
const contents = file.readToEndAlloc(comp.gpa, std.math.maxInt(u32)) catch |err| switch (err) {
@@ -1349,10 +1383,9 @@ pub fn hasInclude(
return false;
}
- const cwd = std.fs.cwd();
if (std.fs.path.isAbsolute(filename)) {
if (which == .next) return false;
- return !std.meta.isError(cwd.access(filename, .{}));
+ return !std.meta.isError(comp.cwd.access(filename, .{}));
}
const cwd_source_id = switch (include_type) {
@@ -1372,7 +1405,7 @@ pub fn hasInclude(
while (try it.nextWithFile(filename, sf_allocator)) |found| {
defer sf_allocator.free(found.path);
- if (!std.meta.isError(cwd.access(found.path, .{}))) return true;
+ if (!std.meta.isError(comp.cwd.access(found.path, .{}))) return true;
}
return false;
}
@@ -1392,7 +1425,7 @@ fn getFileContents(comp: *Compilation, path: []const u8, limit: ?u32) ![]const u
return error.FileNotFound;
}
- const file = try std.fs.cwd().openFile(path, .{});
+ const file = try comp.cwd.openFile(path, .{});
defer file.close();
var buf = std.ArrayList(u8).init(comp.gpa);
@@ -1571,6 +1604,17 @@ pub fn hasBuiltinFunction(comp: *const Compilation, builtin: Builtin) bool {
}
}
+pub fn locSlice(comp: *const Compilation, loc: Source.Location) []const u8 {
+ var tmp_tokenizer = Tokenizer{
+ .buf = comp.getSource(loc.id).buf,
+ .langopts = comp.langopts,
+ .index = loc.byte_offset,
+ .source = .generated,
+ };
+ const tok = tmp_tokenizer.next();
+ return tmp_tokenizer.buf[tok.start..tok.end];
+}
+
pub const CharUnitSize = enum(u32) {
@"1" = 1,
@"2" = 2,
@@ -1590,7 +1634,7 @@ pub const addDiagnostic = Diagnostics.add;
test "addSourceFromReader" {
const Test = struct {
fn addSourceFromReader(str: []const u8, expected: []const u8, warning_count: u32, splices: []const u32) !void {
- var comp = Compilation.init(std.testing.allocator);
+ var comp = Compilation.init(std.testing.allocator, std.fs.cwd());
defer comp.deinit();
var buf_reader = std.io.fixedBufferStream(str);
@@ -1602,7 +1646,7 @@ test "addSourceFromReader" {
}
fn withAllocationFailures(allocator: std.mem.Allocator) !void {
- var comp = Compilation.init(allocator);
+ var comp = Compilation.init(allocator, std.fs.cwd());
defer comp.deinit();
_ = try comp.addSourceFromBuffer("path", "spliced\\\nbuffer\n");
@@ -1644,7 +1688,7 @@ test "addSourceFromReader - exhaustive check for carriage return elimination" {
const alen = alphabet.len;
var buf: [alphabet.len]u8 = [1]u8{alphabet[0]} ** alen;
- var comp = Compilation.init(std.testing.allocator);
+ var comp = Compilation.init(std.testing.allocator, std.fs.cwd());
defer comp.deinit();
var source_count: u32 = 0;
@@ -1672,7 +1716,7 @@ test "ignore BOM at beginning of file" {
const Test = struct {
fn run(buf: []const u8) !void {
- var comp = Compilation.init(std.testing.allocator);
+ var comp = Compilation.init(std.testing.allocator, std.fs.cwd());
defer comp.deinit();
var buf_reader = std.io.fixedBufferStream(buf);
diff --git a/lib/compiler/aro/aro/Diagnostics.zig b/lib/compiler/aro/aro/Diagnostics.zig
index 8f80e4393dc8..eb3bb31ee800 100644
--- a/lib/compiler/aro/aro/Diagnostics.zig
+++ b/lib/compiler/aro/aro/Diagnostics.zig
@@ -47,6 +47,10 @@ pub const Message = struct {
tag: Attribute.Tag,
specifier: enum { @"struct", @"union", @"enum" },
},
+ attribute_todo: struct {
+ tag: Attribute.Tag,
+ kind: enum { variables, fields, types, functions },
+ },
builtin_with_header: struct {
builtin: Builtin.Tag,
header: Header,
@@ -210,11 +214,14 @@ pub const Options = struct {
normalized: Kind = .default,
@"shift-count-negative": Kind = .default,
@"shift-count-overflow": Kind = .default,
+ @"constant-conversion": Kind = .default,
+ @"sign-conversion": Kind = .default,
+ nonnull: Kind = .default,
};
const Diagnostics = @This();
-list: std.ArrayListUnmanaged(Message) = .{},
+list: std.ArrayListUnmanaged(Message) = .empty,
arena: std.heap.ArenaAllocator,
fatal_errors: bool = false,
options: Options = .{},
@@ -222,14 +229,14 @@ errors: u32 = 0,
macro_backtrace_limit: u32 = 6,
pub fn warningExists(name: []const u8) bool {
- inline for (std.meta.fields(Options)) |f| {
+ inline for (@typeInfo(Options).@"struct".fields) |f| {
if (mem.eql(u8, f.name, name)) return true;
}
return false;
}
pub fn set(d: *Diagnostics, name: []const u8, to: Kind) !void {
- inline for (std.meta.fields(Options)) |f| {
+ inline for (@typeInfo(Options).@"struct".fields) |f| {
if (mem.eql(u8, f.name, name)) {
@field(d.options, f.name) = to;
return;
@@ -422,6 +429,10 @@ pub fn renderMessage(comp: *Compilation, m: anytype, msg: Message) void {
@tagName(msg.extra.ignored_record_attr.tag),
@tagName(msg.extra.ignored_record_attr.specifier),
}),
+ .attribute_todo => printRt(m, prop.msg, .{ "{s}", "{s}" }, .{
+ @tagName(msg.extra.attribute_todo.tag),
+ @tagName(msg.extra.attribute_todo.kind),
+ }),
.builtin_with_header => printRt(m, prop.msg, .{ "{s}", "{s}" }, .{
@tagName(msg.extra.builtin_with_header.header),
Builtin.nameFromTag(msg.extra.builtin_with_header.builtin).span(),
diff --git a/lib/compiler/aro/aro/Diagnostics/messages.zig b/lib/compiler/aro/aro/Diagnostics/messages.zig
index acc5fd562c27..c56641a4614d 100644
--- a/lib/compiler/aro/aro/Diagnostics/messages.zig
+++ b/lib/compiler/aro/aro/Diagnostics/messages.zig
@@ -107,6 +107,9 @@ pub const Tag = enum {
multiple_default,
previous_case,
expected_arguments,
+ callee_with_static_array,
+ array_argument_too_small,
+ non_null_argument,
expected_arguments_old,
expected_at_least_arguments,
invalid_static_star,
@@ -214,6 +217,7 @@ pub const Tag = enum {
pre_c23_compat,
unbound_vla,
array_too_large,
+ record_too_large,
incompatible_ptr_init,
incompatible_ptr_init_sign,
incompatible_ptr_assign,
@@ -349,6 +353,8 @@ pub const Tag = enum {
non_standard_escape_char,
invalid_pp_stringify_escape,
vla,
+ int_value_changed,
+ sign_conversion,
float_overflow_conversion,
float_out_of_range,
float_zero_conversion,
@@ -425,7 +431,8 @@ pub const Tag = enum {
bit_int,
unsigned_bit_int_too_small,
signed_bit_int_too_small,
- bit_int_too_big,
+ unsigned_bit_int_too_big,
+ signed_bit_int_too_big,
keyword_macro,
ptr_arithmetic_incomplete,
callconv_not_supported,
@@ -509,6 +516,9 @@ pub const Tag = enum {
complex_conj,
overflow_builtin_requires_int,
overflow_result_requires_ptr,
+ attribute_todo,
+ invalid_type_underlying_enum,
+ auto_type_self_initialized,
pub fn property(tag: Tag) Properties {
return named_data[@intFromEnum(tag)];
@@ -613,6 +623,9 @@ pub const Tag = enum {
.{ .msg = "multiple default cases in the same switch", .kind = .@"error" },
.{ .msg = "previous case defined here", .kind = .note },
.{ .msg = expected_arguments, .extra = .arguments, .kind = .@"error" },
+ .{ .msg = "callee declares array parameter as static here", .kind = .note },
+ .{ .msg = "array argument is too small; contains {d} elements, callee requires at least {d}", .extra = .arguments, .kind = .warning, .opt = W("array-bounds") },
+ .{ .msg = "null passed to a callee that requires a non-null argument", .kind = .warning, .opt = W("nonnull") },
.{ .msg = expected_arguments, .extra = .arguments, .kind = .warning },
.{ .msg = "expected at least {d} argument(s) got {d}", .extra = .arguments, .kind = .warning },
.{ .msg = "'static' may not be used with an unspecified variable length array size", .kind = .@"error" },
@@ -720,6 +733,7 @@ pub const Tag = enum {
.{ .msg = "{s} is incompatible with C standards before C23", .extra = .str, .kind = .off, .suppress_unless_version = .c23, .opt = W("pre-c23-compat") },
.{ .msg = "variable length array must be bound in function definition", .kind = .@"error" },
.{ .msg = "array is too large", .kind = .@"error" },
+ .{ .msg = "type '{s}' is too large", .kind = .@"error", .extra = .str },
.{ .msg = "incompatible pointer types initializing {s}", .extra = .str, .opt = W("incompatible-pointer-types"), .kind = .warning },
.{ .msg = "incompatible pointer types initializing {s}" ++ pointer_sign_message, .extra = .str, .opt = W("pointer-sign"), .kind = .warning },
.{ .msg = "incompatible pointer types assigning to {s}", .extra = .str, .opt = W("incompatible-pointer-types"), .kind = .warning },
@@ -855,6 +869,8 @@ pub const Tag = enum {
.{ .msg = "use of non-standard escape character '\\{s}'", .kind = .off, .opt = W("pedantic"), .extra = .invalid_escape },
.{ .msg = "invalid string literal, ignoring final '\\'", .kind = .warning },
.{ .msg = "variable length array used", .kind = .off, .opt = W("vla") },
+ .{ .msg = "implicit conversion from {s}", .extra = .str, .kind = .warning, .opt = W("constant-conversion") },
+ .{ .msg = "implicit conversion changes signedness: {s}", .extra = .str, .kind = .off, .opt = W("sign-conversion") },
.{ .msg = "implicit conversion of non-finite value from {s} is undefined", .extra = .str, .kind = .off, .opt = W("float-overflow-conversion") },
.{ .msg = "implicit conversion of out of range value from {s} is undefined", .extra = .str, .kind = .warning, .opt = W("literal-conversion") },
.{ .msg = "implicit conversion from {s}", .extra = .str, .kind = .off, .opt = W("float-zero-conversion") },
@@ -929,9 +945,10 @@ pub const Tag = enum {
.{ .msg = "this declarator", .kind = .note },
.{ .msg = "{s} is not supported on this target", .extra = .str, .kind = .@"error" },
.{ .msg = "'_BitInt' in C17 and earlier is a Clang extension'", .kind = .off, .pedantic = true, .opt = W("bit-int-extension"), .suppress_version = .c23 },
- .{ .msg = "{s} must have a bit size of at least 1", .extra = .str, .kind = .@"error" },
- .{ .msg = "{s} must have a bit size of at least 2", .extra = .str, .kind = .@"error" },
- .{ .msg = "{s} of bit sizes greater than " ++ std.fmt.comptimePrint("{d}", .{Properties.max_bits}) ++ " not supported", .extra = .str, .kind = .@"error" },
+ .{ .msg = "{s}unsigned _BitInt must have a bit size of at least 1", .extra = .str, .kind = .@"error" },
+ .{ .msg = "{s}signed _BitInt must have a bit size of at least 2", .extra = .str, .kind = .@"error" },
+ .{ .msg = "{s}unsigned _BitInt of bit sizes greater than " ++ std.fmt.comptimePrint("{d}", .{Properties.max_bits}) ++ " not supported", .extra = .str, .kind = .@"error" },
+ .{ .msg = "{s}signed _BitInt of bit sizes greater than " ++ std.fmt.comptimePrint("{d}", .{Properties.max_bits}) ++ " not supported", .extra = .str, .kind = .@"error" },
.{ .msg = "keyword is hidden by macro definition", .kind = .off, .pedantic = true, .opt = W("keyword-macro") },
.{ .msg = "arithmetic on a pointer to an incomplete type '{s}'", .extra = .str, .kind = .@"error" },
.{ .msg = "'{s}' calling convention is not supported for this target", .extra = .str, .opt = W("ignored-attributes"), .kind = .warning },
@@ -1015,6 +1032,9 @@ pub const Tag = enum {
.{ .msg = "ISO C does not support '~' for complex conjugation of '{s}'", .opt = W("pedantic"), .extra = .str, .kind = .off },
.{ .msg = "operand argument to overflow builtin must be an integer ('{s}' invalid)", .extra = .str, .kind = .@"error" },
.{ .msg = "result argument to overflow builtin must be a pointer to a non-const integer ('{s}' invalid)", .extra = .str, .kind = .@"error" },
+ .{ .msg = "TODO: implement '{s}' attribute for {s}", .extra = .attribute_todo, .kind = .@"error" },
+ .{ .msg = "non-integral type '{s}' is an invalid underlying type", .extra = .str, .kind = .@"error" },
+ .{ .msg = "variable '{s}' declared with deduced type '__auto_type' cannot appear in its own initializer", .extra = .str, .kind = .@"error" },
};
};
};
diff --git a/lib/compiler/aro/aro/Driver.zig b/lib/compiler/aro/aro/Driver.zig
index 6876395b8ac5..c89dafe00222 100644
--- a/lib/compiler/aro/aro/Driver.zig
+++ b/lib/compiler/aro/aro/Driver.zig
@@ -25,8 +25,8 @@ pub const Linker = enum {
const Driver = @This();
comp: *Compilation,
-inputs: std.ArrayListUnmanaged(Source) = .{},
-link_objects: std.ArrayListUnmanaged([]const u8) = .{},
+inputs: std.ArrayListUnmanaged(Source) = .empty,
+link_objects: std.ArrayListUnmanaged([]const u8) = .empty,
output_name: ?[]const u8 = null,
sysroot: ?[]const u8 = null,
system_defines: Compilation.SystemDefinesMode = .include_system_defines,
@@ -47,6 +47,20 @@ color: ?bool = null,
nobuiltininc: bool = false,
nostdinc: bool = false,
nostdlibinc: bool = false,
+debug_dump_letters: packed struct(u3) {
+ d: bool = false,
+ m: bool = false,
+ n: bool = false,
+
+ /// According to GCC, specifying letters whose behavior conflicts is undefined.
+ /// We follow clang in that `-dM` always takes precedence over `-dD`
+ pub fn getPreprocessorDumpMode(self: @This()) Preprocessor.DumpMode {
+ if (self.m) return .macros_only;
+ if (self.d) return .macros_and_result;
+ if (self.n) return .macro_names_and_result;
+ return .result_only;
+ }
+} = .{},
/// Full path to the aro executable
aro_name: []const u8 = "",
@@ -92,6 +106,9 @@ pub const usage =
\\
\\Compile options:
\\ -c, --compile Only run preprocess, compile, and assemble steps
+ \\ -dM Output #define directives for all the macros defined during the execution of the preprocessor
+ \\ -dD Like -dM except that it outputs both the #define directives and the result of preprocessing
+ \\ -dN Like -dD, but emit only the macro names, not their expansions.
\\ -D = Define to (defaults to 1)
\\ -E Only run the preprocessor
\\ -fchar8_t Enable char8_t (enabled by default in C23 and later)
@@ -234,6 +251,12 @@ pub fn parseArgs(
d.system_defines = .no_system_defines;
} else if (mem.eql(u8, arg, "-c") or mem.eql(u8, arg, "--compile")) {
d.only_compile = true;
+ } else if (mem.eql(u8, arg, "-dD")) {
+ d.debug_dump_letters.d = true;
+ } else if (mem.eql(u8, arg, "-dM")) {
+ d.debug_dump_letters.m = true;
+ } else if (mem.eql(u8, arg, "-dN")) {
+ d.debug_dump_letters.n = true;
} else if (mem.eql(u8, arg, "-E")) {
d.only_preprocess = true;
} else if (mem.eql(u8, arg, "-P") or mem.eql(u8, arg, "--no-line-commands")) {
@@ -636,13 +659,17 @@ fn processSource(
if (d.comp.langopts.ms_extensions) {
d.comp.ms_cwd_source_id = source.id;
}
-
+ const dump_mode = d.debug_dump_letters.getPreprocessorDumpMode();
if (d.verbose_pp) pp.verbose = true;
if (d.only_preprocess) {
pp.preserve_whitespace = true;
if (d.line_commands) {
pp.linemarkers = if (d.use_line_directives) .line_directives else .numeric_directives;
}
+ switch (dump_mode) {
+ .macros_and_result, .macro_names_and_result => pp.store_macro_tokens = true,
+ .result_only, .macros_only => {},
+ }
}
try pp.preprocessSources(&.{ source, builtin, user_macros });
@@ -663,7 +690,8 @@ fn processSource(
defer if (d.output_name != null) file.close();
var buf_w = std.io.bufferedWriter(file.writer());
- pp.prettyPrintTokens(buf_w.writer()) catch |er|
+
+ pp.prettyPrintTokens(buf_w.writer(), dump_mode) catch |er|
return d.fatal("unable to write result: {s}", .{errorDescription(er)});
buf_w.flush() catch |er|
diff --git a/lib/compiler/aro/aro/Driver/Filesystem.zig b/lib/compiler/aro/aro/Driver/Filesystem.zig
index a81f31375306..07cbeac03c72 100644
--- a/lib/compiler/aro/aro/Driver/Filesystem.zig
+++ b/lib/compiler/aro/aro/Driver/Filesystem.zig
@@ -56,7 +56,7 @@ fn existsFake(entries: []const Filesystem.Entry, path: []const u8) bool {
}
fn canExecutePosix(path: []const u8) bool {
- std.os.access(path, std.os.X_OK) catch return false;
+ std.posix.access(path, std.posix.X_OK) catch return false;
// Todo: ensure path is not a directory
return true;
}
@@ -173,7 +173,7 @@ pub const Filesystem = union(enum) {
pub fn exists(fs: Filesystem, path: []const u8) bool {
switch (fs) {
.real => {
- std.os.access(path, std.os.F_OK) catch return false;
+ std.fs.cwd().access(path, .{}) catch return false;
return true;
},
.fake => |paths| return existsFake(paths, path),
diff --git a/lib/compiler/aro/aro/Hideset.zig b/lib/compiler/aro/aro/Hideset.zig
index 433be9f39324..98712e41e2f4 100644
--- a/lib/compiler/aro/aro/Hideset.zig
+++ b/lib/compiler/aro/aro/Hideset.zig
@@ -46,15 +46,15 @@ const Item = struct {
const List = std.MultiArrayList(Item);
};
-const Index = enum(u32) {
+pub const Index = enum(u32) {
none = std.math.maxInt(u32),
_,
};
-map: std.AutoHashMapUnmanaged(Identifier, Index) = .{},
-/// Used for computing intersection of two lists; stored here so that allocations can be retained
+map: std.AutoHashMapUnmanaged(Identifier, Index) = .empty,
+/// Used for computing union/intersection of two lists; stored here so that allocations can be retained
/// until hideset is deinit'ed
-intersection_map: std.AutoHashMapUnmanaged(Identifier, void) = .{},
+tmp_map: std.AutoHashMapUnmanaged(Identifier, void) = .empty,
linked_list: Item.List = .{},
comp: *const Compilation,
@@ -72,7 +72,7 @@ const Iterator = struct {
pub fn deinit(self: *Hideset) void {
self.map.deinit(self.comp.gpa);
- self.intersection_map.deinit(self.comp.gpa);
+ self.tmp_map.deinit(self.comp.gpa);
self.linked_list.deinit(self.comp.gpa);
}
@@ -83,7 +83,7 @@ pub fn clearRetainingCapacity(self: *Hideset) void {
pub fn clearAndFree(self: *Hideset) void {
self.map.clearAndFree(self.comp.gpa);
- self.intersection_map.clearAndFree(self.comp.gpa);
+ self.tmp_map.clearAndFree(self.comp.gpa);
self.linked_list.shrinkAndFree(self.comp.gpa, 0);
}
@@ -109,8 +109,13 @@ fn ensureUnusedCapacity(self: *Hideset, new_size: usize) !void {
/// Creates a one-item list with contents `identifier`
fn createNodeAssumeCapacity(self: *Hideset, identifier: Identifier) Index {
+ return self.createNodeAssumeCapacityExtra(identifier, .none);
+}
+
+/// Creates a one-item list with contents `identifier`
+fn createNodeAssumeCapacityExtra(self: *Hideset, identifier: Identifier, next: Index) Index {
const next_idx = self.linked_list.len;
- self.linked_list.appendAssumeCapacity(.{ .identifier = identifier });
+ self.linked_list.appendAssumeCapacity(.{ .identifier = identifier, .next = next });
return @enumFromInt(next_idx);
}
@@ -121,24 +126,24 @@ pub fn prepend(self: *Hideset, loc: Source.Location, tail: Index) !Index {
return @enumFromInt(new_idx);
}
-/// Copy a, then attach b at the end
+/// Attach elements of `b` to the front of `a` (if they're not in `a`)
pub fn @"union"(self: *Hideset, a: Index, b: Index) !Index {
- var cur: Index = .none;
+ if (a == .none) return b;
+ if (b == .none) return a;
+ self.tmp_map.clearRetainingCapacity();
+
+ var it = self.iterator(b);
+ while (it.next()) |identifier| {
+ try self.tmp_map.put(self.comp.gpa, identifier, {});
+ }
+
var head: Index = b;
try self.ensureUnusedCapacity(self.len(a));
- var it = self.iterator(a);
+ it = self.iterator(a);
while (it.next()) |identifier| {
- const new_idx = self.createNodeAssumeCapacity(identifier);
- if (head == b) {
- head = new_idx;
+ if (!self.tmp_map.contains(identifier)) {
+ head = self.createNodeAssumeCapacityExtra(identifier, head);
}
- if (cur != .none) {
- self.linked_list.items(.next)[@intFromEnum(cur)] = new_idx;
- }
- cur = new_idx;
- }
- if (cur != .none) {
- self.linked_list.items(.next)[@intFromEnum(cur)] = b;
}
return head;
}
@@ -163,20 +168,20 @@ fn len(self: *const Hideset, list: Index) usize {
pub fn intersection(self: *Hideset, a: Index, b: Index) !Index {
if (a == .none or b == .none) return .none;
- self.intersection_map.clearRetainingCapacity();
+ self.tmp_map.clearRetainingCapacity();
var cur: Index = .none;
var head: Index = .none;
var it = self.iterator(a);
var a_len: usize = 0;
while (it.next()) |identifier| : (a_len += 1) {
- try self.intersection_map.put(self.comp.gpa, identifier, {});
+ try self.tmp_map.put(self.comp.gpa, identifier, {});
}
try self.ensureUnusedCapacity(@min(a_len, self.len(b)));
it = self.iterator(b);
while (it.next()) |identifier| {
- if (self.intersection_map.contains(identifier)) {
+ if (self.tmp_map.contains(identifier)) {
const new_idx = self.createNodeAssumeCapacity(identifier);
if (head == .none) {
head = new_idx;
diff --git a/lib/compiler/aro/aro/InitList.zig b/lib/compiler/aro/aro/InitList.zig
index 7e9f73e8a339..5a5765216ccf 100644
--- a/lib/compiler/aro/aro/InitList.zig
+++ b/lib/compiler/aro/aro/InitList.zig
@@ -23,7 +23,7 @@ const Item = struct {
const InitList = @This();
-list: std.ArrayListUnmanaged(Item) = .{},
+list: std.ArrayListUnmanaged(Item) = .empty,
node: NodeIndex = .none,
tok: TokenIndex = 0,
diff --git a/lib/compiler/aro/aro/Parser.zig b/lib/compiler/aro/aro/Parser.zig
index d8d6f9d71c7b..00857c65e16a 100644
--- a/lib/compiler/aro/aro/Parser.zig
+++ b/lib/compiler/aro/aro/Parser.zig
@@ -28,6 +28,7 @@ const StrInt = @import("StringInterner.zig");
const StringId = StrInt.StringId;
const Builtins = @import("Builtins.zig");
const Builtin = Builtins.Builtin;
+const evalBuiltin = @import("Builtins/eval.zig").eval;
const target_util = @import("target.zig");
const Switch = struct {
@@ -100,7 +101,7 @@ value_map: Tree.ValueMap,
// buffers used during compilation
syms: SymbolStack = .{},
-strings: std.ArrayList(u8),
+strings: std.ArrayListAligned(u8, 4),
labels: std.ArrayList(Label),
list_buf: NodeList,
decl_buf: NodeList,
@@ -108,7 +109,7 @@ param_buf: std.ArrayList(Type.Func.Param),
enum_buf: std.ArrayList(Type.Enum.Field),
record_buf: std.ArrayList(Type.Record.Field),
attr_buf: std.MultiArrayList(TentativeAttribute) = .{},
-attr_application_buf: std.ArrayListUnmanaged(Attribute) = .{},
+attr_application_buf: std.ArrayListUnmanaged(Attribute) = .empty,
field_attr_buf: std.ArrayList([]const Attribute),
/// type name -> variable name location for tentative definitions (top-level defs with thus-far-incomplete types)
/// e.g. `struct Foo bar;` where `struct Foo` is not defined yet.
@@ -116,7 +117,7 @@ field_attr_buf: std.ArrayList([]const Attribute),
/// Items are removed if the type is subsequently completed with a definition.
/// We only store the first tentative definition that uses a given type because this map is only used
/// for issuing an error message, and correcting the first error for a type will fix all of them for that type.
-tentative_defs: std.AutoHashMapUnmanaged(StringId, TokenIndex) = .{},
+tentative_defs: std.AutoHashMapUnmanaged(StringId, TokenIndex) = .empty,
// configuration and miscellaneous info
no_eval: bool = false,
@@ -130,6 +131,10 @@ const_decl_folding: ConstDeclFoldingMode = .fold_const_decls,
/// address-of-label expression (tracked with contains_address_of_label)
computed_goto_tok: ?TokenIndex = null,
+/// __auto_type may only be used with a single declarator. Keep track of the name
+/// so that it is not used in its own initializer.
+auto_type_decl_name: StringId = .empty,
+
/// Various variables that are different for each function.
func: struct {
/// null if not in function, will always be plain func, var_args_func or old_style_func
@@ -160,7 +165,7 @@ record: struct {
}
fn addFieldsFromAnonymous(r: @This(), p: *Parser, ty: Type) Error!void {
- for (ty.data.record.fields) |f| {
+ for (ty.getRecord().?.fields) |f| {
if (f.isAnonymousRecord()) {
try r.addFieldsFromAnonymous(p, f.ty.canonicalize(.standard));
} else if (f.name_tok != 0) {
@@ -169,7 +174,7 @@ record: struct {
}
}
} = .{},
-record_members: std.ArrayListUnmanaged(struct { tok: TokenIndex, name: StringId }) = .{},
+record_members: std.ArrayListUnmanaged(struct { tok: TokenIndex, name: StringId }) = .empty,
@"switch": ?*Switch = null,
in_loop: bool = false,
pragma_pack: ?u8 = null,
@@ -470,7 +475,7 @@ pub fn typePairStrExtra(p: *Parser, a: Type, msg: []const u8, b: Type) ![]const
return try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
}
-pub fn floatValueChangedStr(p: *Parser, res: *Result, old_value: Value, int_ty: Type) ![]const u8 {
+pub fn valueChangedStr(p: *Parser, res: *Result, old_value: Value, int_ty: Type) ![]const u8 {
const strings_top = p.strings.items.len;
defer p.strings.items.len = strings_top;
@@ -572,6 +577,14 @@ fn nodeIs(p: *Parser, node: NodeIndex, tag: Tree.Tag) bool {
return p.getNode(node, tag) != null;
}
+pub fn getDecayedStringLiteral(p: *Parser, node: NodeIndex) ?Value {
+ const cast_node = p.getNode(node, .implicit_cast) orelse return null;
+ const data = p.nodes.items(.data)[@intFromEnum(cast_node)];
+ if (data.cast.kind != .array_to_pointer) return null;
+ const literal_node = p.getNode(data.cast.operand, .string_literal_expr) orelse return null;
+ return p.value_map.get(literal_node);
+}
+
fn getNode(p: *Parser, node: NodeIndex, tag: Tree.Tag) ?NodeIndex {
var cur = node;
const tags = p.nodes.items(.tag);
@@ -680,7 +693,7 @@ pub fn parse(pp: *Preprocessor) Compilation.Error!Tree {
.gpa = pp.comp.gpa,
.arena = arena.allocator(),
.tok_ids = pp.tokens.items(.id),
- .strings = std.ArrayList(u8).init(pp.comp.gpa),
+ .strings = std.ArrayListAligned(u8, 4).init(pp.comp.gpa),
.value_map = Tree.ValueMap.init(pp.comp.gpa),
.data = NodeList.init(pp.comp.gpa),
.labels = std.ArrayList(Label).init(pp.comp.gpa),
@@ -725,7 +738,7 @@ pub fn parse(pp: *Preprocessor) Compilation.Error!Tree {
defer p.syms.popScope();
// NodeIndex 0 must be invalid
- _ = try p.addNode(.{ .tag = .invalid, .ty = undefined, .data = undefined });
+ _ = try p.addNode(.{ .tag = .invalid, .ty = undefined, .data = undefined, .loc = undefined });
{
if (p.comp.langopts.hasChar8_T()) {
@@ -747,6 +760,10 @@ pub fn parse(pp: *Preprocessor) Compilation.Error!Tree {
if (ty.isArray()) ty.decayArray();
try p.syms.defineTypedef(&p, try StrInt.intern(p.comp, "__NSConstantString"), pp.comp.types.ns_constant_string.ty, 0, .none);
+
+ if (p.comp.float80Type()) |float80_ty| {
+ try p.syms.defineTypedef(&p, try StrInt.intern(p.comp, "__float80"), float80_ty, 0, .none);
+ }
}
while (p.eatToken(.eof) == null) {
@@ -862,6 +879,8 @@ fn nextExternDecl(p: *Parser) void {
.keyword_int,
.keyword_long,
.keyword_signed,
+ .keyword_signed1,
+ .keyword_signed2,
.keyword_unsigned,
.keyword_float,
.keyword_double,
@@ -1018,10 +1037,8 @@ fn decl(p: *Parser) Error!bool {
// Collect old style parameter declarations.
if (init_d.d.old_style_func != null) {
- const attrs = init_d.d.ty.getAttributes();
- var base_ty = if (init_d.d.ty.specifier == .attributed) init_d.d.ty.data.attributed.base else init_d.d.ty;
+ var base_ty = init_d.d.ty.base();
base_ty.specifier = .func;
- init_d.d.ty = try base_ty.withAttributes(p.arena, attrs);
const param_buf_top = p.param_buf.items.len;
defer p.param_buf.items.len = param_buf_top;
@@ -1116,6 +1133,7 @@ fn decl(p: *Parser) Error!bool {
.ty = init_d.d.ty,
.tag = try decl_spec.validateFnDef(p),
.data = .{ .decl = .{ .name = init_d.d.name, .node = body } },
+ .loc = @enumFromInt(init_d.d.name),
});
try p.decl_buf.append(node);
@@ -1142,9 +1160,18 @@ fn decl(p: *Parser) Error!bool {
if (init_d.d.old_style_func) |tok_i| try p.errTok(.invalid_old_style_params, tok_i);
const tag = try decl_spec.validate(p, &init_d.d.ty, init_d.initializer.node != .none);
- const node = try p.addNode(.{ .ty = init_d.d.ty, .tag = tag, .data = .{
- .decl = .{ .name = init_d.d.name, .node = init_d.initializer.node },
- } });
+ const tok = switch (decl_spec.storage_class) {
+ .auto, .@"extern", .register, .static, .typedef => |tok| tok,
+ .none => init_d.d.name,
+ };
+ const node = try p.addNode(.{
+ .ty = init_d.d.ty,
+ .tag = tag,
+ .data = .{
+ .decl = .{ .name = init_d.d.name, .node = init_d.initializer.node },
+ },
+ .loc = @enumFromInt(tok),
+ });
try p.decl_buf.append(node);
const interned_name = try StrInt.intern(p.comp, p.tokSlice(init_d.d.name));
@@ -1287,6 +1314,7 @@ fn staticAssert(p: *Parser) Error!bool {
.lhs = res.node,
.rhs = str.node,
} },
+ .loc = @enumFromInt(static_assert),
});
try p.decl_buf.append(node);
return true;
@@ -1407,6 +1435,8 @@ fn typeof(p: *Parser) Error!?Type {
const l_paren = try p.expectToken(.l_paren);
if (try p.typeName()) |ty| {
try p.expectClosing(l_paren, .r_paren);
+ if (ty.is(.invalid)) return null;
+
const typeof_ty = try p.arena.create(Type);
typeof_ty.* = .{
.data = ty.data,
@@ -1428,6 +1458,8 @@ fn typeof(p: *Parser) Error!?Type {
.specifier = .nullptr_t,
.qual = if (unqual) .{} else typeof_expr.ty.qual.inheritFromTypeof(),
};
+ } else if (typeof_expr.ty.is(.invalid)) {
+ return null;
}
const inner = try p.arena.create(Type.Expr);
@@ -1774,6 +1806,8 @@ fn initDeclarator(p: *Parser, decl_spec: *DeclSpec, attr_buf_top: usize) Error!?
} else {
apply_var_attributes = true;
}
+ const c23_auto = init_d.d.ty.is(.c23_auto);
+ const auto_type = init_d.d.ty.is(.auto_type);
if (p.eatToken(.equal)) |eq| init: {
if (decl_spec.storage_class == .typedef or
@@ -1801,19 +1835,21 @@ fn initDeclarator(p: *Parser, decl_spec: *DeclSpec, attr_buf_top: usize) Error!?
const interned_name = try StrInt.intern(p.comp, p.tokSlice(init_d.d.name));
try p.syms.declareSymbol(p, interned_name, init_d.d.ty, init_d.d.name, .none);
+ if (c23_auto or auto_type) {
+ p.auto_type_decl_name = interned_name;
+ }
+ defer p.auto_type_decl_name = .empty;
+
var init_list_expr = try p.initializer(init_d.d.ty);
init_d.initializer = init_list_expr;
if (!init_list_expr.ty.isArray()) break :init;
- if (init_d.d.ty.specifier == .incomplete_array) {
- // Modifying .data is exceptionally allowed for .incomplete_array.
- init_d.d.ty.data.array.len = init_list_expr.ty.arrayLen() orelse break :init;
- init_d.d.ty.specifier = .array;
+ if (init_d.d.ty.is(.incomplete_array)) {
+ init_d.d.ty.setIncompleteArrayLen(init_list_expr.ty.arrayLen() orelse break :init);
}
}
const name = init_d.d.name;
- const c23_auto = init_d.d.ty.is(.c23_auto);
- if (init_d.d.ty.is(.auto_type) or c23_auto) {
+ if (auto_type or c23_auto) {
if (init_d.initializer.node == .none) {
init_d.d.ty = Type.invalid;
if (c23_auto) {
@@ -1872,6 +1908,8 @@ fn initDeclarator(p: *Parser, decl_spec: *DeclSpec, attr_buf_top: usize) Error!?
/// | keyword_float
/// | keyword_double
/// | keyword_signed
+/// | keyword_signed1
+/// | keyword_signed2
/// | keyword_unsigned
/// | keyword_bool
/// | keyword_c23_bool
@@ -1911,14 +1949,13 @@ fn typeSpec(p: *Parser, ty: *Type.Builder) Error!bool {
.keyword_long => try ty.combine(p, .long, p.tok_i),
.keyword_int64, .keyword_int64_2 => try ty.combine(p, .long_long, p.tok_i),
.keyword_int128 => try ty.combine(p, .int128, p.tok_i),
- .keyword_signed => try ty.combine(p, .signed, p.tok_i),
+ .keyword_signed, .keyword_signed1, .keyword_signed2 => try ty.combine(p, .signed, p.tok_i),
.keyword_unsigned => try ty.combine(p, .unsigned, p.tok_i),
.keyword_fp16 => try ty.combine(p, .fp16, p.tok_i),
.keyword_float16 => try ty.combine(p, .float16, p.tok_i),
.keyword_float => try ty.combine(p, .float, p.tok_i),
.keyword_double => try ty.combine(p, .double, p.tok_i),
.keyword_complex => try ty.combine(p, .complex, p.tok_i),
- .keyword_float80 => try ty.combine(p, .float80, p.tok_i),
.keyword_float128_1, .keyword_float128_2 => {
if (!p.comp.hasFloat128()) {
try p.errStr(.type_not_supported_on_target, p.tok_i, p.tok_ids[p.tok_i].lexeme().?);
@@ -2128,6 +2165,7 @@ fn recordSpec(p: *Parser) Error!Type {
.tag = if (is_struct) .struct_forward_decl else .union_forward_decl,
.ty = ty,
.data = .{ .decl_ref = ident },
+ .loc = @enumFromInt(ident),
}));
return ty;
}
@@ -2248,19 +2286,22 @@ fn recordSpec(p: *Parser) Error!Type {
// TODO: msvc considers `#pragma pack` on a per-field basis
.msvc => p.pragma_pack,
};
- record_layout.compute(record_ty, ty, p.comp, pragma_pack_value);
+ record_layout.compute(record_ty, ty, p.comp, pragma_pack_value) catch |er| switch (er) {
+ error.Overflow => try p.errStr(.record_too_large, maybe_ident orelse kind_tok, try p.typeStr(ty)),
+ };
}
// finish by creating a node
var node: Tree.Node = .{
.tag = if (is_struct) .struct_decl_two else .union_decl_two,
.ty = ty,
- .data = .{ .bin = .{ .lhs = .none, .rhs = .none } },
+ .data = .{ .two = .{ .none, .none } },
+ .loc = @enumFromInt(maybe_ident orelse kind_tok),
};
switch (record_decls.len) {
0 => {},
- 1 => node.data = .{ .bin = .{ .lhs = record_decls[0], .rhs = .none } },
- 2 => node.data = .{ .bin = .{ .lhs = record_decls[0], .rhs = record_decls[1] } },
+ 1 => node.data = .{ .two = .{ record_decls[0], .none } },
+ 2 => node.data = .{ .two = .{ record_decls[0], record_decls[1] } },
else => {
node.tag = if (is_struct) .struct_decl else .union_decl;
node.data = .{ .range = try p.addList(record_decls) };
@@ -2383,6 +2424,7 @@ fn recordDeclarator(p: *Parser) Error!bool {
.tag = .indirect_record_field_decl,
.ty = ty,
.data = undefined,
+ .loc = @enumFromInt(first_tok),
});
try p.decl_buf.append(node);
try p.record.addFieldsFromAnonymous(p, ty);
@@ -2402,6 +2444,7 @@ fn recordDeclarator(p: *Parser) Error!bool {
.tag = .record_field_decl,
.ty = ty,
.data = .{ .decl = .{ .name = name_tok, .node = bits_node } },
+ .loc = @enumFromInt(if (name_tok != 0) name_tok else first_tok),
});
try p.decl_buf.append(node);
}
@@ -2461,7 +2504,8 @@ fn enumSpec(p: *Parser) Error!Type {
const maybe_ident = try p.eatIdentifier();
const fixed_ty = if (p.eatToken(.colon)) |colon| fixed: {
- const fixed = (try p.typeName()) orelse {
+ const ty_start = p.tok_i;
+ const fixed = (try p.specQual()) orelse {
if (p.record.kind != .invalid) {
// This is a bit field.
p.tok_i -= 1;
@@ -2471,6 +2515,12 @@ fn enumSpec(p: *Parser) Error!Type {
try p.errTok(.enum_fixed, colon);
break :fixed null;
};
+
+ if (!fixed.isInt() or fixed.is(.@"enum")) {
+ try p.errStr(.invalid_type_underlying_enum, ty_start, try p.typeStr(fixed));
+ break :fixed Type.int;
+ }
+
try p.errTok(.enum_fixed, colon);
break :fixed fixed;
} else null;
@@ -2505,6 +2555,7 @@ fn enumSpec(p: *Parser) Error!Type {
.tag = .enum_forward_decl,
.ty = ty,
.data = .{ .decl_ref = ident },
+ .loc = @enumFromInt(ident),
}));
return ty;
}
@@ -2587,7 +2638,7 @@ fn enumSpec(p: *Parser) Error!Type {
continue;
const symbol = p.syms.getPtr(field.name, .vars);
- try symbol.val.intCast(dest_ty, p.comp);
+ _ = try symbol.val.intCast(dest_ty, p.comp);
symbol.ty = dest_ty;
p.nodes.items(.ty)[@intFromEnum(field_nodes[i])] = dest_ty;
field.ty = dest_ty;
@@ -2615,13 +2666,18 @@ fn enumSpec(p: *Parser) Error!Type {
}
// finish by creating a node
- var node: Tree.Node = .{ .tag = .enum_decl_two, .ty = ty, .data = .{
- .bin = .{ .lhs = .none, .rhs = .none },
- } };
+ var node: Tree.Node = .{
+ .tag = .enum_decl_two,
+ .ty = ty,
+ .data = .{
+ .two = .{ .none, .none },
+ },
+ .loc = @enumFromInt(maybe_ident orelse enum_tok),
+ };
switch (field_nodes.len) {
0 => {},
- 1 => node.data = .{ .bin = .{ .lhs = field_nodes[0], .rhs = .none } },
- 2 => node.data = .{ .bin = .{ .lhs = field_nodes[0], .rhs = field_nodes[1] } },
+ 1 => node.data = .{ .two = .{ field_nodes[0], .none } },
+ 2 => node.data = .{ .two = .{ field_nodes[0], field_nodes[1] } },
else => {
node.tag = .enum_decl;
node.data = .{ .range = try p.addList(field_nodes) };
@@ -2679,8 +2735,6 @@ const Enumerator = struct {
return;
}
if (try e.res.val.add(e.res.val, Value.one, e.res.ty, p.comp)) {
- const byte_size = e.res.ty.sizeof(p.comp).?;
- const bit_size: u8 = @intCast(if (e.res.ty.isUnsignedInt(p.comp)) byte_size * 8 else byte_size * 8 - 1);
if (e.fixed) {
try p.errStr(.enum_not_representable_fixed, tok, try p.typeStr(e.res.ty));
return;
@@ -2689,6 +2743,8 @@ const Enumerator = struct {
try p.errTok(.enumerator_overflow, tok);
break :blk larger;
} else blk: {
+ const signed = !e.res.ty.isUnsignedInt(p.comp);
+ const bit_size: u8 = @intCast(e.res.ty.bitSizeof(p.comp).? - @intFromBool(signed));
try p.errExtra(.enum_not_representable, tok, .{ .pow_2_as_string = bit_size });
break :blk Type{ .specifier = .ulong_long };
};
@@ -2792,14 +2848,12 @@ fn enumerator(p: *Parser, e: *Enumerator) Error!?EnumFieldAndNode {
if (err_start == p.comp.diagnostics.list.items.len) {
// only do these warnings if we didn't already warn about overflow or non-representable values
if (e.res.val.compare(.lt, Value.zero, p.comp)) {
- const min_int = (Type{ .specifier = .int }).minInt(p.comp);
- const min_val = try Value.int(min_int, p.comp);
+ const min_val = try Value.minInt(Type.int, p.comp);
if (e.res.val.compare(.lt, min_val, p.comp)) {
try p.errStr(.enumerator_too_small, name_tok, try e.res.str(p));
}
} else {
- const max_int = (Type{ .specifier = .int }).maxInt(p.comp);
- const max_val = try Value.int(max_int, p.comp);
+ const max_val = try Value.maxInt(Type.int, p.comp);
if (e.res.val.compare(.gt, max_val, p.comp)) {
try p.errStr(.enumerator_too_large, name_tok, try e.res.str(p));
}
@@ -2815,6 +2869,7 @@ fn enumerator(p: *Parser, e: *Enumerator) Error!?EnumFieldAndNode {
.name = name_tok,
.node = res.node,
} },
+ .loc = @enumFromInt(name_tok),
});
try p.value_map.put(node, e.res.val);
return EnumFieldAndNode{ .field = .{
@@ -2991,15 +3046,12 @@ fn directDeclarator(p: *Parser, base_type: Type, d: *Declarator, kind: Declarato
}
const outer = try p.directDeclarator(base_type, d, kind);
- var max_bits = p.comp.target.ptrBitWidth();
- if (max_bits > 61) max_bits = 61;
- const max_bytes = (@as(u64, 1) << @truncate(max_bits)) - 1;
if (!size.ty.isInt()) {
try p.errStr(.array_size_non_int, size_tok, try p.typeStr(size.ty));
return error.ParsingFailed;
}
- if (base_type.is(.c23_auto)) {
+ if (base_type.is(.c23_auto) or outer.is(.invalid)) {
// issue error later
return Type.invalid;
} else if (size.val.opt_ref == .none) {
@@ -3030,7 +3082,7 @@ fn directDeclarator(p: *Parser, base_type: Type, d: *Declarator, kind: Declarato
} else {
// `outer` is validated later so it may be invalid here
const outer_size = outer.sizeof(p.comp);
- const max_elems = max_bytes / @max(1, outer_size orelse 1);
+ const max_elems = p.comp.maxArrayBytes() / @max(1, outer_size orelse 1);
var size_val = size.val;
if (size_val.isZero(p.comp)) {
@@ -3047,7 +3099,7 @@ fn directDeclarator(p: *Parser, base_type: Type, d: *Declarator, kind: Declarato
arr_ty.len = max_elems;
}
res_ty.data = .{ .array = arr_ty };
- res_ty.specifier = .array;
+ res_ty.specifier = if (static != null) .static_array else .array;
}
try res_ty.combine(outer);
@@ -3120,12 +3172,14 @@ fn directDeclarator(p: *Parser, base_type: Type, d: *Declarator, kind: Declarato
fn pointer(p: *Parser, base_ty: Type) Error!Type {
var ty = base_ty;
while (p.eatToken(.asterisk)) |_| {
- const elem_ty = try p.arena.create(Type);
- elem_ty.* = ty;
- ty = Type{
- .specifier = .pointer,
- .data = .{ .sub_type = elem_ty },
- };
+ if (!ty.is(.invalid)) {
+ const elem_ty = try p.arena.create(Type);
+ elem_ty.* = ty;
+ ty = Type{
+ .specifier = .pointer,
+ .data = .{ .sub_type = elem_ty },
+ };
+ }
var quals = Type.Qualifiers.Builder{};
_ = try p.typeQual(&quals);
try quals.finish(p, &ty);
@@ -3237,6 +3291,75 @@ fn typeName(p: *Parser) Error!?Type {
return try Attribute.applyTypeAttributes(p, ty, attr_buf_top, .align_ignored);
}
+fn complexInitializer(p: *Parser, init_ty: Type) Error!Result {
+ assert(p.tok_ids[p.tok_i] == .l_brace);
+ assert(init_ty.isComplex());
+
+ const real_ty = init_ty.makeReal();
+ if (real_ty.isInt()) {
+ return p.todo("Complex integer initializers");
+ }
+ const l_brace = p.tok_i;
+ p.tok_i += 1;
+ try p.errTok(.complex_component_init, l_brace);
+
+ const first_tok = p.tok_i;
+ var first = try p.assignExpr();
+ try first.expect(p);
+ try p.coerceInit(&first, first_tok, real_ty);
+
+ var second: Result = .{
+ .ty = real_ty,
+ .val = Value.zero,
+ };
+ if (p.eatToken(.comma)) |_| {
+ const second_tok = p.tok_i;
+ const maybe_second = try p.assignExpr();
+ if (!maybe_second.empty(p)) {
+ second = maybe_second;
+ try p.coerceInit(&second, second_tok, real_ty);
+ }
+ }
+
+ // Eat excess initializers
+ var extra_tok: ?TokenIndex = null;
+ while (p.eatToken(.comma)) |_| {
+ if (p.tok_ids[p.tok_i] == .r_brace) break;
+ extra_tok = p.tok_i;
+ const extra = try p.assignExpr();
+ if (extra.empty(p)) {
+ try p.errTok(.expected_expr, p.tok_i);
+ p.skipTo(.r_brace);
+ return error.ParsingFailed;
+ }
+ }
+ try p.expectClosing(l_brace, .r_brace);
+ if (extra_tok) |tok| {
+ try p.errTok(.excess_scalar_init, tok);
+ }
+
+ const arr_init_node: Tree.Node = .{
+ .tag = .array_init_expr_two,
+ .ty = init_ty,
+ .data = .{ .two = .{ first.node, second.node } },
+ .loc = @enumFromInt(l_brace),
+ };
+ var res: Result = .{
+ .node = try p.addNode(arr_init_node),
+ .ty = init_ty,
+ };
+ if (first.val.opt_ref != .none and second.val.opt_ref != .none) {
+ res.val = try Value.intern(p.comp, switch (real_ty.bitSizeof(p.comp).?) {
+ 32 => .{ .complex = .{ .cf32 = .{ first.val.toFloat(f32, p.comp), second.val.toFloat(f32, p.comp) } } },
+ 64 => .{ .complex = .{ .cf64 = .{ first.val.toFloat(f64, p.comp), second.val.toFloat(f64, p.comp) } } },
+ 80 => .{ .complex = .{ .cf80 = .{ first.val.toFloat(f80, p.comp), second.val.toFloat(f80, p.comp) } } },
+ 128 => .{ .complex = .{ .cf128 = .{ first.val.toFloat(f128, p.comp), second.val.toFloat(f128, p.comp) } } },
+ else => unreachable,
+ });
+ }
+ return res;
+}
+
/// initializer
/// : assignExpr
/// | '{' initializerItems '}'
@@ -3255,6 +3378,9 @@ fn initializer(p: *Parser, init_ty: Type) Error!Result {
return error.ParsingFailed;
}
+ if (init_ty.isComplex()) {
+ return p.complexInitializer(init_ty);
+ }
var il: InitList = .{};
defer il.deinit(p.gpa);
@@ -3754,9 +3880,15 @@ fn convertInitList(p: *Parser, il: InitList, init_ty: Type) Error!NodeIndex {
var arr_init_node: Tree.Node = .{
.tag = .array_init_expr_two,
.ty = init_ty,
- .data = .{ .bin = .{ .lhs = .none, .rhs = .none } },
+ .data = .{ .two = .{ .none, .none } },
};
+ const max_elems = p.comp.maxArrayBytes() / (@max(1, elem_ty.sizeof(p.comp) orelse 1));
+ if (start > max_elems) {
+ try p.errTok(.array_too_large, il.tok);
+ start = max_elems;
+ }
+
if (init_ty.specifier == .incomplete_array) {
arr_init_node.ty.specifier = .array;
arr_init_node.ty.data.array.len = start;
@@ -3767,8 +3899,6 @@ fn convertInitList(p: *Parser, il: InitList, init_ty: Type) Error!NodeIndex {
.specifier = .array,
.data = .{ .array = arr_ty },
};
- const attrs = init_ty.getAttributes();
- arr_init_node.ty = try arr_init_node.ty.withAttributes(p.arena, attrs);
} else if (start < max_items) {
const elem = try p.addNode(.{
.tag = .array_filler_expr,
@@ -3781,8 +3911,8 @@ fn convertInitList(p: *Parser, il: InitList, init_ty: Type) Error!NodeIndex {
const items = p.list_buf.items[list_buf_top..];
switch (items.len) {
0 => {},
- 1 => arr_init_node.data.bin.lhs = items[0],
- 2 => arr_init_node.data.bin = .{ .lhs = items[0], .rhs = items[1] },
+ 1 => arr_init_node.data.two[0] = items[0],
+ 2 => arr_init_node.data.two = .{ items[0], items[1] },
else => {
arr_init_node.tag = .array_init_expr;
arr_init_node.data = .{ .range = try p.addList(items) };
@@ -3813,13 +3943,13 @@ fn convertInitList(p: *Parser, il: InitList, init_ty: Type) Error!NodeIndex {
var struct_init_node: Tree.Node = .{
.tag = .struct_init_expr_two,
.ty = init_ty,
- .data = .{ .bin = .{ .lhs = .none, .rhs = .none } },
+ .data = .{ .two = .{ .none, .none } },
};
const items = p.list_buf.items[list_buf_top..];
switch (items.len) {
0 => {},
- 1 => struct_init_node.data.bin.lhs = items[0],
- 2 => struct_init_node.data.bin = .{ .lhs = items[0], .rhs = items[1] },
+ 1 => struct_init_node.data.two[0] = items[0],
+ 2 => struct_init_node.data.two = .{ items[0], items[1] },
else => {
struct_init_node.tag = .struct_init_expr;
struct_init_node.data = .{ .range = try p.addList(items) };
@@ -3894,7 +4024,7 @@ fn asmOperand(p: *Parser, names: *std.ArrayList(?TokenIndex), constraints: *Node
/// | asmStr ':' asmOperand* ':' asmOperand*
/// | asmStr ':' asmOperand* ':' asmOperand* : asmStr? (',' asmStr)*
/// | asmStr ':' asmOperand* ':' asmOperand* : asmStr? (',' asmStr)* : IDENTIFIER (',' IDENTIFIER)*
-fn gnuAsmStmt(p: *Parser, quals: Tree.GNUAssemblyQualifiers, l_paren: TokenIndex) Error!NodeIndex {
+fn gnuAsmStmt(p: *Parser, quals: Tree.GNUAssemblyQualifiers, asm_tok: TokenIndex, l_paren: TokenIndex) Error!NodeIndex {
const asm_str = try p.asmStr();
try p.checkAsmStr(asm_str.val, l_paren);
@@ -3903,6 +4033,7 @@ fn gnuAsmStmt(p: *Parser, quals: Tree.GNUAssemblyQualifiers, l_paren: TokenIndex
.tag = .gnu_asm_simple,
.ty = .{ .specifier = .void },
.data = .{ .un = asm_str.node },
+ .loc = @enumFromInt(asm_tok),
});
}
@@ -4007,6 +4138,7 @@ fn gnuAsmStmt(p: *Parser, quals: Tree.GNUAssemblyQualifiers, l_paren: TokenIndex
.tag = .addr_of_label,
.data = .{ .decl_ref = label },
.ty = result_ty,
+ .loc = @enumFromInt(ident),
});
try exprs.append(label_addr_node);
@@ -4088,9 +4220,10 @@ fn assembly(p: *Parser, kind: enum { global, decl_label, stmt }) Error!?NodeInde
.tag = .file_scope_asm,
.ty = .{ .specifier = .void },
.data = .{ .decl = .{ .name = asm_tok, .node = asm_str.node } },
+ .loc = @enumFromInt(asm_tok),
});
},
- .stmt => result_node = try p.gnuAsmStmt(quals, l_paren),
+ .stmt => result_node = try p.gnuAsmStmt(quals, asm_tok, l_paren),
}
try p.expectClosing(l_paren, .r_paren);
@@ -4141,7 +4274,7 @@ fn asmStr(p: *Parser) Error!Result {
fn stmt(p: *Parser) Error!NodeIndex {
if (try p.labeledStmt()) |some| return some;
if (try p.compoundStmt(false, null)) |some| return some;
- if (p.eatToken(.keyword_if)) |_| {
+ if (p.eatToken(.keyword_if)) |kw_if| {
const l_paren = try p.expectToken(.l_paren);
const cond_tok = p.tok_i;
var cond = try p.expr();
@@ -4160,14 +4293,16 @@ fn stmt(p: *Parser) Error!NodeIndex {
return try p.addNode(.{
.tag = .if_then_else_stmt,
.data = .{ .if3 = .{ .cond = cond.node, .body = (try p.addList(&.{ then, @"else" })).start } },
+ .loc = @enumFromInt(kw_if),
})
else
return try p.addNode(.{
.tag = .if_then_stmt,
.data = .{ .bin = .{ .lhs = cond.node, .rhs = then } },
+ .loc = @enumFromInt(kw_if),
});
}
- if (p.eatToken(.keyword_switch)) |_| {
+ if (p.eatToken(.keyword_switch)) |kw_switch| {
const l_paren = try p.expectToken(.l_paren);
const cond_tok = p.tok_i;
var cond = try p.expr();
@@ -4197,9 +4332,10 @@ fn stmt(p: *Parser) Error!NodeIndex {
return try p.addNode(.{
.tag = .switch_stmt,
.data = .{ .bin = .{ .lhs = cond.node, .rhs = body } },
+ .loc = @enumFromInt(kw_switch),
});
}
- if (p.eatToken(.keyword_while)) |_| {
+ if (p.eatToken(.keyword_while)) |kw_while| {
const l_paren = try p.expectToken(.l_paren);
const cond_tok = p.tok_i;
var cond = try p.expr();
@@ -4221,9 +4357,10 @@ fn stmt(p: *Parser) Error!NodeIndex {
return try p.addNode(.{
.tag = .while_stmt,
.data = .{ .bin = .{ .lhs = cond.node, .rhs = body } },
+ .loc = @enumFromInt(kw_while),
});
}
- if (p.eatToken(.keyword_do)) |_| {
+ if (p.eatToken(.keyword_do)) |kw_do| {
const body = body: {
const old_loop = p.in_loop;
p.in_loop = true;
@@ -4248,9 +4385,10 @@ fn stmt(p: *Parser) Error!NodeIndex {
return try p.addNode(.{
.tag = .do_while_stmt,
.data = .{ .bin = .{ .lhs = cond.node, .rhs = body } },
+ .loc = @enumFromInt(kw_do),
});
}
- if (p.eatToken(.keyword_for)) |_| {
+ if (p.eatToken(.keyword_for)) |kw_for| {
try p.syms.pushScope(p);
defer p.syms.popScope();
const decl_buf_top = p.decl_buf.items.len;
@@ -4301,16 +4439,22 @@ fn stmt(p: *Parser) Error!NodeIndex {
return try p.addNode(.{
.tag = .for_decl_stmt,
.data = .{ .range = .{ .start = start, .end = end } },
+ .loc = @enumFromInt(kw_for),
});
} else if (init.node == .none and cond.node == .none and incr.node == .none) {
return try p.addNode(.{
.tag = .forever_stmt,
.data = .{ .un = body },
+ .loc = @enumFromInt(kw_for),
});
- } else return try p.addNode(.{ .tag = .for_stmt, .data = .{ .if3 = .{
- .cond = body,
- .body = (try p.addList(&.{ init.node, cond.node, incr.node })).start,
- } } });
+ } else return try p.addNode(.{
+ .tag = .for_stmt,
+ .data = .{ .if3 = .{
+ .cond = body,
+ .body = (try p.addList(&.{ init.node, cond.node, incr.node })).start,
+ } },
+ .loc = @enumFromInt(kw_for),
+ });
}
if (p.eatToken(.keyword_goto)) |goto_tok| {
if (p.eatToken(.asterisk)) |_| {
@@ -4338,7 +4482,7 @@ fn stmt(p: *Parser) Error!NodeIndex {
}
}
- try e.un(p, .computed_goto_stmt);
+ try e.un(p, .computed_goto_stmt, goto_tok);
_ = try p.expectToken(.semicolon);
return e.node;
}
@@ -4351,17 +4495,18 @@ fn stmt(p: *Parser) Error!NodeIndex {
return try p.addNode(.{
.tag = .goto_stmt,
.data = .{ .decl_ref = name_tok },
+ .loc = @enumFromInt(goto_tok),
});
}
if (p.eatToken(.keyword_continue)) |cont| {
if (!p.in_loop) try p.errTok(.continue_not_in_loop, cont);
_ = try p.expectToken(.semicolon);
- return try p.addNode(.{ .tag = .continue_stmt, .data = undefined });
+ return try p.addNode(.{ .tag = .continue_stmt, .data = undefined, .loc = @enumFromInt(cont) });
}
if (p.eatToken(.keyword_break)) |br| {
if (!p.in_loop and p.@"switch" == null) try p.errTok(.break_not_in_loop_or_switch, br);
_ = try p.expectToken(.semicolon);
- return try p.addNode(.{ .tag = .break_stmt, .data = undefined });
+ return try p.addNode(.{ .tag = .break_stmt, .data = undefined, .loc = @enumFromInt(br) });
}
if (try p.returnStmt()) |some| return some;
if (try p.assembly(.stmt)) |some| return some;
@@ -4380,8 +4525,8 @@ fn stmt(p: *Parser) Error!NodeIndex {
defer p.attr_buf.len = attr_buf_top;
try p.attributeSpecifier();
- if (p.eatToken(.semicolon)) |_| {
- var null_node: Tree.Node = .{ .tag = .null_stmt, .data = undefined };
+ if (p.eatToken(.semicolon)) |semicolon| {
+ var null_node: Tree.Node = .{ .tag = .null_stmt, .data = undefined, .loc = @enumFromInt(semicolon) };
null_node.ty = try Attribute.applyStatementAttributes(p, null_node.ty, expr_start, attr_buf_top);
return p.addNode(null_node);
}
@@ -4422,6 +4567,7 @@ fn labeledStmt(p: *Parser) Error!?NodeIndex {
var labeled_stmt = Tree.Node{
.tag = .labeled_stmt,
.data = .{ .decl = .{ .name = name_tok, .node = try p.labelableStmt() } },
+ .loc = @enumFromInt(name_tok),
};
labeled_stmt.ty = try Attribute.applyLabelAttributes(p, labeled_stmt.ty, attr_buf_top);
return try p.addNode(labeled_stmt);
@@ -4464,9 +4610,11 @@ fn labeledStmt(p: *Parser) Error!?NodeIndex {
if (second_item) |some| return try p.addNode(.{
.tag = .case_range_stmt,
.data = .{ .if3 = .{ .cond = s, .body = (try p.addList(&.{ first_item.node, some.node })).start } },
+ .loc = @enumFromInt(case),
}) else return try p.addNode(.{
.tag = .case_stmt,
.data = .{ .bin = .{ .lhs = first_item.node, .rhs = s } },
+ .loc = @enumFromInt(case),
});
} else if (p.eatToken(.keyword_default)) |default| {
_ = try p.expectToken(.colon);
@@ -4474,6 +4622,7 @@ fn labeledStmt(p: *Parser) Error!?NodeIndex {
const node = try p.addNode(.{
.tag = .default_stmt,
.data = .{ .un = s },
+ .loc = @enumFromInt(default),
});
const @"switch" = p.@"switch" orelse {
try p.errStr(.case_not_in_switch, default, "default");
@@ -4492,7 +4641,7 @@ fn labeledStmt(p: *Parser) Error!?NodeIndex {
fn labelableStmt(p: *Parser) Error!NodeIndex {
if (p.tok_ids[p.tok_i] == .r_brace) {
try p.err(.label_compound_end);
- return p.addNode(.{ .tag = .null_stmt, .data = undefined });
+ return p.addNode(.{ .tag = .null_stmt, .data = undefined, .loc = @enumFromInt(p.tok_i) });
}
return p.stmt();
}
@@ -4557,6 +4706,7 @@ fn compoundStmt(p: *Parser, is_fn_body: bool, stmt_expr_state: ?*StmtExprState)
else => {},
}
}
+ const r_brace = p.tok_i - 1;
if (noreturn_index) |some| {
// if new labels were defined we cannot be certain that the code is unreachable
@@ -4580,7 +4730,7 @@ fn compoundStmt(p: *Parser, is_fn_body: bool, stmt_expr_state: ?*StmtExprState)
try p.errStr(.func_does_not_return, p.tok_i - 1, func_name);
}
}
- try p.decl_buf.append(try p.addNode(.{ .tag = .implicit_return, .ty = p.func.ty.?.returnType(), .data = .{ .return_zero = return_zero } }));
+ try p.decl_buf.append(try p.addNode(.{ .tag = .implicit_return, .ty = p.func.ty.?.returnType(), .data = .{ .return_zero = return_zero }, .loc = @enumFromInt(r_brace) }));
}
if (p.func.ident) |some| try p.decl_buf.insert(decl_buf_top, some.node);
if (p.func.pretty_ident) |some| try p.decl_buf.insert(decl_buf_top, some.node);
@@ -4588,13 +4738,14 @@ fn compoundStmt(p: *Parser, is_fn_body: bool, stmt_expr_state: ?*StmtExprState)
var node: Tree.Node = .{
.tag = .compound_stmt_two,
- .data = .{ .bin = .{ .lhs = .none, .rhs = .none } },
+ .data = .{ .two = .{ .none, .none } },
+ .loc = @enumFromInt(l_brace),
};
const statements = p.decl_buf.items[decl_buf_top..];
switch (statements.len) {
0 => {},
- 1 => node.data = .{ .bin = .{ .lhs = statements[0], .rhs = .none } },
- 2 => node.data = .{ .bin = .{ .lhs = statements[0], .rhs = statements[1] } },
+ 1 => node.data = .{ .two = .{ statements[0], .none } },
+ 2 => node.data = .{ .two = .{ statements[0], statements[1] } },
else => {
node.tag = .compound_stmt;
node.data = .{ .range = try p.addList(statements) };
@@ -4618,8 +4769,8 @@ fn nodeIsNoreturn(p: *Parser, node: NodeIndex) NoreturnKind {
},
.compound_stmt_two => {
const data = p.nodes.items(.data)[@intFromEnum(node)];
- const lhs_type = if (data.bin.lhs != .none) p.nodeIsNoreturn(data.bin.lhs) else .no;
- const rhs_type = if (data.bin.rhs != .none) p.nodeIsNoreturn(data.bin.rhs) else .no;
+ const lhs_type = if (data.two[0] != .none) p.nodeIsNoreturn(data.two[0]) else .no;
+ const rhs_type = if (data.two[1] != .none) p.nodeIsNoreturn(data.two[1]) else .no;
if (lhs_type == .complex or rhs_type == .complex) return .complex;
if (lhs_type == .yes or rhs_type == .yes) return .yes;
return .no;
@@ -4704,6 +4855,8 @@ fn nextStmt(p: *Parser, l_brace: TokenIndex) !void {
.keyword_int,
.keyword_long,
.keyword_signed,
+ .keyword_signed1,
+ .keyword_signed2,
.keyword_unsigned,
.keyword_float,
.keyword_double,
@@ -4743,17 +4896,17 @@ fn returnStmt(p: *Parser) Error!?NodeIndex {
if (e.node == .none) {
if (!ret_ty.is(.void)) try p.errStr(.func_should_return, ret_tok, p.tokSlice(p.func.name));
- return try p.addNode(.{ .tag = .return_stmt, .data = .{ .un = e.node } });
+ return try p.addNode(.{ .tag = .return_stmt, .data = .{ .un = e.node }, .loc = @enumFromInt(ret_tok) });
} else if (ret_ty.is(.void)) {
try p.errStr(.void_func_returns_value, e_tok, p.tokSlice(p.func.name));
- return try p.addNode(.{ .tag = .return_stmt, .data = .{ .un = e.node } });
+ return try p.addNode(.{ .tag = .return_stmt, .data = .{ .un = e.node }, .loc = @enumFromInt(ret_tok) });
}
try e.lvalConversion(p);
try e.coerce(p, ret_ty, e_tok, .ret);
try e.saveValue(p);
- return try p.addNode(.{ .tag = .return_stmt, .data = .{ .un = e.node } });
+ return try p.addNode(.{ .tag = .return_stmt, .data = .{ .un = e.node }, .loc = @enumFromInt(ret_tok) });
}
// ====== expressions ======
@@ -4802,7 +4955,6 @@ const CallExpr = union(enum) {
}
fn shouldPromoteVarArg(self: CallExpr, arg_idx: u32) bool {
- @setEvalBranchQuota(2000);
return switch (self) {
.standard => true,
.builtin => |builtin| switch (builtin.tag) {
@@ -4810,10 +4962,13 @@ const CallExpr = union(enum) {
Builtin.tagFromName("__va_start").?,
Builtin.tagFromName("va_start").?,
=> arg_idx != 1,
- Builtin.tagFromName("__builtin_complex").?,
Builtin.tagFromName("__builtin_add_overflow").?,
- Builtin.tagFromName("__builtin_sub_overflow").?,
+ Builtin.tagFromName("__builtin_complex").?,
+ Builtin.tagFromName("__builtin_isinf").?,
+ Builtin.tagFromName("__builtin_isinf_sign").?,
Builtin.tagFromName("__builtin_mul_overflow").?,
+ Builtin.tagFromName("__builtin_isnan").?,
+ Builtin.tagFromName("__builtin_sub_overflow").?,
=> false,
else => true,
},
@@ -4827,7 +4982,6 @@ const CallExpr = union(enum) {
}
fn checkVarArg(self: CallExpr, p: *Parser, first_after: TokenIndex, param_tok: TokenIndex, arg: *Result, arg_idx: u32) !void {
- @setEvalBranchQuota(10_000);
if (self == .standard) return;
const builtin_tok = p.nodes.items(.data)[@intFromEnum(self.builtin.node)].decl.name;
@@ -4852,13 +5006,15 @@ const CallExpr = union(enum) {
/// of arguments, `paramCountOverride` is used to tell us how many arguments we should actually expect to see for
/// these custom-typechecked functions.
fn paramCountOverride(self: CallExpr) ?u32 {
- @setEvalBranchQuota(10_000);
return switch (self) {
.standard => null,
.builtin => |builtin| switch (builtin.tag) {
Builtin.tagFromName("__c11_atomic_thread_fence").?,
Builtin.tagFromName("__c11_atomic_signal_fence").?,
Builtin.tagFromName("__c11_atomic_is_lock_free").?,
+ Builtin.tagFromName("__builtin_isinf").?,
+ Builtin.tagFromName("__builtin_isinf_sign").?,
+ Builtin.tagFromName("__builtin_isnan").?,
=> 1,
Builtin.tagFromName("__builtin_complex").?,
@@ -4903,7 +5059,6 @@ const CallExpr = union(enum) {
}
fn returnType(self: CallExpr, p: *Parser, callable_ty: Type) Type {
- @setEvalBranchQuota(6000);
return switch (self) {
.standard => callable_ty.returnType(),
.builtin => |builtin| switch (builtin.tag) {
@@ -4977,12 +5132,12 @@ const CallExpr = union(enum) {
var call_node: Tree.Node = .{
.tag = .call_expr_one,
.ty = ret_ty,
- .data = .{ .bin = .{ .lhs = func_node, .rhs = .none } },
+ .data = .{ .two = .{ func_node, .none } },
};
const args = p.list_buf.items[list_buf_top..];
switch (arg_count) {
0 => {},
- 1 => call_node.data.bin.rhs = args[1], // args[0] == func.node
+ 1 => call_node.data.two[1] = args[1], // args[0] == func.node
else => {
call_node.tag = .call_expr;
call_node.data = .{ .range = try p.addList(args) };
@@ -5005,7 +5160,8 @@ const CallExpr = union(enum) {
call_node.data = .{ .range = try p.addList(args) };
},
}
- return Result{ .node = builtin.node, .ty = ret_ty };
+ const val = try evalBuiltin(builtin.tag, p, args[1..]);
+ return Result{ .node = builtin.node, .ty = ret_ty, .val = val };
},
}
}
@@ -5016,6 +5172,8 @@ pub const Result = struct {
ty: Type = .{ .specifier = .int },
val: Value = .{},
+ const invalid: Result = .{ .ty = Type.invalid };
+
pub fn str(res: Result, p: *Parser) ![]const u8 {
switch (res.val.opt_ref) {
.none => return "(none)",
@@ -5073,30 +5231,21 @@ pub const Result = struct {
.post_inc_expr,
.post_dec_expr,
=> return,
- .call_expr_one => {
- const fn_ptr = p.nodes.items(.data)[@intFromEnum(cur_node)].bin.lhs;
- const fn_ty = p.nodes.items(.ty)[@intFromEnum(fn_ptr)].elemType();
- const cast_info = p.nodes.items(.data)[@intFromEnum(fn_ptr)].cast.operand;
- const decl_ref = p.nodes.items(.data)[@intFromEnum(cast_info)].decl_ref;
- if (fn_ty.hasAttribute(.nodiscard)) try p.errStr(.nodiscard_unused, expr_start, p.tokSlice(decl_ref));
- if (fn_ty.hasAttribute(.warn_unused_result)) try p.errStr(.warn_unused_result, expr_start, p.tokSlice(decl_ref));
- return;
- },
- .call_expr => {
- const fn_ptr = p.data.items[p.nodes.items(.data)[@intFromEnum(cur_node)].range.start];
- const fn_ty = p.nodes.items(.ty)[@intFromEnum(fn_ptr)].elemType();
- const cast_info = p.nodes.items(.data)[@intFromEnum(fn_ptr)].cast.operand;
- const decl_ref = p.nodes.items(.data)[@intFromEnum(cast_info)].decl_ref;
- if (fn_ty.hasAttribute(.nodiscard)) try p.errStr(.nodiscard_unused, expr_start, p.tokSlice(decl_ref));
- if (fn_ty.hasAttribute(.warn_unused_result)) try p.errStr(.warn_unused_result, expr_start, p.tokSlice(decl_ref));
+ .call_expr, .call_expr_one => {
+ const tmp_tree = p.tmpTree();
+ const child_nodes = tmp_tree.childNodes(cur_node);
+ const fn_ptr = child_nodes[0];
+ const call_info = tmp_tree.callableResultUsage(fn_ptr) orelse return;
+ if (call_info.nodiscard) try p.errStr(.nodiscard_unused, expr_start, p.tokSlice(call_info.tok));
+ if (call_info.warn_unused_result) try p.errStr(.warn_unused_result, expr_start, p.tokSlice(call_info.tok));
return;
},
.stmt_expr => {
const body = p.nodes.items(.data)[@intFromEnum(cur_node)].un;
switch (p.nodes.items(.tag)[@intFromEnum(body)]) {
.compound_stmt_two => {
- const body_stmt = p.nodes.items(.data)[@intFromEnum(body)].bin;
- cur_node = if (body_stmt.rhs != .none) body_stmt.rhs else body_stmt.lhs;
+ const body_stmt = p.nodes.items(.data)[@intFromEnum(body)].two;
+ cur_node = if (body_stmt[1] != .none) body_stmt[1] else body_stmt[0];
},
.compound_stmt => {
const data = p.nodes.items(.data)[@intFromEnum(body)];
@@ -5112,29 +5261,31 @@ pub const Result = struct {
try p.errTok(.unused_value, expr_start);
}
- fn boolRes(lhs: *Result, p: *Parser, tag: Tree.Tag, rhs: Result) !void {
+ fn boolRes(lhs: *Result, p: *Parser, tag: Tree.Tag, rhs: Result, tok_i: TokenIndex) !void {
if (lhs.val.opt_ref == .null) {
lhs.val = Value.zero;
}
if (lhs.ty.specifier != .invalid) {
lhs.ty = Type.int;
}
- return lhs.bin(p, tag, rhs);
+ return lhs.bin(p, tag, rhs, tok_i);
}
- fn bin(lhs: *Result, p: *Parser, tag: Tree.Tag, rhs: Result) !void {
+ fn bin(lhs: *Result, p: *Parser, tag: Tree.Tag, rhs: Result, tok_i: TokenIndex) !void {
lhs.node = try p.addNode(.{
.tag = tag,
.ty = lhs.ty,
.data = .{ .bin = .{ .lhs = lhs.node, .rhs = rhs.node } },
+ .loc = @enumFromInt(tok_i),
});
}
- fn un(operand: *Result, p: *Parser, tag: Tree.Tag) Error!void {
+ fn un(operand: *Result, p: *Parser, tag: Tree.Tag, tok_i: TokenIndex) Error!void {
operand.node = try p.addNode(.{
.tag = tag,
.ty = operand.ty,
.data = .{ .un = operand.node },
+ .loc = @enumFromInt(tok_i),
});
}
@@ -5368,10 +5519,14 @@ pub const Result = struct {
fn lvalConversion(res: *Result, p: *Parser) Error!void {
if (res.ty.isFunc()) {
- const elem_ty = try p.arena.create(Type);
- elem_ty.* = res.ty;
- res.ty.specifier = .pointer;
- res.ty.data = .{ .sub_type = elem_ty };
+ if (res.ty.isInvalidFunc()) {
+ res.ty = .{ .specifier = .invalid };
+ } else {
+ const elem_ty = try p.arena.create(Type);
+ elem_ty.* = res.ty;
+ res.ty.specifier = .pointer;
+ res.ty.data = .{ .sub_type = elem_ty };
+ }
try res.implicitCast(p, .function_to_pointer);
} else if (res.ty.isArray()) {
res.val = .{};
@@ -5455,7 +5610,14 @@ pub const Result = struct {
try res.implicitCast(p, .complex_float_to_complex_int);
}
} else if (!res.ty.eql(int_ty, p.comp, true)) {
- try res.val.intCast(int_ty, p.comp);
+ const old_val = res.val;
+ const value_change_kind = try res.val.intCast(int_ty, p.comp);
+ switch (value_change_kind) {
+ .none => {},
+ .truncated => try p.errStr(.int_value_changed, tok, try p.valueChangedStr(res, old_val, int_ty)),
+ .sign_changed => try p.errStr(.sign_conversion, tok, try p.typePairStrExtra(res.ty, " to ", int_ty)),
+ }
+
const old_real = res.ty.isReal();
const new_real = int_ty.isReal();
if (old_real and new_real) {
@@ -5486,8 +5648,8 @@ pub const Result = struct {
.none => return p.errStr(.float_to_int, tok, try p.typePairStrExtra(res.ty, " to ", int_ty)),
.out_of_range => return p.errStr(.float_out_of_range, tok, try p.typePairStrExtra(res.ty, " to ", int_ty)),
.overflow => return p.errStr(.float_overflow_conversion, tok, try p.typePairStrExtra(res.ty, " to ", int_ty)),
- .nonzero_to_zero => return p.errStr(.float_zero_conversion, tok, try p.floatValueChangedStr(res, old_value, int_ty)),
- .value_changed => return p.errStr(.float_value_changed, tok, try p.floatValueChangedStr(res, old_value, int_ty)),
+ .nonzero_to_zero => return p.errStr(.float_zero_conversion, tok, try p.valueChangedStr(res, old_value, int_ty)),
+ .value_changed => return p.errStr(.float_value_changed, tok, try p.valueChangedStr(res, old_value, int_ty)),
}
}
@@ -5555,7 +5717,7 @@ pub const Result = struct {
res.ty = ptr_ty;
try res.implicitCast(p, .bool_to_pointer);
} else if (res.ty.isInt()) {
- try res.val.intCast(ptr_ty, p.comp);
+ _ = try res.val.intCast(ptr_ty, p.comp);
res.ty = ptr_ty;
try res.implicitCast(p, .int_to_pointer);
}
@@ -5620,16 +5782,14 @@ pub const Result = struct {
// if either is a float cast to that type
if (a.ty.isFloat() or b.ty.isFloat()) {
- const float_types = [7][2]Type.Specifier{
+ const float_types = [6][2]Type.Specifier{
.{ .complex_long_double, .long_double },
.{ .complex_float128, .float128 },
- .{ .complex_float80, .float80 },
.{ .complex_double, .double },
.{ .complex_float, .float },
// No `_Complex __fp16` type
.{ .invalid, .fp16 },
- // No `_Complex _Float16`
- .{ .invalid, .float16 },
+ .{ .complex_float16, .float16 },
};
const a_spec = a.ty.canonicalize(.standard).specifier;
const b_spec = b.ty.canonicalize(.standard).specifier;
@@ -5647,7 +5807,7 @@ pub const Result = struct {
if (try a.floatConversion(b, a_spec, b_spec, p, float_types[3])) return;
if (try a.floatConversion(b, a_spec, b_spec, p, float_types[4])) return;
if (try a.floatConversion(b, a_spec, b_spec, p, float_types[5])) return;
- if (try a.floatConversion(b, a_spec, b_spec, p, float_types[6])) return;
+ unreachable;
}
if (a.ty.eql(b.ty, p.comp, true)) {
@@ -5875,6 +6035,10 @@ pub const Result = struct {
if (to.is(.bool)) {
res.val.boolCast(p.comp);
} else if (old_float and new_int) {
+ if (to.hasIncompleteSize()) {
+ try p.errStr(.cast_to_incomplete_type, l_paren, try p.typeStr(to));
+ return error.ParsingFailed;
+ }
// Explicit cast, no conversion warning
_ = try res.val.floatToInt(to, p.comp);
} else if (new_float and old_int) {
@@ -5886,7 +6050,7 @@ pub const Result = struct {
try p.errStr(.cast_to_incomplete_type, l_paren, try p.typeStr(to));
return error.ParsingFailed;
}
- try res.val.intCast(to, p.comp);
+ _ = try res.val.intCast(to, p.comp);
}
} else if (to.get(.@"union")) |union_ty| {
if (union_ty.data.record.hasFieldOfType(res.ty, p.comp)) {
@@ -5918,12 +6082,13 @@ pub const Result = struct {
.tag = .explicit_cast,
.ty = res.ty,
.data = .{ .cast = .{ .operand = res.node, .kind = cast_kind } },
+ .loc = @enumFromInt(l_paren),
});
}
fn intFitsInType(res: Result, p: *Parser, ty: Type) !bool {
- const max_int = try Value.int(ty.maxInt(p.comp), p.comp);
- const min_int = try Value.int(ty.minInt(p.comp), p.comp);
+ const max_int = try Value.maxInt(ty, p.comp);
+ const min_int = try Value.minInt(ty, p.comp);
return res.val.compare(.lte, max_int, p.comp) and
(res.ty.isUnsignedInt(p.comp) or res.val.compare(.gte, min_int, p.comp));
}
@@ -6091,7 +6256,7 @@ fn expr(p: *Parser) Error!Result {
var err_start = p.comp.diagnostics.list.items.len;
var lhs = try p.assignExpr();
if (p.tok_ids[p.tok_i] == .comma) try lhs.expect(p);
- while (p.eatToken(.comma)) |_| {
+ while (p.eatToken(.comma)) |comma| {
try lhs.maybeWarnUnused(p, expr_start, err_start);
expr_start = p.tok_i;
err_start = p.comp.diagnostics.list.items.len;
@@ -6101,7 +6266,7 @@ fn expr(p: *Parser) Error!Result {
try rhs.lvalConversion(p);
lhs.val = rhs.val;
lhs.ty = rhs.ty;
- try lhs.bin(p, .comma_expr, rhs);
+ try lhs.bin(p, .comma_expr, rhs, comma);
}
return lhs;
}
@@ -6183,7 +6348,7 @@ fn assignExpr(p: *Parser) Error!Result {
}
}
_ = try lhs_copy.adjustTypes(tok, &rhs, p, if (tag == .mod_assign_expr) .integer else .arithmetic);
- try lhs.bin(p, tag, rhs);
+ try lhs.bin(p, tag, rhs, bit_or.?);
return lhs;
},
.sub_assign_expr,
@@ -6194,7 +6359,7 @@ fn assignExpr(p: *Parser) Error!Result {
} else {
_ = try lhs_copy.adjustTypes(tok, &rhs, p, .arithmetic);
}
- try lhs.bin(p, tag, rhs);
+ try lhs.bin(p, tag, rhs, bit_or.?);
return lhs;
},
.shl_assign_expr,
@@ -6204,7 +6369,7 @@ fn assignExpr(p: *Parser) Error!Result {
.bit_or_assign_expr,
=> {
_ = try lhs_copy.adjustTypes(tok, &rhs, p, .integer);
- try lhs.bin(p, tag, rhs);
+ try lhs.bin(p, tag, rhs, bit_or.?);
return lhs;
},
else => unreachable,
@@ -6212,7 +6377,7 @@ fn assignExpr(p: *Parser) Error!Result {
try rhs.coerce(p, lhs.ty, tok, .assign);
- try lhs.bin(p, tag, rhs);
+ try lhs.bin(p, tag, rhs, bit_or.?);
return lhs;
}
@@ -6280,6 +6445,7 @@ fn condExpr(p: *Parser) Error!Result {
.tag = .binary_cond_expr,
.ty = cond.ty,
.data = .{ .if3 = .{ .cond = cond.node, .body = (try p.addList(&.{ cond_then.node, then_expr.node })).start } },
+ .loc = @enumFromInt(cond_tok),
});
return cond;
}
@@ -6305,6 +6471,7 @@ fn condExpr(p: *Parser) Error!Result {
.tag = .cond_expr,
.ty = cond.ty,
.data = .{ .if3 = .{ .cond = cond.node, .body = (try p.addList(&.{ then_expr.node, else_expr.node })).start } },
+ .loc = @enumFromInt(cond_tok),
});
return cond;
}
@@ -6324,8 +6491,10 @@ fn lorExpr(p: *Parser) Error!Result {
if (try lhs.adjustTypes(tok, &rhs, p, .boolean_logic)) {
const res = lhs.val.toBool(p.comp) or rhs.val.toBool(p.comp);
lhs.val = Value.fromBool(res);
+ } else {
+ lhs.val.boolCast(p.comp);
}
- try lhs.boolRes(p, .bool_or_expr, rhs);
+ try lhs.boolRes(p, .bool_or_expr, rhs, tok);
}
return lhs;
}
@@ -6345,8 +6514,10 @@ fn landExpr(p: *Parser) Error!Result {
if (try lhs.adjustTypes(tok, &rhs, p, .boolean_logic)) {
const res = lhs.val.toBool(p.comp) and rhs.val.toBool(p.comp);
lhs.val = Value.fromBool(res);
+ } else {
+ lhs.val.boolCast(p.comp);
}
- try lhs.boolRes(p, .bool_and_expr, rhs);
+ try lhs.boolRes(p, .bool_and_expr, rhs, tok);
}
return lhs;
}
@@ -6362,7 +6533,7 @@ fn orExpr(p: *Parser) Error!Result {
if (try lhs.adjustTypes(tok, &rhs, p, .integer)) {
lhs.val = try lhs.val.bitOr(rhs.val, p.comp);
}
- try lhs.bin(p, .bit_or_expr, rhs);
+ try lhs.bin(p, .bit_or_expr, rhs, tok);
}
return lhs;
}
@@ -6378,7 +6549,7 @@ fn xorExpr(p: *Parser) Error!Result {
if (try lhs.adjustTypes(tok, &rhs, p, .integer)) {
lhs.val = try lhs.val.bitXor(rhs.val, p.comp);
}
- try lhs.bin(p, .bit_xor_expr, rhs);
+ try lhs.bin(p, .bit_xor_expr, rhs, tok);
}
return lhs;
}
@@ -6394,7 +6565,7 @@ fn andExpr(p: *Parser) Error!Result {
if (try lhs.adjustTypes(tok, &rhs, p, .integer)) {
lhs.val = try lhs.val.bitAnd(rhs.val, p.comp);
}
- try lhs.bin(p, .bit_and_expr, rhs);
+ try lhs.bin(p, .bit_and_expr, rhs, tok);
}
return lhs;
}
@@ -6414,8 +6585,10 @@ fn eqExpr(p: *Parser) Error!Result {
const op: std.math.CompareOperator = if (tag == .equal_expr) .eq else .neq;
const res = lhs.val.compare(op, rhs.val, p.comp);
lhs.val = Value.fromBool(res);
+ } else {
+ lhs.val.boolCast(p.comp);
}
- try lhs.boolRes(p, tag, rhs);
+ try lhs.boolRes(p, tag, rhs, ne.?);
}
return lhs;
}
@@ -6443,8 +6616,10 @@ fn compExpr(p: *Parser) Error!Result {
};
const res = lhs.val.compare(op, rhs.val, p.comp);
lhs.val = Value.fromBool(res);
+ } else {
+ lhs.val.boolCast(p.comp);
}
- try lhs.boolRes(p, tag, rhs);
+ try lhs.boolRes(p, tag, rhs, ge.?);
}
return lhs;
}
@@ -6474,7 +6649,7 @@ fn shiftExpr(p: *Parser) Error!Result {
lhs.val = try lhs.val.shr(rhs.val, lhs.ty, p.comp);
}
}
- try lhs.bin(p, tag, rhs);
+ try lhs.bin(p, tag, rhs, shr.?);
}
return lhs;
}
@@ -6504,7 +6679,7 @@ fn addExpr(p: *Parser) Error!Result {
try p.errStr(.ptr_arithmetic_incomplete, minus.?, try p.typeStr(lhs_ty.elemType()));
lhs.ty = Type.invalid;
}
- try lhs.bin(p, tag, rhs);
+ try lhs.bin(p, tag, rhs, minus.?);
}
return lhs;
}
@@ -6538,7 +6713,7 @@ fn mulExpr(p: *Parser) Error!Result {
lhs.ty.signedness(p.comp) != .unsigned) try p.errOverflow(mul.?, lhs);
} else if (div != null) {
if (try lhs.val.div(lhs.val, rhs.val, lhs.ty, p.comp) and
- lhs.ty.signedness(p.comp) != .unsigned) try p.errOverflow(mul.?, lhs);
+ lhs.ty.signedness(p.comp) != .unsigned) try p.errOverflow(div.?, lhs);
} else {
var res = try Value.rem(lhs.val, rhs.val, lhs.ty, p.comp);
if (res.opt_ref == .none) {
@@ -6554,7 +6729,7 @@ fn mulExpr(p: *Parser) Error!Result {
}
}
- try lhs.bin(p, tag, rhs);
+ try lhs.bin(p, tag, rhs, percent.?);
}
return lhs;
}
@@ -6573,7 +6748,7 @@ fn removeUnusedWarningForTok(p: *Parser, last_expr_tok: TokenIndex) void {
}
/// castExpr
-/// : '(' compoundStmt ')'
+/// : '(' compoundStmt ')' suffixExpr*
/// | '(' typeName ')' castExpr
/// | '(' typeName ')' '{' initializerItems '}'
/// | __builtin_choose_expr '(' integerConstExpr ',' assignExpr ',' assignExpr ')'
@@ -6584,6 +6759,7 @@ fn removeUnusedWarningForTok(p: *Parser, last_expr_tok: TokenIndex) void {
fn castExpr(p: *Parser) Error!Result {
if (p.eatToken(.l_paren)) |l_paren| cast_expr: {
if (p.tok_ids[p.tok_i] == .l_brace) {
+ const tok = p.tok_i;
try p.err(.gnu_statement_expression);
if (p.func.ty == null) {
try p.err(.stmt_expr_not_allowed_file_scope);
@@ -6599,7 +6775,12 @@ fn castExpr(p: *Parser) Error!Result {
.val = stmt_expr_state.last_expr_res.val,
};
try p.expectClosing(l_paren, .r_paren);
- try res.un(p, .stmt_expr);
+ try res.un(p, .stmt_expr, tok);
+ while (true) {
+ const suffix = try p.suffixExpr(res);
+ if (suffix.empty(p)) break;
+ res = suffix;
+ }
return res;
}
const ty = (try p.typeName()) orelse {
@@ -6634,23 +6815,26 @@ fn castExpr(p: *Parser) Error!Result {
}
fn typesCompatible(p: *Parser) Error!Result {
+ const builtin_tok = p.tok_i;
p.tok_i += 1;
const l_paren = try p.expectToken(.l_paren);
+ const first_tok = p.tok_i;
const first = (try p.typeName()) orelse {
try p.err(.expected_type);
p.skipTo(.r_paren);
return error.ParsingFailed;
};
- const lhs = try p.addNode(.{ .tag = .invalid, .ty = first, .data = undefined });
+ const lhs = try p.addNode(.{ .tag = .invalid, .ty = first, .data = undefined, .loc = @enumFromInt(first_tok) });
_ = try p.expectToken(.comma);
+ const second_tok = p.tok_i;
const second = (try p.typeName()) orelse {
try p.err(.expected_type);
p.skipTo(.r_paren);
return error.ParsingFailed;
};
- const rhs = try p.addNode(.{ .tag = .invalid, .ty = second, .data = undefined });
+ const rhs = try p.addNode(.{ .tag = .invalid, .ty = second, .data = undefined, .loc = @enumFromInt(second_tok) });
try p.expectClosing(l_paren, .r_paren);
@@ -6665,10 +6849,15 @@ fn typesCompatible(p: *Parser) Error!Result {
const res = Result{
.val = Value.fromBool(compatible),
- .node = try p.addNode(.{ .tag = .builtin_types_compatible_p, .ty = Type.int, .data = .{ .bin = .{
- .lhs = lhs,
- .rhs = rhs,
- } } }),
+ .node = try p.addNode(.{
+ .tag = .builtin_types_compatible_p,
+ .ty = Type.int,
+ .data = .{ .bin = .{
+ .lhs = lhs,
+ .rhs = rhs,
+ } },
+ .loc = @enumFromInt(builtin_tok),
+ }),
};
try p.value_map.put(res.node, res.val);
return res;
@@ -6786,11 +6975,11 @@ fn offsetofMemberDesignator(p: *Parser, base_ty: Type, want_bits: bool) Error!Re
errdefer p.skipTo(.r_paren);
const base_field_name_tok = try p.expectIdentifier();
const base_field_name = try StrInt.intern(p.comp, p.tokSlice(base_field_name_tok));
- try p.validateFieldAccess(base_ty, base_ty, base_field_name_tok, base_field_name);
+ const base_record_ty = base_ty.getRecord().?;
+ try p.validateFieldAccess(base_record_ty, base_ty, base_field_name_tok, base_field_name);
const base_node = try p.addNode(.{ .tag = .default_init_expr, .ty = base_ty, .data = undefined });
var cur_offset: u64 = 0;
- const base_record_ty = base_ty.canonicalize(.standard);
var lhs = try p.fieldAccessExtra(base_node, base_record_ty, base_field_name, false, &cur_offset);
var total_offset = cur_offset;
@@ -6800,13 +6989,12 @@ fn offsetofMemberDesignator(p: *Parser, base_ty: Type, want_bits: bool) Error!Re
const field_name_tok = try p.expectIdentifier();
const field_name = try StrInt.intern(p.comp, p.tokSlice(field_name_tok));
- if (!lhs.ty.isRecord()) {
+ const lhs_record_ty = lhs.ty.getRecord() orelse {
try p.errStr(.offsetof_ty, field_name_tok, try p.typeStr(lhs.ty));
return error.ParsingFailed;
- }
- try p.validateFieldAccess(lhs.ty, lhs.ty, field_name_tok, field_name);
- const record_ty = lhs.ty.canonicalize(.standard);
- lhs = try p.fieldAccessExtra(lhs.node, record_ty, field_name, false, &cur_offset);
+ };
+ try p.validateFieldAccess(lhs_record_ty, lhs.ty, field_name_tok, field_name);
+ lhs = try p.fieldAccessExtra(lhs.node, lhs_record_ty, field_name, false, &cur_offset);
total_offset += cur_offset;
},
.l_bracket => {
@@ -6824,11 +7012,14 @@ fn offsetofMemberDesignator(p: *Parser, base_ty: Type, want_bits: bool) Error!Re
try ptr.lvalConversion(p);
try index.lvalConversion(p);
- if (!index.ty.isInt()) try p.errTok(.invalid_index, l_bracket_tok);
- try p.checkArrayBounds(index, lhs, l_bracket_tok);
+ if (index.ty.isInt()) {
+ try p.checkArrayBounds(index, lhs, l_bracket_tok);
+ } else {
+ try p.errTok(.invalid_index, l_bracket_tok);
+ }
try index.saveValue(p);
- try ptr.bin(p, .array_access_expr, index);
+ try ptr.bin(p, .array_access_expr, index, l_bracket_tok);
lhs = ptr;
},
else => break,
@@ -6867,6 +7058,7 @@ fn unExpr(p: *Parser) Error!Result {
.tag = .addr_of_label,
.data = .{ .decl_ref = name_tok },
.ty = result_ty,
+ .loc = @enumFromInt(address_tok),
}),
.ty = result_ty,
};
@@ -6886,19 +7078,21 @@ fn unExpr(p: *Parser) Error!Result {
{
if (tree.isBitfield(member_node)) try p.errTok(.addr_of_bitfield, tok);
}
- if (!tree.isLval(operand.node)) {
+ if (!tree.isLval(operand.node) and !operand.ty.is(.invalid)) {
try p.errTok(.addr_of_rvalue, tok);
}
if (operand.ty.qual.register) try p.errTok(.addr_of_register, tok);
- const elem_ty = try p.arena.create(Type);
- elem_ty.* = operand.ty;
- operand.ty = Type{
- .specifier = .pointer,
- .data = .{ .sub_type = elem_ty },
- };
+ if (!operand.ty.is(.invalid)) {
+ const elem_ty = try p.arena.create(Type);
+ elem_ty.* = operand.ty;
+ operand.ty = Type{
+ .specifier = .pointer,
+ .data = .{ .sub_type = elem_ty },
+ };
+ }
try operand.saveValue(p);
- try operand.un(p, .addr_of_expr);
+ try operand.un(p, .addr_of_expr, tok);
return operand;
},
.asterisk => {
@@ -6917,7 +7111,7 @@ fn unExpr(p: *Parser) Error!Result {
try p.errStr(.deref_incomplete_ty_ptr, asterisk_loc, try p.typeStr(operand.ty));
}
operand.ty.qual = .{};
- try operand.un(p, .deref_expr);
+ try operand.un(p, .deref_expr, tok);
return operand;
},
.plus => {
@@ -6943,12 +7137,12 @@ fn unExpr(p: *Parser) Error!Result {
try p.errStr(.invalid_argument_un, tok, try p.typeStr(operand.ty));
try operand.usualUnaryConversion(p, tok);
- if (operand.val.is(.int, p.comp) or operand.val.is(.float, p.comp)) {
+ if (operand.val.isArithmetic(p.comp)) {
_ = try operand.val.sub(Value.zero, operand.val, operand.ty, p.comp);
} else {
operand.val = .{};
}
- try operand.un(p, .negate_expr);
+ try operand.un(p, .negate_expr, tok);
return operand;
},
.plus_plus => {
@@ -6974,7 +7168,7 @@ fn unExpr(p: *Parser) Error!Result {
operand.val = .{};
}
- try operand.un(p, .pre_inc_expr);
+ try operand.un(p, .pre_inc_expr, tok);
return operand;
},
.minus_minus => {
@@ -7000,7 +7194,7 @@ fn unExpr(p: *Parser) Error!Result {
operand.val = .{};
}
- try operand.un(p, .pre_dec_expr);
+ try operand.un(p, .pre_dec_expr, tok);
return operand;
},
.tilde => {
@@ -7016,11 +7210,14 @@ fn unExpr(p: *Parser) Error!Result {
}
} else if (operand.ty.isComplex()) {
try p.errStr(.complex_conj, tok, try p.typeStr(operand.ty));
+ if (operand.val.is(.complex, p.comp)) {
+ operand.val = try operand.val.complexConj(operand.ty, p.comp);
+ }
} else {
try p.errStr(.invalid_argument_un, tok, try p.typeStr(operand.ty));
operand.val = .{};
}
- try operand.un(p, .bit_not_expr);
+ try operand.un(p, .bit_not_expr, tok);
return operand;
},
.bang => {
@@ -7045,7 +7242,7 @@ fn unExpr(p: *Parser) Error!Result {
}
}
operand.ty = .{ .specifier = .int };
- try operand.un(p, .bool_not_expr);
+ try operand.un(p, .bool_not_expr, tok);
return operand;
},
.keyword_sizeof => {
@@ -7089,7 +7286,7 @@ fn unExpr(p: *Parser) Error!Result {
res.ty = p.comp.types.size;
}
}
- try res.un(p, .sizeof_expr);
+ try res.un(p, .sizeof_expr, tok);
return res;
},
.keyword_alignof,
@@ -7127,7 +7324,7 @@ fn unExpr(p: *Parser) Error!Result {
try p.errStr(.invalid_alignof, expected_paren, try p.typeStr(res.ty));
res.ty = Type.invalid;
}
- try res.un(p, .alignof_expr);
+ try res.un(p, .alignof_expr, tok);
return res;
},
.keyword_extension => {
@@ -7147,15 +7344,18 @@ fn unExpr(p: *Parser) Error!Result {
var operand = try p.castExpr();
try operand.expect(p);
try operand.lvalConversion(p);
+ if (operand.ty.is(.invalid)) return Result.invalid;
if (!operand.ty.isInt() and !operand.ty.isFloat()) {
try p.errStr(.invalid_imag, imag_tok, try p.typeStr(operand.ty));
}
- if (operand.ty.isReal()) {
+ if (operand.ty.isComplex()) {
+ operand.val = try operand.val.imaginaryPart(p.comp);
+ } else if (operand.ty.isReal()) {
switch (p.comp.langopts.emulate) {
.msvc => {}, // Doesn't support `_Complex` or `__imag` in the first place
.gcc => operand.val = Value.zero,
.clang => {
- if (operand.val.is(.int, p.comp)) {
+ if (operand.val.is(.int, p.comp) or operand.val.is(.float, p.comp)) {
operand.val = Value.zero;
} else {
operand.val = .{};
@@ -7165,7 +7365,7 @@ fn unExpr(p: *Parser) Error!Result {
}
// convert _Complex T to T
operand.ty = operand.ty.makeReal();
- try operand.un(p, .imag_expr);
+ try operand.un(p, .imag_expr, tok);
return operand;
},
.keyword_real1, .keyword_real2 => {
@@ -7175,12 +7375,14 @@ fn unExpr(p: *Parser) Error!Result {
var operand = try p.castExpr();
try operand.expect(p);
try operand.lvalConversion(p);
+ if (operand.ty.is(.invalid)) return Result.invalid;
if (!operand.ty.isInt() and !operand.ty.isFloat()) {
try p.errStr(.invalid_real, real_tok, try p.typeStr(operand.ty));
}
// convert _Complex T to T
operand.ty = operand.ty.makeReal();
- try operand.un(p, .real_expr);
+ operand.val = try operand.val.realPart(p.comp);
+ try operand.un(p, .real_expr, tok);
return operand;
},
else => {
@@ -7253,7 +7455,7 @@ fn compoundLiteral(p: *Parser) Error!Result {
if (d.constexpr) |_| {
// TODO error if not constexpr
}
- try init_list_expr.un(p, tag);
+ try init_list_expr.un(p, tag, l_paren);
return init_list_expr;
}
@@ -7284,7 +7486,7 @@ fn suffixExpr(p: *Parser, lhs: Result) Error!Result {
}
try operand.usualUnaryConversion(p, p.tok_i);
- try operand.un(p, .post_inc_expr);
+ try operand.un(p, .post_inc_expr, p.tok_i);
return operand;
},
.minus_minus => {
@@ -7302,7 +7504,7 @@ fn suffixExpr(p: *Parser, lhs: Result) Error!Result {
}
try operand.usualUnaryConversion(p, p.tok_i);
- try operand.un(p, .post_dec_expr);
+ try operand.un(p, .post_dec_expr, p.tok_i);
return operand;
},
.l_bracket => {
@@ -7319,12 +7521,18 @@ fn suffixExpr(p: *Parser, lhs: Result) Error!Result {
try index.lvalConversion(p);
if (ptr.ty.isPtr()) {
ptr.ty = ptr.ty.elemType();
- if (!index.ty.isInt()) try p.errTok(.invalid_index, l_bracket);
- try p.checkArrayBounds(index_before_conversion, array_before_conversion, l_bracket);
+ if (index.ty.isInt()) {
+ try p.checkArrayBounds(index_before_conversion, array_before_conversion, l_bracket);
+ } else {
+ try p.errTok(.invalid_index, l_bracket);
+ }
} else if (index.ty.isPtr()) {
index.ty = index.ty.elemType();
- if (!ptr.ty.isInt()) try p.errTok(.invalid_index, l_bracket);
- try p.checkArrayBounds(array_before_conversion, index_before_conversion, l_bracket);
+ if (ptr.ty.isInt()) {
+ try p.checkArrayBounds(array_before_conversion, index_before_conversion, l_bracket);
+ } else {
+ try p.errTok(.invalid_index, l_bracket);
+ }
std.mem.swap(Result, &ptr, &index);
} else {
try p.errTok(.invalid_subscript, l_bracket);
@@ -7332,7 +7540,7 @@ fn suffixExpr(p: *Parser, lhs: Result) Error!Result {
try ptr.saveValue(p);
try index.saveValue(p);
- try ptr.bin(p, .array_access_expr, index);
+ try ptr.bin(p, .array_access_expr, index, l_bracket);
return ptr;
},
.period => {
@@ -7364,16 +7572,12 @@ fn fieldAccess(
const expr_ty = lhs.ty;
const is_ptr = expr_ty.isPtr();
const expr_base_ty = if (is_ptr) expr_ty.elemType() else expr_ty;
- const record_ty = expr_base_ty.canonicalize(.standard);
+ const record_ty = expr_base_ty.getRecord() orelse {
+ try p.errStr(.expected_record_ty, field_name_tok, try p.typeStr(expr_ty));
+ return error.ParsingFailed;
+ };
- switch (record_ty.specifier) {
- .@"struct", .@"union" => {},
- else => {
- try p.errStr(.expected_record_ty, field_name_tok, try p.typeStr(expr_ty));
- return error.ParsingFailed;
- },
- }
- if (record_ty.hasIncompleteSize()) {
+ if (record_ty.isIncomplete()) {
try p.errStr(.deref_incomplete_ty_ptr, field_name_tok - 2, try p.typeStr(expr_base_ty));
return error.ParsingFailed;
}
@@ -7386,7 +7590,7 @@ fn fieldAccess(
return p.fieldAccessExtra(lhs.node, record_ty, field_name, is_arrow, &discard);
}
-fn validateFieldAccess(p: *Parser, record_ty: Type, expr_ty: Type, field_name_tok: TokenIndex, field_name: StringId) Error!void {
+fn validateFieldAccess(p: *Parser, record_ty: *const Type.Record, expr_ty: Type, field_name_tok: TokenIndex, field_name: StringId) Error!void {
if (record_ty.hasField(field_name)) return;
p.strings.items.len = 0;
@@ -7401,8 +7605,8 @@ fn validateFieldAccess(p: *Parser, record_ty: Type, expr_ty: Type, field_name_to
return error.ParsingFailed;
}
-fn fieldAccessExtra(p: *Parser, lhs: NodeIndex, record_ty: Type, field_name: StringId, is_arrow: bool, offset_bits: *u64) Error!Result {
- for (record_ty.data.record.fields, 0..) |f, i| {
+fn fieldAccessExtra(p: *Parser, lhs: NodeIndex, record_ty: *const Type.Record, field_name: StringId, is_arrow: bool, offset_bits: *u64) Error!Result {
+ for (record_ty.fields, 0..) |f, i| {
if (f.isAnonymousRecord()) {
if (!f.ty.hasField(field_name)) continue;
const inner = try p.addNode(.{
@@ -7410,7 +7614,7 @@ fn fieldAccessExtra(p: *Parser, lhs: NodeIndex, record_ty: Type, field_name: Str
.ty = f.ty,
.data = .{ .member = .{ .lhs = lhs, .index = @intCast(i) } },
});
- const ret = p.fieldAccessExtra(inner, f.ty, field_name, false, offset_bits);
+ const ret = p.fieldAccessExtra(inner, f.ty.getRecord().?, field_name, false, offset_bits);
offset_bits.* = f.layout.offset_bits;
return ret;
}
@@ -7527,6 +7731,23 @@ fn callExpr(p: *Parser, lhs: Result) Error!Result {
continue;
}
const p_ty = params[arg_count].ty;
+ if (p_ty.specifier == .static_array) {
+ const arg_array_len: u64 = arg.ty.arrayLen() orelse std.math.maxInt(u64);
+ const param_array_len: u64 = p_ty.arrayLen().?;
+ if (arg_array_len < param_array_len) {
+ const extra = Diagnostics.Message.Extra{ .arguments = .{
+ .expected = @intCast(arg_array_len),
+ .actual = @intCast(param_array_len),
+ } };
+ try p.errExtra(.array_argument_too_small, param_tok, extra);
+ try p.errTok(.callee_with_static_array, params[arg_count].name_tok);
+ }
+ if (arg.val.isZero(p.comp)) {
+ try p.errTok(.non_null_argument, param_tok);
+ try p.errTok(.callee_with_static_array, params[arg_count].name_tok);
+ }
+ }
+
if (call_expr.shouldCoerceArg(arg_count)) {
try arg.coerce(p, p_ty, param_tok, .{ .arg = params[arg_count].name_tok });
}
@@ -7618,7 +7839,7 @@ fn primaryExpr(p: *Parser) Error!Result {
var e = try p.expr();
try e.expect(p);
try p.expectClosing(l_paren, .r_paren);
- try e.un(p, .paren_expr);
+ try e.un(p, .paren_expr, l_paren);
return e;
}
switch (p.tok_ids[p.tok_i]) {
@@ -7626,6 +7847,10 @@ fn primaryExpr(p: *Parser) Error!Result {
const name_tok = try p.expectIdentifier();
const name = p.tokSlice(name_tok);
const interned_name = try StrInt.intern(p.comp, name);
+ if (interned_name == p.auto_type_decl_name) {
+ try p.errStr(.auto_type_self_initialized, name_tok, name);
+ return error.ParsingFailed;
+ }
if (p.syms.findSymbol(interned_name)) |sym| {
try p.checkDeprecatedUnavailable(sym.ty, name_tok, sym.tok);
if (sym.kind == .constexpr) {
@@ -7636,6 +7861,7 @@ fn primaryExpr(p: *Parser) Error!Result {
.tag = .decl_ref_expr,
.ty = sym.ty,
.data = .{ .decl_ref = name_tok },
+ .loc = @enumFromInt(name_tok),
}),
};
}
@@ -7653,6 +7879,7 @@ fn primaryExpr(p: *Parser) Error!Result {
.tag = if (sym.kind == .enumeration) .enumeration_ref else .decl_ref_expr,
.ty = sym.ty,
.data = .{ .decl_ref = name_tok },
+ .loc = @enumFromInt(name_tok),
}),
};
}
@@ -7679,6 +7906,7 @@ fn primaryExpr(p: *Parser) Error!Result {
.tag = .builtin_call_expr_one,
.ty = some.ty,
.data = .{ .decl = .{ .name = name_tok, .node = .none } },
+ .loc = @enumFromInt(name_tok),
}),
};
}
@@ -7696,6 +7924,7 @@ fn primaryExpr(p: *Parser) Error!Result {
.ty = ty,
.tag = .fn_proto,
.data = .{ .decl = .{ .name = name_tok } },
+ .loc = @enumFromInt(name_tok),
});
try p.decl_buf.append(node);
@@ -7707,6 +7936,7 @@ fn primaryExpr(p: *Parser) Error!Result {
.tag = .decl_ref_expr,
.ty = ty,
.data = .{ .decl_ref = name_tok },
+ .loc = @enumFromInt(name_tok),
}),
};
}
@@ -7714,11 +7944,12 @@ fn primaryExpr(p: *Parser) Error!Result {
return error.ParsingFailed;
},
.keyword_true, .keyword_false => |id| {
+ const tok_i = p.tok_i;
p.tok_i += 1;
const res = Result{
.val = Value.fromBool(id == .keyword_true),
.ty = .{ .specifier = .bool },
- .node = try p.addNode(.{ .tag = .bool_literal, .ty = .{ .specifier = .bool }, .data = undefined }),
+ .node = try p.addNode(.{ .tag = .bool_literal, .ty = .{ .specifier = .bool }, .data = undefined, .loc = @enumFromInt(tok_i) }),
};
std.debug.assert(!p.in_macro); // Should have been replaced with .one / .zero
try p.value_map.put(res.node, res.val);
@@ -7734,6 +7965,7 @@ fn primaryExpr(p: *Parser) Error!Result {
.tag = .nullptr_literal,
.ty = .{ .specifier = .nullptr_t },
.data = undefined,
+ .loc = @enumFromInt(p.tok_i),
}),
};
},
@@ -7770,6 +8002,7 @@ fn primaryExpr(p: *Parser) Error!Result {
.tag = .decl_ref_expr,
.ty = ty,
.data = .{ .decl_ref = tok },
+ .loc = @enumFromInt(tok),
}),
};
},
@@ -7805,6 +8038,7 @@ fn primaryExpr(p: *Parser) Error!Result {
.tag = .decl_ref_expr,
.ty = ty,
.data = .{ .decl_ref = p.tok_i },
+ .loc = @enumFromInt(p.tok_i),
}),
};
},
@@ -7824,16 +8058,16 @@ fn primaryExpr(p: *Parser) Error!Result {
.unterminated_char_literal,
=> return p.charLiteral(),
.zero => {
- p.tok_i += 1;
+ defer p.tok_i += 1;
var res: Result = .{ .val = Value.zero, .ty = if (p.in_macro) p.comp.types.intmax else Type.int };
- res.node = try p.addNode(.{ .tag = .int_literal, .ty = res.ty, .data = undefined });
+ res.node = try p.addNode(.{ .tag = .int_literal, .ty = res.ty, .data = undefined, .loc = @enumFromInt(p.tok_i) });
if (!p.in_macro) try p.value_map.put(res.node, res.val);
return res;
},
.one => {
- p.tok_i += 1;
+ defer p.tok_i += 1;
var res: Result = .{ .val = Value.one, .ty = if (p.in_macro) p.comp.types.intmax else Type.int };
- res.node = try p.addNode(.{ .tag = .int_literal, .ty = res.ty, .data = undefined });
+ res.node = try p.addNode(.{ .tag = .int_literal, .ty = res.ty, .data = undefined, .loc = @enumFromInt(p.tok_i) });
if (!p.in_macro) try p.value_map.put(res.node, res.val);
return res;
},
@@ -7841,7 +8075,7 @@ fn primaryExpr(p: *Parser) Error!Result {
.embed_byte => {
assert(!p.in_macro);
const loc = p.pp.tokens.items(.loc)[p.tok_i];
- p.tok_i += 1;
+ defer p.tok_i += 1;
const buf = p.comp.getSource(.generated).buf[loc.byte_offset..];
var byte: u8 = buf[0] - '0';
for (buf[1..]) |c| {
@@ -7850,7 +8084,7 @@ fn primaryExpr(p: *Parser) Error!Result {
byte += c - '0';
}
var res: Result = .{ .val = try Value.int(byte, p.comp) };
- res.node = try p.addNode(.{ .tag = .int_literal, .ty = res.ty, .data = undefined });
+ res.node = try p.addNode(.{ .tag = .int_literal, .ty = res.ty, .data = undefined, .loc = @enumFromInt(p.tok_i) });
try p.value_map.put(res.node, res.val);
return res;
},
@@ -7869,17 +8103,19 @@ fn makePredefinedIdentifier(p: *Parser, strings_top: usize) !Result {
const slice = p.strings.items[strings_top..];
const val = try Value.intern(p.comp, .{ .bytes = slice });
- const str_lit = try p.addNode(.{ .tag = .string_literal_expr, .ty = ty, .data = undefined });
+ const str_lit = try p.addNode(.{ .tag = .string_literal_expr, .ty = ty, .data = undefined, .loc = @enumFromInt(p.tok_i) });
if (!p.in_macro) try p.value_map.put(str_lit, val);
return Result{ .ty = ty, .node = try p.addNode(.{
.tag = .implicit_static_var,
.ty = ty,
.data = .{ .decl = .{ .name = p.tok_i, .node = str_lit } },
+ .loc = @enumFromInt(p.tok_i),
}) };
}
fn stringLiteral(p: *Parser) Error!Result {
+ const string_start = p.tok_i;
var string_end = p.tok_i;
var string_kind: text_literal.Kind = .char;
while (text_literal.Kind.classify(p.tok_ids[string_end], .string_literal)) |next| : (string_end += 1) {
@@ -7894,13 +8130,17 @@ fn stringLiteral(p: *Parser) Error!Result {
return error.ParsingFailed;
}
}
- assert(string_end > p.tok_i);
+ const count = string_end - p.tok_i;
+ assert(count > 0);
const char_width = string_kind.charUnitSize(p.comp);
const strings_top = p.strings.items.len;
defer p.strings.items.len = strings_top;
+ const literal_start = mem.alignForward(usize, strings_top, @intFromEnum(char_width));
+ try p.strings.resize(literal_start);
+
while (p.tok_i < string_end) : (p.tok_i += 1) {
const this_kind = text_literal.Kind.classify(p.tok_ids[p.tok_i], .string_literal).?;
const slice = this_kind.contentSlice(p.tokSlice(p.tok_i));
@@ -7940,12 +8180,18 @@ fn stringLiteral(p: *Parser) Error!Result {
},
}
},
- .improperly_encoded => |bytes| p.strings.appendSliceAssumeCapacity(bytes),
+ .improperly_encoded => |bytes| {
+ if (count > 1) {
+ try p.errTok(.illegal_char_encoding_error, p.tok_i);
+ return error.ParsingFailed;
+ }
+ p.strings.appendSliceAssumeCapacity(bytes);
+ },
.utf8_text => |view| {
switch (char_width) {
.@"1" => p.strings.appendSliceAssumeCapacity(view.bytes),
.@"2" => {
- const capacity_slice: []align(@alignOf(u16)) u8 = @alignCast(p.strings.unusedCapacitySlice());
+ const capacity_slice: []align(@alignOf(u16)) u8 = @alignCast(p.strings.allocatedSlice()[literal_start..]);
const dest_len = std.mem.alignBackward(usize, capacity_slice.len, 2);
const dest = std.mem.bytesAsSlice(u16, capacity_slice[0..dest_len]);
const words_written = std.unicode.utf8ToUtf16Le(dest, view.bytes) catch unreachable;
@@ -7966,7 +8212,7 @@ fn stringLiteral(p: *Parser) Error!Result {
}
}
p.strings.appendNTimesAssumeCapacity(0, @intFromEnum(char_width));
- const slice = p.strings.items[strings_top..];
+ const slice = p.strings.items[literal_start..];
// TODO this won't do anything if there is a cache hit
const interned_align = mem.alignForward(
@@ -7987,7 +8233,7 @@ fn stringLiteral(p: *Parser) Error!Result {
},
.val = val,
};
- res.node = try p.addNode(.{ .tag = .string_literal_expr, .ty = res.ty, .data = undefined });
+ res.node = try p.addNode(.{ .tag = .string_literal_expr, .ty = res.ty, .data = undefined, .loc = @enumFromInt(string_start) });
if (!p.in_macro) try p.value_map.put(res.node, res.val);
return res;
}
@@ -8004,7 +8250,7 @@ fn charLiteral(p: *Parser) Error!Result {
return .{
.ty = Type.int,
.val = Value.zero,
- .node = try p.addNode(.{ .tag = .char_literal, .ty = Type.int, .data = undefined }),
+ .node = try p.addNode(.{ .tag = .char_literal, .ty = Type.int, .data = undefined, .loc = @enumFromInt(p.tok_i) }),
};
};
if (char_kind == .utf_8) try p.err(.u8_char_lit);
@@ -8013,7 +8259,7 @@ fn charLiteral(p: *Parser) Error!Result {
const slice = char_kind.contentSlice(p.tokSlice(p.tok_i));
var is_multichar = false;
- if (slice.len == 1 and std.ascii.isAscii(slice[0])) {
+ if (slice.len == 1 and std.ascii.isASCII(slice[0])) {
// fast path: single unescaped ASCII char
val = slice[0];
} else {
@@ -8096,25 +8342,25 @@ fn charLiteral(p: *Parser) Error!Result {
// > that of the single character or escape sequence is converted to type int.
// This conversion only matters if `char` is signed and has a high-order bit of `1`
if (char_kind == .char and !is_multichar and val > 0x7F and p.comp.getCharSignedness() == .signed) {
- try value.intCast(.{ .specifier = .char }, p.comp);
+ _ = try value.intCast(.{ .specifier = .char }, p.comp);
}
const res = Result{
.ty = if (p.in_macro) macro_ty else ty,
.val = value,
- .node = try p.addNode(.{ .tag = .char_literal, .ty = ty, .data = undefined }),
+ .node = try p.addNode(.{ .tag = .char_literal, .ty = ty, .data = undefined, .loc = @enumFromInt(p.tok_i) }),
};
if (!p.in_macro) try p.value_map.put(res.node, res.val);
return res;
}
-fn parseFloat(p: *Parser, buf: []const u8, suffix: NumberSuffix) !Result {
+fn parseFloat(p: *Parser, buf: []const u8, suffix: NumberSuffix, tok_i: TokenIndex) !Result {
const ty = Type{ .specifier = switch (suffix) {
.None, .I => .double,
.F, .IF => .float,
- .F16 => .float16,
+ .F16, .IF16 => .float16,
.L, .IL => .long_double,
- .W, .IW => .float80,
+ .W, .IW => p.comp.float80Type().?.specifier,
.Q, .IQ, .F128, .IF128 => .float128,
else => unreachable,
} };
@@ -8140,21 +8386,29 @@ fn parseFloat(p: *Parser, buf: []const u8, suffix: NumberSuffix) !Result {
});
var res = Result{
.ty = ty,
- .node = try p.addNode(.{ .tag = .float_literal, .ty = ty, .data = undefined }),
+ .node = try p.addNode(.{ .tag = .float_literal, .ty = ty, .data = undefined, .loc = @enumFromInt(tok_i) }),
.val = val,
};
if (suffix.isImaginary()) {
try p.err(.gnu_imaginary_constant);
res.ty = .{ .specifier = switch (suffix) {
.I => .complex_double,
+ .IF16 => .complex_float16,
.IF => .complex_float,
.IL => .complex_long_double,
- .IW => .complex_float80,
+ .IW => p.comp.float80Type().?.makeComplex().specifier,
.IQ, .IF128 => .complex_float128,
else => unreachable,
} };
- res.val = .{}; // TODO add complex values
- try res.un(p, .imaginary_literal);
+ res.val = try Value.intern(p.comp, switch (res.ty.bitSizeof(p.comp).?) {
+ 32 => .{ .complex = .{ .cf16 = .{ 0.0, val.toFloat(f16, p.comp) } } },
+ 64 => .{ .complex = .{ .cf32 = .{ 0.0, val.toFloat(f32, p.comp) } } },
+ 128 => .{ .complex = .{ .cf64 = .{ 0.0, val.toFloat(f64, p.comp) } } },
+ 160 => .{ .complex = .{ .cf80 = .{ 0.0, val.toFloat(f80, p.comp) } } },
+ 256 => .{ .complex = .{ .cf128 = .{ 0.0, val.toFloat(f128, p.comp) } } },
+ else => unreachable,
+ });
+ try res.un(p, .imaginary_literal, tok_i);
}
return res;
}
@@ -8233,12 +8487,14 @@ fn fixedSizeInt(p: *Parser, base: u8, buf: []const u8, suffix: NumberSuffix, tok
if (overflow) {
try p.errTok(.int_literal_too_big, tok_i);
res.ty = .{ .specifier = .ulong_long };
- res.node = try p.addNode(.{ .tag = .int_literal, .ty = res.ty, .data = undefined });
+ res.node = try p.addNode(.{ .tag = .int_literal, .ty = res.ty, .data = undefined, .loc = @enumFromInt(tok_i) });
if (!p.in_macro) try p.value_map.put(res.node, res.val);
return res;
}
+ const interned_val = try Value.int(val, p.comp);
if (suffix.isSignedInteger()) {
- if (val > p.comp.types.intmax.maxInt(p.comp)) {
+ const max_int = try Value.maxInt(p.comp.types.intmax, p.comp);
+ if (interned_val.compare(.gt, max_int, p.comp)) {
try p.errTok(.implicitly_unsigned_literal, tok_i);
}
}
@@ -8266,13 +8522,23 @@ fn fixedSizeInt(p: *Parser, base: u8, buf: []const u8, suffix: NumberSuffix, tok
for (specs) |spec| {
res.ty = Type{ .specifier = spec };
if (res.ty.compareIntegerRanks(suffix_ty, p.comp).compare(.lt)) continue;
- const max_int = res.ty.maxInt(p.comp);
- if (val <= max_int) break;
+ const max_int = try Value.maxInt(res.ty, p.comp);
+ if (interned_val.compare(.lte, max_int, p.comp)) break;
} else {
- res.ty = .{ .specifier = .ulong_long };
+ res.ty = .{ .specifier = spec: {
+ if (p.comp.langopts.emulate == .gcc) {
+ if (target_util.hasInt128(p.comp.target)) {
+ break :spec .int128;
+ } else {
+ break :spec .long_long;
+ }
+ } else {
+ break :spec .ulong_long;
+ }
+ } };
}
- res.node = try p.addNode(.{ .tag = .int_literal, .ty = res.ty, .data = undefined });
+ res.node = try p.addNode(.{ .tag = .int_literal, .ty = res.ty, .data = undefined, .loc = @enumFromInt(tok_i) });
if (!p.in_macro) try p.value_map.put(res.node, res.val);
return res;
}
@@ -8291,7 +8557,7 @@ fn parseInt(p: *Parser, prefix: NumberPrefix, buf: []const u8, suffix: NumberSuf
try p.errTok(.gnu_imaginary_constant, tok_i);
res.ty = res.ty.makeComplex();
res.val = .{};
- try res.un(p, .imaginary_literal);
+ try res.un(p, .imaginary_literal, tok_i);
}
return res;
}
@@ -8326,17 +8592,6 @@ fn bitInt(p: *Parser, base: u8, buf: []const u8, suffix: NumberSuffix, tok_i: To
// value of the constant is positive or was specified in hexadecimal or octal notation.
const sign_bits = @intFromBool(suffix.isSignedInteger());
const bits_needed = count + sign_bits;
- if (bits_needed > Compilation.bit_int_max_bits) {
- const specifier: Type.Builder.Specifier = switch (suffix) {
- .WB => .{ .bit_int = 0 },
- .UWB => .{ .ubit_int = 0 },
- .IWB => .{ .complex_bit_int = 0 },
- .IUWB => .{ .complex_ubit_int = 0 },
- else => unreachable,
- };
- try p.errStr(.bit_int_too_big, tok_i, specifier.str(p.comp.langopts).?);
- return error.ParsingFailed;
- }
break :blk @intCast(bits_needed);
};
@@ -8347,7 +8602,7 @@ fn bitInt(p: *Parser, base: u8, buf: []const u8, suffix: NumberSuffix, tok_i: To
.data = .{ .int = .{ .bits = bits_needed, .signedness = suffix.signedness() } },
},
};
- res.node = try p.addNode(.{ .tag = .int_literal, .ty = res.ty, .data = undefined });
+ res.node = try p.addNode(.{ .tag = .int_literal, .ty = res.ty, .data = undefined, .loc = @enumFromInt(tok_i) });
if (!p.in_macro) try p.value_map.put(res.node, res.val);
return res;
}
@@ -8420,6 +8675,10 @@ pub fn parseNumberToken(p: *Parser, tok_i: TokenIndex) !Result {
}
return error.ParsingFailed;
};
+ if (suffix.isFloat80() and p.comp.float80Type() == null) {
+ try p.errStr(.invalid_float_suffix, tok_i, suffix_str);
+ return error.ParsingFailed;
+ }
if (is_float) {
assert(prefix == .hex or prefix == .decimal);
@@ -8428,7 +8687,7 @@ pub fn parseNumberToken(p: *Parser, tok_i: TokenIndex) !Result {
return error.ParsingFailed;
}
const number = buf[0 .. buf.len - suffix_str.len];
- return p.parseFloat(number, suffix);
+ return p.parseFloat(number, suffix, tok_i);
} else {
return p.parseInt(prefix, int_part, suffix, tok_i);
}
@@ -8444,7 +8703,6 @@ fn ppNum(p: *Parser) Error!Result {
}
res.ty = if (res.ty.isUnsignedInt(p.comp)) p.comp.types.intmax.makeIntegerUnsigned() else p.comp.types.intmax;
} else if (res.val.opt_ref != .none) {
- // TODO add complex values
try p.value_map.put(res.node, res.val);
}
return res;
@@ -8465,6 +8723,7 @@ fn parseNoEval(p: *Parser, comptime func: fn (*Parser) Error!Result) Error!Resul
/// : typeName ':' assignExpr
/// | keyword_default ':' assignExpr
fn genericSelection(p: *Parser) Error!Result {
+ const kw_generic = p.tok_i;
p.tok_i += 1;
const l_paren = try p.expectToken(.l_paren);
const controlling_tok = p.tok_i;
@@ -8508,17 +8767,23 @@ fn genericSelection(p: *Parser) Error!Result {
try p.errStr(.generic_duplicate, start, try p.typeStr(ty));
try p.errStr(.generic_duplicate_here, chosen_tok, try p.typeStr(ty));
}
- for (p.list_buf.items[list_buf_top + 1 ..], p.decl_buf.items[decl_buf_top..]) |item, prev_tok| {
- const prev_ty = p.nodes.items(.ty)[@intFromEnum(item)];
- if (prev_ty.eql(ty, p.comp, true)) {
- try p.errStr(.generic_duplicate, start, try p.typeStr(ty));
- try p.errStr(.generic_duplicate_here, @intFromEnum(prev_tok), try p.typeStr(ty));
+ const list_buf = p.list_buf.items[list_buf_top + 1 ..];
+ const decl_buf = p.decl_buf.items[decl_buf_top..];
+ if (list_buf.len == decl_buf.len) {
+ // If these do not have the same length, there is already an error
+ for (list_buf, decl_buf) |item, prev_tok| {
+ const prev_ty = p.nodes.items(.ty)[@intFromEnum(item)];
+ if (prev_ty.eql(ty, p.comp, true)) {
+ try p.errStr(.generic_duplicate, start, try p.typeStr(ty));
+ try p.errStr(.generic_duplicate_here, @intFromEnum(prev_tok), try p.typeStr(ty));
+ }
}
}
try p.list_buf.append(try p.addNode(.{
.tag = .generic_association_expr,
.ty = ty,
.data = .{ .un = node.node },
+ .loc = @enumFromInt(start),
}));
try p.decl_buf.append(@enumFromInt(start));
} else if (p.eatToken(.keyword_default)) |tok| {
@@ -8542,10 +8807,12 @@ fn genericSelection(p: *Parser) Error!Result {
try p.expectClosing(l_paren, .r_paren);
if (chosen.node == .none) {
- if (default_tok != null) {
+ if (default_tok) |tok| {
try p.list_buf.insert(list_buf_top + 1, try p.addNode(.{
.tag = .generic_default_expr,
.data = .{ .un = default.node },
+ .ty = default.ty,
+ .loc = @enumFromInt(tok),
}));
chosen = default;
} else {
@@ -8556,11 +8823,15 @@ fn genericSelection(p: *Parser) Error!Result {
try p.list_buf.insert(list_buf_top + 1, try p.addNode(.{
.tag = .generic_association_expr,
.data = .{ .un = chosen.node },
+ .ty = chosen.ty,
+ .loc = @enumFromInt(chosen_tok),
}));
- if (default_tok != null) {
+ if (default_tok) |tok| {
try p.list_buf.append(try p.addNode(.{
.tag = .generic_default_expr,
- .data = .{ .un = chosen.node },
+ .data = .{ .un = default.node },
+ .ty = default.ty,
+ .loc = @enumFromInt(tok),
}));
}
}
@@ -8568,7 +8839,8 @@ fn genericSelection(p: *Parser) Error!Result {
var generic_node: Tree.Node = .{
.tag = .generic_expr_one,
.ty = chosen.ty,
- .data = .{ .bin = .{ .lhs = controlling.node, .rhs = chosen.node } },
+ .data = .{ .two = .{ controlling.node, chosen.node } },
+ .loc = @enumFromInt(kw_generic),
};
const associations = p.list_buf.items[list_buf_top..];
if (associations.len > 2) { // associations[0] == controlling.node
@@ -8578,3 +8850,42 @@ fn genericSelection(p: *Parser) Error!Result {
chosen.node = try p.addNode(generic_node);
return chosen;
}
+
+test "Node locations" {
+ var comp = Compilation.init(std.testing.allocator, std.fs.cwd());
+ defer comp.deinit();
+
+ const file = try comp.addSourceFromBuffer("file.c",
+ \\int foo = 5;
+ \\int bar = 10;
+ \\int main(void) {}
+ \\
+ );
+
+ const builtin_macros = try comp.generateBuiltinMacros(.no_system_defines);
+
+ var pp = Preprocessor.init(&comp);
+ defer pp.deinit();
+ try pp.addBuiltinMacros();
+
+ _ = try pp.preprocess(builtin_macros);
+
+ const eof = try pp.preprocess(file);
+ try pp.addToken(eof);
+
+ var tree = try Parser.parse(&pp);
+ defer tree.deinit();
+
+ try std.testing.expectEqual(0, comp.diagnostics.list.items.len);
+ for (tree.root_decls, 0..) |node, i| {
+ const tok_i = tree.nodeTok(node).?;
+ const slice = tree.tokSlice(tok_i);
+ const expected = switch (i) {
+ 0 => "foo",
+ 1 => "bar",
+ 2 => "main",
+ else => unreachable,
+ };
+ try std.testing.expectEqualStrings(expected, slice);
+ }
+}
diff --git a/lib/compiler/aro/aro/Preprocessor.zig b/lib/compiler/aro/aro/Preprocessor.zig
index aa0a64c3e721..5a03cc0dff01 100644
--- a/lib/compiler/aro/aro/Preprocessor.zig
+++ b/lib/compiler/aro/aro/Preprocessor.zig
@@ -95,7 +95,12 @@ counter: u32 = 0,
expansion_source_loc: Source.Location = undefined,
poisoned_identifiers: std.StringHashMap(void),
/// Map from Source.Id to macro name in the `#ifndef` condition which guards the source, if any
-include_guards: std.AutoHashMapUnmanaged(Source.Id, []const u8) = .{},
+include_guards: std.AutoHashMapUnmanaged(Source.Id, []const u8) = .empty,
+
+/// Store `keyword_define` and `keyword_undef` tokens.
+/// Used to implement preprocessor debug dump options
+/// Must be false unless in -E mode (parser does not handle those token types)
+store_macro_tokens: bool = false,
/// Memory is retained to avoid allocation on every single token.
top_expansion_buf: ExpandBuf,
@@ -266,7 +271,7 @@ fn clearBuffers(pp: *Preprocessor) void {
pub fn expansionSlice(pp: *Preprocessor, tok: Tree.TokenIndex) []Source.Location {
const S = struct {
fn orderTokenIndex(context: Tree.TokenIndex, item: Tree.TokenIndex) std.math.Order {
- return std.math.order(item, context);
+ return std.math.order(context, item);
}
};
@@ -622,9 +627,12 @@ fn preprocessExtra(pp: *Preprocessor, source: Source) MacroError!TokenWithExpans
}
if_level -= 1;
},
- .keyword_define => try pp.define(&tokenizer),
+ .keyword_define => try pp.define(&tokenizer, directive),
.keyword_undef => {
const macro_name = (try pp.expectMacroName(&tokenizer)) orelse continue;
+ if (pp.store_macro_tokens) {
+ try pp.addToken(tokFromRaw(directive));
+ }
_ = pp.defines.remove(macro_name);
try pp.expectNl(&tokenizer);
@@ -975,7 +983,7 @@ fn expr(pp: *Preprocessor, tokenizer: *Tokenizer) MacroError!bool {
.tok_i = @intCast(token_state.tokens_len),
.arena = pp.arena.allocator(),
.in_macro = true,
- .strings = std.ArrayList(u8).init(pp.comp.gpa),
+ .strings = std.ArrayListAligned(u8, 4).init(pp.comp.gpa),
.data = undefined,
.value_map = undefined,
@@ -1328,19 +1336,41 @@ fn stringify(pp: *Preprocessor, tokens: []const TokenWithExpansionLocs) !void {
try pp.char_buf.append(c);
}
}
- if (pp.char_buf.items[pp.char_buf.items.len - 1] == '\\') {
+ try pp.char_buf.ensureUnusedCapacity(2);
+ if (pp.char_buf.items[pp.char_buf.items.len - 1] != '\\') {
+ pp.char_buf.appendSliceAssumeCapacity("\"\n");
+ return;
+ }
+ pp.char_buf.appendAssumeCapacity('"');
+ var tokenizer: Tokenizer = .{
+ .buf = pp.char_buf.items,
+ .index = 0,
+ .source = .generated,
+ .langopts = pp.comp.langopts,
+ .line = 0,
+ };
+ const item = tokenizer.next();
+ if (item.id == .unterminated_string_literal) {
const tok = tokens[tokens.len - 1];
try pp.comp.addDiagnostic(.{
.tag = .invalid_pp_stringify_escape,
.loc = tok.loc,
}, tok.expansionSlice());
- pp.char_buf.items.len -= 1;
+ pp.char_buf.items.len -= 2; // erase unpaired backslash and appended end quote
+ pp.char_buf.appendAssumeCapacity('"');
}
- try pp.char_buf.appendSlice("\"\n");
+ pp.char_buf.appendAssumeCapacity('\n');
}
fn reconstructIncludeString(pp: *Preprocessor, param_toks: []const TokenWithExpansionLocs, embed_args: ?*[]const TokenWithExpansionLocs, first: TokenWithExpansionLocs) !?[]const u8 {
- assert(param_toks.len != 0);
+ if (param_toks.len == 0) {
+ try pp.comp.addDiagnostic(.{
+ .tag = .expected_filename,
+ .loc = first.loc,
+ }, first.expansionSlice());
+ return null;
+ }
+
const char_top = pp.char_buf.items.len;
defer pp.char_buf.items.len = char_top;
@@ -1539,11 +1569,13 @@ fn getPasteArgs(args: []const TokenWithExpansionLocs) []const TokenWithExpansion
fn expandFuncMacro(
pp: *Preprocessor,
- loc: Source.Location,
+ macro_tok: TokenWithExpansionLocs,
func_macro: *const Macro,
args: *const MacroArguments,
expanded_args: *const MacroArguments,
+ hideset_arg: Hideset.Index,
) MacroError!ExpandBuf {
+ var hideset = hideset_arg;
var buf = ExpandBuf.init(pp.gpa);
try buf.ensureTotalCapacity(func_macro.tokens.len);
errdefer buf.deinit();
@@ -1594,16 +1626,21 @@ fn expandFuncMacro(
},
else => &[1]TokenWithExpansionLocs{tokFromRaw(raw_next)},
};
-
try pp.pasteTokens(&buf, next);
if (next.len != 0) break;
},
.macro_param_no_expand => {
+ if (tok_i + 1 < func_macro.tokens.len and func_macro.tokens[tok_i + 1].id == .hash_hash) {
+ hideset = pp.hideset.get(tokFromRaw(func_macro.tokens[tok_i + 1]).loc);
+ }
const slice = getPasteArgs(args.items[raw.end]);
const raw_loc = Source.Location{ .id = raw.source, .byte_offset = raw.start, .line = raw.line };
try bufCopyTokens(&buf, slice, &.{raw_loc});
},
.macro_param => {
+ if (tok_i + 1 < func_macro.tokens.len and func_macro.tokens[tok_i + 1].id == .hash_hash) {
+ hideset = pp.hideset.get(tokFromRaw(func_macro.tokens[tok_i + 1]).loc);
+ }
const arg = expanded_args.items[raw.end];
const raw_loc = Source.Location{ .id = raw.source, .byte_offset = raw.start, .line = raw.line };
try bufCopyTokens(&buf, arg, &.{raw_loc});
@@ -1642,9 +1679,9 @@ fn expandFuncMacro(
const arg = expanded_args.items[0];
const result = if (arg.len == 0) blk: {
const extra = Diagnostics.Message.Extra{ .arguments = .{ .expected = 1, .actual = 0 } };
- try pp.comp.addDiagnostic(.{ .tag = .expected_arguments, .loc = loc, .extra = extra }, &.{});
+ try pp.comp.addDiagnostic(.{ .tag = .expected_arguments, .loc = macro_tok.loc, .extra = extra }, &.{});
break :blk false;
- } else try pp.handleBuiltinMacro(raw.id, arg, loc);
+ } else try pp.handleBuiltinMacro(raw.id, arg, macro_tok.loc);
const start = pp.comp.generated_buf.items.len;
const w = pp.comp.generated_buf.writer(pp.gpa);
try w.print("{}\n", .{@intFromBool(result)});
@@ -1655,7 +1692,7 @@ fn expandFuncMacro(
const not_found = "0\n";
const result = if (arg.len == 0) blk: {
const extra = Diagnostics.Message.Extra{ .arguments = .{ .expected = 1, .actual = 0 } };
- try pp.comp.addDiagnostic(.{ .tag = .expected_arguments, .loc = loc, .extra = extra }, &.{});
+ try pp.comp.addDiagnostic(.{ .tag = .expected_arguments, .loc = macro_tok.loc, .extra = extra }, &.{});
break :blk not_found;
} else res: {
var invalid: ?TokenWithExpansionLocs = null;
@@ -1687,7 +1724,7 @@ fn expandFuncMacro(
if (vendor_ident != null and attr_ident == null) {
invalid = vendor_ident;
} else if (attr_ident == null and invalid == null) {
- invalid = .{ .id = .eof, .loc = loc };
+ invalid = .{ .id = .eof, .loc = macro_tok.loc };
}
if (invalid) |some| {
try pp.comp.addDiagnostic(
@@ -1731,7 +1768,7 @@ fn expandFuncMacro(
const not_found = "0\n";
const result = if (arg.len == 0) blk: {
const extra = Diagnostics.Message.Extra{ .arguments = .{ .expected = 1, .actual = 0 } };
- try pp.comp.addDiagnostic(.{ .tag = .expected_arguments, .loc = loc, .extra = extra }, &.{});
+ try pp.comp.addDiagnostic(.{ .tag = .expected_arguments, .loc = macro_tok.loc, .extra = extra }, &.{});
break :blk not_found;
} else res: {
var embed_args: []const TokenWithExpansionLocs = &.{};
@@ -1877,11 +1914,11 @@ fn expandFuncMacro(
break;
},
};
- if (string == null and invalid == null) invalid = .{ .loc = loc, .id = .eof };
+ if (string == null and invalid == null) invalid = .{ .loc = macro_tok.loc, .id = .eof };
if (invalid) |some| try pp.comp.addDiagnostic(
.{ .tag = .pragma_operator_string_literal, .loc = some.loc },
some.expansionSlice(),
- ) else try pp.pragmaOperator(string.?, loc);
+ ) else try pp.pragmaOperator(string.?, macro_tok.loc);
},
.comma => {
if (tok_i + 2 < func_macro.tokens.len and func_macro.tokens[tok_i + 1].id == .hash_hash) {
@@ -1930,6 +1967,15 @@ fn expandFuncMacro(
}
removePlacemarkers(&buf);
+ const macro_expansion_locs = macro_tok.expansionSlice();
+ for (buf.items) |*tok| {
+ try tok.addExpansionLocation(pp.gpa, &.{macro_tok.loc});
+ try tok.addExpansionLocation(pp.gpa, macro_expansion_locs);
+ const tok_hidelist = pp.hideset.get(tok.loc);
+ const new_hidelist = try pp.hideset.@"union"(tok_hidelist, hideset);
+ try pp.hideset.put(tok.loc, new_hidelist);
+ }
+
return buf;
}
@@ -2207,8 +2253,10 @@ fn expandMacroExhaustive(
else => |e| return e,
};
assert(r_paren.id == .r_paren);
+ var free_arg_expansion_locs = false;
defer {
for (args.items) |item| {
+ if (free_arg_expansion_locs) for (item) |tok| TokenWithExpansionLocs.free(tok.expansion_locs, pp.gpa);
pp.gpa.free(item);
}
args.deinit();
@@ -2234,6 +2282,7 @@ fn expandMacroExhaustive(
.arguments = .{ .expected = @intCast(macro.params.len), .actual = args_count },
};
if (macro.var_args and args_count < macro.params.len) {
+ free_arg_expansion_locs = true;
try pp.comp.addDiagnostic(
.{ .tag = .expected_at_least_arguments, .loc = buf.items[idx].loc, .extra = extra },
buf.items[idx].expansionSlice(),
@@ -2243,6 +2292,7 @@ fn expandMacroExhaustive(
continue;
}
if (!macro.var_args and args_count != macro.params.len) {
+ free_arg_expansion_locs = true;
try pp.comp.addDiagnostic(
.{ .tag = .expected_arguments, .loc = buf.items[idx].loc, .extra = extra },
buf.items[idx].expansionSlice(),
@@ -2264,19 +2314,9 @@ fn expandMacroExhaustive(
expanded_args.appendAssumeCapacity(try expand_buf.toOwnedSlice());
}
- var res = try pp.expandFuncMacro(macro_tok.loc, macro, &args, &expanded_args);
+ var res = try pp.expandFuncMacro(macro_tok, macro, &args, &expanded_args, hs);
defer res.deinit();
const tokens_added = res.items.len;
-
- const macro_expansion_locs = macro_tok.expansionSlice();
- for (res.items) |*tok| {
- try tok.addExpansionLocation(pp.gpa, &.{macro_tok.loc});
- try tok.addExpansionLocation(pp.gpa, macro_expansion_locs);
- const tok_hidelist = pp.hideset.get(tok.loc);
- const new_hidelist = try pp.hideset.@"union"(tok_hidelist, hs);
- try pp.hideset.put(tok.loc, new_hidelist);
- }
-
const tokens_removed = macro_scan_idx - idx + 1;
for (buf.items[idx .. idx + tokens_removed]) |tok| TokenWithExpansionLocs.free(tok.expansion_locs, pp.gpa);
try buf.replaceRange(idx, tokens_removed, res.items);
@@ -2476,7 +2516,7 @@ fn makeGeneratedToken(pp: *Preprocessor, start: usize, id: Token.Id, source: Tok
}
/// Defines a new macro and warns if it is a duplicate
-fn defineMacro(pp: *Preprocessor, name_tok: RawToken, macro: Macro) Error!void {
+fn defineMacro(pp: *Preprocessor, define_tok: RawToken, name_tok: RawToken, macro: Macro) Error!void {
const name_str = pp.tokSlice(name_tok);
const gop = try pp.defines.getOrPut(pp.gpa, name_str);
if (gop.found_existing and !gop.value_ptr.eql(macro, pp)) {
@@ -2497,11 +2537,14 @@ fn defineMacro(pp: *Preprocessor, name_tok: RawToken, macro: Macro) Error!void {
if (pp.verbose) {
pp.verboseLog(name_tok, "macro {s} defined", .{name_str});
}
+ if (pp.store_macro_tokens) {
+ try pp.addToken(tokFromRaw(define_tok));
+ }
gop.value_ptr.* = macro;
}
/// Handle a #define directive.
-fn define(pp: *Preprocessor, tokenizer: *Tokenizer) Error!void {
+fn define(pp: *Preprocessor, tokenizer: *Tokenizer, define_tok: RawToken) Error!void {
// Get macro name and validate it.
const macro_name = tokenizer.nextNoWS();
if (macro_name.id == .keyword_defined) {
@@ -2524,7 +2567,7 @@ fn define(pp: *Preprocessor, tokenizer: *Tokenizer) Error!void {
// Check for function macros and empty defines.
var first = tokenizer.next();
switch (first.id) {
- .nl, .eof => return pp.defineMacro(macro_name, .{
+ .nl, .eof => return pp.defineMacro(define_tok, macro_name, .{
.params = &.{},
.tokens = &.{},
.var_args = false,
@@ -2532,7 +2575,7 @@ fn define(pp: *Preprocessor, tokenizer: *Tokenizer) Error!void {
.is_func = false,
}),
.whitespace => first = tokenizer.next(),
- .l_paren => return pp.defineFn(tokenizer, macro_name, first),
+ .l_paren => return pp.defineFn(tokenizer, define_tok, macro_name, first),
else => try pp.err(first, .whitespace_after_macro_name),
}
if (first.id == .hash_hash) {
@@ -2591,7 +2634,7 @@ fn define(pp: *Preprocessor, tokenizer: *Tokenizer) Error!void {
}
const list = try pp.arena.allocator().dupe(RawToken, pp.token_buf.items);
- try pp.defineMacro(macro_name, .{
+ try pp.defineMacro(define_tok, macro_name, .{
.loc = tokFromRaw(macro_name).loc,
.tokens = list,
.params = undefined,
@@ -2601,7 +2644,7 @@ fn define(pp: *Preprocessor, tokenizer: *Tokenizer) Error!void {
}
/// Handle a function like #define directive.
-fn defineFn(pp: *Preprocessor, tokenizer: *Tokenizer, macro_name: RawToken, l_paren: RawToken) Error!void {
+fn defineFn(pp: *Preprocessor, tokenizer: *Tokenizer, define_tok: RawToken, macro_name: RawToken, l_paren: RawToken) Error!void {
assert(macro_name.id.isMacroIdentifier());
var params = std.ArrayList([]const u8).init(pp.gpa);
defer params.deinit();
@@ -2778,7 +2821,7 @@ fn defineFn(pp: *Preprocessor, tokenizer: *Tokenizer, macro_name: RawToken, l_pa
const param_list = try pp.arena.allocator().dupe([]const u8, params.items);
const token_list = try pp.arena.allocator().dupe(RawToken, pp.token_buf.items);
- try pp.defineMacro(macro_name, .{
+ try pp.defineMacro(define_tok, macro_name, .{
.is_func = true,
.params = param_list,
.var_args = var_args or gnu_var_args.len != 0,
@@ -3241,8 +3284,78 @@ fn printLinemarker(
// After how many empty lines are needed to replace them with linemarkers.
const collapse_newlines = 8;
+pub const DumpMode = enum {
+ /// Standard preprocessor output; no macros
+ result_only,
+ /// Output only #define directives for all the macros defined during the execution of the preprocessor
+ /// Only macros which are still defined at the end of preprocessing are printed.
+ /// Only the most recent definition is printed
+ /// Defines are printed in arbitrary order
+ macros_only,
+ /// Standard preprocessor output; but additionally output #define's and #undef's for macros as they are encountered
+ macros_and_result,
+ /// Same as macros_and_result, except only the macro name is printed for #define's
+ macro_names_and_result,
+};
+
+/// Pretty-print the macro define or undef at location `loc`.
+/// We re-tokenize the directive because we are printing a macro that may have the same name as one in
+/// `pp.defines` but a different definition (due to being #undef'ed and then redefined)
+fn prettyPrintMacro(pp: *Preprocessor, w: anytype, loc: Source.Location, parts: enum { name_only, name_and_body }) !void {
+ const source = pp.comp.getSource(loc.id);
+ var tokenizer: Tokenizer = .{
+ .buf = source.buf,
+ .langopts = pp.comp.langopts,
+ .source = source.id,
+ .index = loc.byte_offset,
+ };
+ var prev_ws = false; // avoid printing multiple whitespace if /* */ comments are within the macro def
+ var saw_name = false; // do not print comments before the name token is seen.
+ while (true) {
+ const tok = tokenizer.next();
+ switch (tok.id) {
+ .comment => {
+ if (saw_name) {
+ prev_ws = false;
+ try w.print("{s}", .{pp.tokSlice(tok)});
+ }
+ },
+ .nl, .eof => break,
+ .whitespace => {
+ if (!prev_ws) {
+ try w.writeByte(' ');
+ prev_ws = true;
+ }
+ },
+ else => {
+ prev_ws = false;
+ try w.print("{s}", .{pp.tokSlice(tok)});
+ },
+ }
+ if (tok.id == .identifier or tok.id == .extended_identifier) {
+ if (parts == .name_only) break;
+ saw_name = true;
+ }
+ }
+}
+
+fn prettyPrintMacrosOnly(pp: *Preprocessor, w: anytype) !void {
+ var it = pp.defines.valueIterator();
+ while (it.next()) |macro| {
+ if (macro.is_builtin) continue;
+
+ try w.writeAll("#define ");
+ try pp.prettyPrintMacro(w, macro.loc, .name_and_body);
+ try w.writeByte('\n');
+ }
+}
+
/// Pretty print tokens and try to preserve whitespace.
-pub fn prettyPrintTokens(pp: *Preprocessor, w: anytype) !void {
+pub fn prettyPrintTokens(pp: *Preprocessor, w: anytype, macro_dump_mode: DumpMode) !void {
+ if (macro_dump_mode == .macros_only) {
+ return pp.prettyPrintMacrosOnly(w);
+ }
+
const tok_ids = pp.tokens.items(.id);
var i: u32 = 0;
@@ -3334,6 +3447,17 @@ pub fn prettyPrintTokens(pp: *Preprocessor, w: anytype) !void {
try pp.printLinemarker(w, line_col.line_no, source, .@"resume");
last_nl = true;
},
+ .keyword_define, .keyword_undef => {
+ switch (macro_dump_mode) {
+ .macros_and_result, .macro_names_and_result => {
+ try w.writeByte('#');
+ try pp.prettyPrintMacro(w, cur.loc, if (macro_dump_mode == .macros_and_result) .name_and_body else .name_only);
+ last_nl = false;
+ },
+ .result_only => unreachable, // `pp.store_macro_tokens` should be false for standard preprocessor output
+ .macros_only => unreachable, // handled by prettyPrintMacrosOnly
+ }
+ },
else => {
const slice = pp.expandedSlice(cur);
try w.writeAll(slice);
@@ -3350,7 +3474,7 @@ test "Preserve pragma tokens sometimes" {
var buf = std.ArrayList(u8).init(allocator);
defer buf.deinit();
- var comp = Compilation.init(allocator);
+ var comp = Compilation.init(allocator, std.fs.cwd());
defer comp.deinit();
try comp.addDefaultPragmaHandlers();
@@ -3364,7 +3488,7 @@ test "Preserve pragma tokens sometimes" {
const test_runner_macros = try comp.addSourceFromBuffer("", source_text);
const eof = try pp.preprocess(test_runner_macros);
try pp.addToken(eof);
- try pp.prettyPrintTokens(buf.writer());
+ try pp.prettyPrintTokens(buf.writer(), .result_only);
return allocator.dupe(u8, buf.items);
}
@@ -3410,7 +3534,7 @@ test "destringify" {
try std.testing.expectEqualStrings(destringified, pp.char_buf.items);
}
};
- var comp = Compilation.init(allocator);
+ var comp = Compilation.init(allocator, std.fs.cwd());
defer comp.deinit();
var pp = Preprocessor.init(&comp);
defer pp.deinit();
@@ -3468,7 +3592,7 @@ test "Include guards" {
}
fn testIncludeGuard(allocator: std.mem.Allocator, comptime template: []const u8, tok_id: RawToken.Id, expected_guards: u32) !void {
- var comp = Compilation.init(allocator);
+ var comp = Compilation.init(allocator, std.fs.cwd());
defer comp.deinit();
var pp = Preprocessor.init(&comp);
defer pp.deinit();
diff --git a/lib/compiler/aro/aro/Source.zig b/lib/compiler/aro/aro/Source.zig
index 06e58ecb1615..20788af21c3e 100644
--- a/lib/compiler/aro/aro/Source.zig
+++ b/lib/compiler/aro/aro/Source.zig
@@ -75,7 +75,17 @@ pub fn lineCol(source: Source, loc: Location) LineCol {
i += 1;
continue;
};
- const cp = std.unicode.utf8Decode(source.buf[i..][0..len]) catch {
+ const slice = source.buf[i..];
+ if (len > slice.len) {
+ break;
+ }
+ const cp = switch (len) {
+ 1 => slice[0],
+ 2 => std.unicode.utf8Decode2(slice[0..2].*),
+ 3 => std.unicode.utf8Decode3(slice[0..3].*),
+ 4 => std.unicode.utf8Decode4(slice[0..4].*),
+ else => unreachable,
+ } catch {
i += 1;
continue;
};
diff --git a/lib/compiler/aro/aro/SymbolStack.zig b/lib/compiler/aro/aro/SymbolStack.zig
index dba722344701..4c01e3d3567f 100644
--- a/lib/compiler/aro/aro/SymbolStack.zig
+++ b/lib/compiler/aro/aro/SymbolStack.zig
@@ -33,14 +33,14 @@ pub const Kind = enum {
constexpr,
};
-scopes: std.ArrayListUnmanaged(Scope) = .{},
+scopes: std.ArrayListUnmanaged(Scope) = .empty,
/// allocations from nested scopes are retained after popping; `active_len` is the number
/// of currently-active items in `scopes`.
active_len: usize = 0,
const Scope = struct {
- vars: std.AutoHashMapUnmanaged(StringId, Symbol) = .{},
- tags: std.AutoHashMapUnmanaged(StringId, Symbol) = .{},
+ vars: std.AutoHashMapUnmanaged(StringId, Symbol) = .empty,
+ tags: std.AutoHashMapUnmanaged(StringId, Symbol) = .empty,
fn deinit(self: *Scope, allocator: Allocator) void {
self.vars.deinit(allocator);
@@ -178,9 +178,11 @@ pub fn defineTypedef(
if (s.get(name, .vars)) |prev| {
switch (prev.kind) {
.typedef => {
- if (!ty.eql(prev.ty, p.comp, true)) {
- try p.errStr(.redefinition_of_typedef, tok, try p.typePairStrExtra(ty, " vs ", prev.ty));
- if (prev.tok != 0) try p.errTok(.previous_definition, prev.tok);
+ if (!prev.ty.is(.invalid)) {
+ if (!ty.eql(prev.ty, p.comp, true)) {
+ try p.errStr(.redefinition_of_typedef, tok, try p.typePairStrExtra(ty, " vs ", prev.ty));
+ if (prev.tok != 0) try p.errTok(.previous_definition, prev.tok);
+ }
}
},
.enumeration, .decl, .def, .constexpr => {
@@ -194,7 +196,12 @@ pub fn defineTypedef(
.kind = .typedef,
.name = name,
.tok = tok,
- .ty = ty,
+ .ty = .{
+ .name = name,
+ .specifier = ty.specifier,
+ .qual = ty.qual,
+ .data = ty.data,
+ },
.node = node,
.val = .{},
});
diff --git a/lib/compiler/aro/aro/Tokenizer.zig b/lib/compiler/aro/aro/Tokenizer.zig
index c5a84b8cc0b5..f703940fd8ea 100644
--- a/lib/compiler/aro/aro/Tokenizer.zig
+++ b/lib/compiler/aro/aro/Tokenizer.zig
@@ -178,6 +178,8 @@ pub const Token = struct {
keyword_return,
keyword_short,
keyword_signed,
+ keyword_signed1,
+ keyword_signed2,
keyword_sizeof,
keyword_static,
keyword_struct,
@@ -258,7 +260,6 @@ pub const Token = struct {
keyword_asm,
keyword_asm1,
keyword_asm2,
- keyword_float80,
/// _Float128
keyword_float128_1,
/// __float128
@@ -369,6 +370,8 @@ pub const Token = struct {
.keyword_return,
.keyword_short,
.keyword_signed,
+ .keyword_signed1,
+ .keyword_signed2,
.keyword_sizeof,
.keyword_static,
.keyword_struct,
@@ -417,7 +420,6 @@ pub const Token = struct {
.keyword_asm,
.keyword_asm1,
.keyword_asm2,
- .keyword_float80,
.keyword_float128_1,
.keyword_float128_2,
.keyword_int128,
@@ -627,6 +629,8 @@ pub const Token = struct {
.keyword_return => "return",
.keyword_short => "short",
.keyword_signed => "signed",
+ .keyword_signed1 => "__signed",
+ .keyword_signed2 => "__signed__",
.keyword_sizeof => "sizeof",
.keyword_static => "static",
.keyword_struct => "struct",
@@ -702,7 +706,6 @@ pub const Token = struct {
.keyword_asm => "asm",
.keyword_asm1 => "__asm",
.keyword_asm2 => "__asm__",
- .keyword_float80 => "__float80",
.keyword_float128_1 => "_Float128",
.keyword_float128_2 => "__float128",
.keyword_int128 => "__int128",
@@ -732,7 +735,8 @@ pub const Token = struct {
pub fn symbol(id: Id) []const u8 {
return switch (id) {
- .macro_string, .invalid => unreachable,
+ .macro_string => unreachable,
+ .invalid => "invalid bytes",
.identifier,
.extended_identifier,
.macro_func,
@@ -873,10 +877,7 @@ pub const Token = struct {
}
const all_kws = std.StaticStringMap(Id).initComptime(.{
- .{ "auto", auto: {
- @setEvalBranchQuota(3000);
- break :auto .keyword_auto;
- } },
+ .{ "auto", .keyword_auto },
.{ "break", .keyword_break },
.{ "case", .keyword_case },
.{ "char", .keyword_char },
@@ -898,6 +899,8 @@ pub const Token = struct {
.{ "return", .keyword_return },
.{ "short", .keyword_short },
.{ "signed", .keyword_signed },
+ .{ "__signed", .keyword_signed1 },
+ .{ "__signed__", .keyword_signed2 },
.{ "sizeof", .keyword_sizeof },
.{ "static", .keyword_static },
.{ "struct", .keyword_struct },
@@ -982,7 +985,6 @@ pub const Token = struct {
.{ "asm", .keyword_asm },
.{ "__asm", .keyword_asm1 },
.{ "__asm__", .keyword_asm2 },
- .{ "__float80", .keyword_float80 },
.{ "_Float128", .keyword_float128_1 },
.{ "__float128", .keyword_float128_2 },
.{ "__int128", .keyword_int128 },
@@ -1300,11 +1302,17 @@ pub fn next(self: *Tokenizer) Token {
else => {},
},
.char_escape_sequence => switch (c) {
- '\r', '\n' => unreachable, // removed by line splicing
+ '\r', '\n' => {
+ id = .unterminated_char_literal;
+ break;
+ },
else => state = .char_literal,
},
.string_escape_sequence => switch (c) {
- '\r', '\n' => unreachable, // removed by line splicing
+ '\r', '\n' => {
+ id = .unterminated_string_literal;
+ break;
+ },
else => state = .string_literal,
},
.identifier, .extended_identifier => switch (c) {
@@ -1792,7 +1800,7 @@ pub fn nextNoWSComments(self: *Tokenizer) Token {
/// Try to tokenize a '::' even if not supported by the current language standard.
pub fn colonColon(self: *Tokenizer) Token {
var tok = self.nextNoWS();
- if (tok.id == .colon and self.buf[self.index] == ':') {
+ if (tok.id == .colon and self.index < self.buf.len and self.buf[self.index] == ':') {
self.index += 1;
tok.id = .colon_colon;
}
@@ -2142,8 +2150,30 @@ test "C23 keywords" {
}, .c23);
}
+test "Tokenizer fuzz test" {
+ var comp = Compilation.init(std.testing.allocator, std.fs.cwd());
+ defer comp.deinit();
+
+ const input_bytes = std.testing.fuzzInput(.{});
+ if (input_bytes.len == 0) return;
+
+ const source = try comp.addSourceFromBuffer("fuzz.c", input_bytes);
+
+ var tokenizer: Tokenizer = .{
+ .buf = source.buf,
+ .source = source.id,
+ .langopts = comp.langopts,
+ };
+ while (true) {
+ const prev_index = tokenizer.index;
+ const tok = tokenizer.next();
+ if (tok.id == .eof) break;
+ try std.testing.expect(prev_index < tokenizer.index); // ensure that the tokenizer always makes progress
+ }
+}
+
fn expectTokensExtra(contents: []const u8, expected_tokens: []const Token.Id, standard: ?LangOpts.Standard) !void {
- var comp = Compilation.init(std.testing.allocator);
+ var comp = Compilation.init(std.testing.allocator, std.fs.cwd());
defer comp.deinit();
if (standard) |provided| {
comp.langopts.standard = provided;
diff --git a/lib/compiler/aro/aro/Tree.zig b/lib/compiler/aro/aro/Tree.zig
index e353beaebc62..a1b15bd66916 100644
--- a/lib/compiler/aro/aro/Tree.zig
+++ b/lib/compiler/aro/aro/Tree.zig
@@ -137,15 +137,22 @@ pub const Node = struct {
tag: Tag,
ty: Type = .{ .specifier = .void },
data: Data,
+ loc: Loc = .none,
pub const Range = struct { start: u32, end: u32 };
+ pub const Loc = enum(u32) {
+ none = std.math.maxInt(u32),
+ _,
+ };
+
pub const Data = union {
decl: struct {
name: TokenIndex,
node: NodeIndex = .none,
},
decl_ref: TokenIndex,
+ two: [2]NodeIndex,
range: Range,
if3: struct {
cond: NodeIndex,
@@ -277,7 +284,8 @@ pub const Tag = enum(u8) {
// ====== Decl ======
- // _Static_assert
+ /// _Static_assert
+ /// loc is token index of _Static_assert
static_assert,
// function prototype
@@ -303,17 +311,18 @@ pub const Tag = enum(u8) {
threadlocal_static_var,
/// __asm__("...") at file scope
+ /// loc is token index of __asm__ keyword
file_scope_asm,
// typedef declaration
typedef,
// container declarations
- /// { lhs; rhs; }
+ /// { two[0]; two[1]; }
struct_decl_two,
- /// { lhs; rhs; }
+ /// { two[0]; two[1]; }
union_decl_two,
- /// { lhs, rhs, }
+ /// { two[0], two[1], }
enum_decl_two,
/// { range }
struct_decl,
@@ -339,7 +348,7 @@ pub const Tag = enum(u8) {
// ====== Stmt ======
labeled_stmt,
- /// { first; second; } first and second may be null
+ /// { two[0]; two[1]; } first and second may be null
compound_stmt_two,
/// { data }
compound_stmt,
@@ -476,7 +485,7 @@ pub const Tag = enum(u8) {
real_expr,
/// lhs[rhs] lhs is pointer/array type, rhs is integer type
array_access_expr,
- /// first(second) second may be 0
+ /// two[0](two[1]) two[1] may be 0
call_expr_one,
/// data[0](data[1..])
call_expr,
@@ -515,7 +524,7 @@ pub const Tag = enum(u8) {
sizeof_expr,
/// _Alignof(un?)
alignof_expr,
- /// _Generic(controlling lhs, chosen rhs)
+ /// _Generic(controlling two[0], chosen two[1])
generic_expr_one,
/// _Generic(controlling range[0], chosen range[1], rest range[2..])
generic_expr,
@@ -534,28 +543,34 @@ pub const Tag = enum(u8) {
// ====== Initializer expressions ======
- /// { lhs, rhs }
+ /// { two[0], two[1] }
array_init_expr_two,
/// { range }
array_init_expr,
- /// { lhs, rhs }
+ /// { two[0], two[1] }
struct_init_expr_two,
/// { range }
struct_init_expr,
/// { union_init }
union_init_expr,
+
/// (ty){ un }
+ /// loc is token index of l_paren
compound_literal_expr,
/// (static ty){ un }
+ /// loc is token index of l_paren
static_compound_literal_expr,
/// (thread_local ty){ un }
+ /// loc is token index of l_paren
thread_local_compound_literal_expr,
/// (static thread_local ty){ un }
+ /// loc is token index of l_paren
static_thread_local_compound_literal_expr,
/// Inserted at the end of a function body if no return stmt is found.
/// ty is the functions return type
/// data is return_zero which is true if the function is called "main" and ty is compatible with int
+ /// loc is token index of closing r_brace of function
implicit_return,
/// Inserted in array_init_expr to represent unspecified elements.
@@ -608,6 +623,57 @@ pub fn bitfieldWidth(tree: *const Tree, node: NodeIndex, inspect_lval: bool) ?u3
}
}
+const CallableResultUsage = struct {
+ /// name token of the thing being called, for diagnostics
+ tok: TokenIndex,
+ /// true if `nodiscard` attribute present
+ nodiscard: bool,
+ /// true if `warn_unused_result` attribute present
+ warn_unused_result: bool,
+};
+
+pub fn callableResultUsage(tree: *const Tree, node: NodeIndex) ?CallableResultUsage {
+ const data = tree.nodes.items(.data);
+
+ var cur_node = node;
+ while (true) switch (tree.nodes.items(.tag)[@intFromEnum(cur_node)]) {
+ .decl_ref_expr => {
+ const tok = data[@intFromEnum(cur_node)].decl_ref;
+ const fn_ty = tree.nodes.items(.ty)[@intFromEnum(node)].elemType();
+ return .{
+ .tok = tok,
+ .nodiscard = fn_ty.hasAttribute(.nodiscard),
+ .warn_unused_result = fn_ty.hasAttribute(.warn_unused_result),
+ };
+ },
+ .paren_expr => cur_node = data[@intFromEnum(cur_node)].un,
+ .comma_expr => cur_node = data[@intFromEnum(cur_node)].bin.rhs,
+
+ .explicit_cast, .implicit_cast => cur_node = data[@intFromEnum(cur_node)].cast.operand,
+ .addr_of_expr, .deref_expr => cur_node = data[@intFromEnum(cur_node)].un,
+ .call_expr_one => cur_node = data[@intFromEnum(cur_node)].two[0],
+ .call_expr => cur_node = tree.data[data[@intFromEnum(cur_node)].range.start],
+ .member_access_expr, .member_access_ptr_expr => {
+ const member = data[@intFromEnum(cur_node)].member;
+ var ty = tree.nodes.items(.ty)[@intFromEnum(member.lhs)];
+ if (ty.isPtr()) ty = ty.elemType();
+ const record = ty.getRecord().?;
+ const field = record.fields[member.index];
+ const attributes = if (record.field_attributes) |attrs| attrs[member.index] else &.{};
+ return .{
+ .tok = field.name_tok,
+ .nodiscard = for (attributes) |attr| {
+ if (attr.tag == .nodiscard) break true;
+ } else false,
+ .warn_unused_result = for (attributes) |attr| {
+ if (attr.tag == .warn_unused_result) break true;
+ } else false,
+ };
+ },
+ else => return null,
+ };
+}
+
pub fn isLval(tree: *const Tree, node: NodeIndex) bool {
var is_const: bool = undefined;
return tree.isLvalExtra(node, &is_const);
@@ -672,17 +738,66 @@ pub fn isLvalExtra(tree: *const Tree, node: NodeIndex, is_const: *bool) bool {
}
}
+/// This should only be used for node tags that represent AST nodes which have an arbitrary number of children
+/// It particular it should *not* be used for nodes with .un or .bin data types
+///
+/// For call expressions, child_nodes[0] is the function pointer being called and child_nodes[1..]
+/// are the arguments
+///
+/// For generic selection expressions, child_nodes[0] is the controlling expression,
+/// child_nodes[1] is the chosen expression (it is a syntax error for there to be no chosen expression),
+/// and child_nodes[2..] are the remaining expressions.
+pub fn childNodes(tree: *const Tree, node: NodeIndex) []const NodeIndex {
+ const tags = tree.nodes.items(.tag);
+ const data = tree.nodes.items(.data);
+ switch (tags[@intFromEnum(node)]) {
+ .compound_stmt_two,
+ .array_init_expr_two,
+ .struct_init_expr_two,
+ .enum_decl_two,
+ .struct_decl_two,
+ .union_decl_two,
+ .call_expr_one,
+ .generic_expr_one,
+ => {
+ const index: u32 = @intFromEnum(node);
+ const end = std.mem.indexOfScalar(NodeIndex, &data[index].two, .none) orelse 2;
+ return data[index].two[0..end];
+ },
+ .compound_stmt,
+ .array_init_expr,
+ .struct_init_expr,
+ .enum_decl,
+ .struct_decl,
+ .union_decl,
+ .call_expr,
+ .generic_expr,
+ => {
+ const range = data[@intFromEnum(node)].range;
+ return tree.data[range.start..range.end];
+ },
+ else => unreachable,
+ }
+}
+
pub fn tokSlice(tree: *const Tree, tok_i: TokenIndex) []const u8 {
if (tree.tokens.items(.id)[tok_i].lexeme()) |some| return some;
const loc = tree.tokens.items(.loc)[tok_i];
- var tmp_tokenizer = Tokenizer{
- .buf = tree.comp.getSource(loc.id).buf,
- .langopts = tree.comp.langopts,
- .index = loc.byte_offset,
- .source = .generated,
+ return tree.comp.locSlice(loc);
+}
+
+pub fn nodeTok(tree: *const Tree, node: NodeIndex) ?TokenIndex {
+ std.debug.assert(node != .none);
+ const loc = tree.nodes.items(.loc)[@intFromEnum(node)];
+ return switch (loc) {
+ .none => null,
+ else => |tok_i| @intFromEnum(tok_i),
};
- const tok = tmp_tokenizer.next();
- return tmp_tokenizer.buf[tok.start..tok.end];
+}
+
+pub fn nodeLoc(tree: *const Tree, node: NodeIndex) ?Source.Location {
+ const tok_i = tree.nodeTok(node) orelse return null;
+ return tree.tokens.items(.loc)[@intFromEnum(tok_i)];
}
pub fn dump(tree: *const Tree, config: std.io.tty.Config, writer: anytype) !void {
@@ -766,6 +881,10 @@ fn dumpNode(
}
try config.setColor(w, TYPE);
try w.writeByte('\'');
+ const name = ty.getName();
+ if (name != .empty) {
+ try w.print("{s}': '", .{mapper.lookup(name)});
+ }
try ty.dump(mapper, tree.comp.langopts, w);
try w.writeByte('\'');
@@ -794,7 +913,9 @@ fn dumpNode(
if (ty.specifier == .attributed) {
try config.setColor(w, ATTRIBUTE);
- for (ty.data.attributed.attributes) |attr| {
+ var it = Attribute.Iterator.initType(ty);
+ while (it.next()) |item| {
+ const attr, _ = item;
try w.writeByteNTimes(' ', level + half);
try w.print("attr: {s}", .{@tagName(attr.tag)});
try tree.dumpAttribute(attr, w);
@@ -900,9 +1021,16 @@ fn dumpNode(
.enum_decl,
.struct_decl,
.union_decl,
+ .compound_stmt_two,
+ .array_init_expr_two,
+ .struct_init_expr_two,
+ .enum_decl_two,
+ .struct_decl_two,
+ .union_decl_two,
=> {
+ const child_nodes = tree.childNodes(node);
const maybe_field_attributes = if (ty.getRecord()) |record| record.field_attributes else null;
- for (tree.data[data.range.start..data.range.end], 0..) |stmt, i| {
+ for (child_nodes, 0..) |stmt, i| {
if (i != 0) try w.writeByte('\n');
try tree.dumpNode(stmt, level + delta, mapper, config, w);
if (maybe_field_attributes) |field_attributes| {
@@ -914,33 +1042,6 @@ fn dumpNode(
}
}
},
- .compound_stmt_two,
- .array_init_expr_two,
- .struct_init_expr_two,
- .enum_decl_two,
- .struct_decl_two,
- .union_decl_two,
- => {
- var attr_array = [2][]const Attribute{ &.{}, &.{} };
- const empty: [][]const Attribute = &attr_array;
- const field_attributes = if (ty.getRecord()) |record| (record.field_attributes orelse empty.ptr) else empty.ptr;
- if (data.bin.lhs != .none) {
- try tree.dumpNode(data.bin.lhs, level + delta, mapper, config, w);
- if (field_attributes[0].len > 0) {
- try config.setColor(w, ATTRIBUTE);
- try tree.dumpFieldAttributes(field_attributes[0], level + delta + half, w);
- try config.setColor(w, .reset);
- }
- }
- if (data.bin.rhs != .none) {
- try tree.dumpNode(data.bin.rhs, level + delta, mapper, config, w);
- if (field_attributes[1].len > 0) {
- try config.setColor(w, ATTRIBUTE);
- try tree.dumpFieldAttributes(field_attributes[1], level + delta + half, w);
- try config.setColor(w, .reset);
- }
- }
- },
.union_init_expr => {
try w.writeByteNTimes(' ', level + half);
try w.writeAll("field index: ");
@@ -1130,23 +1231,21 @@ fn dumpNode(
try tree.dumpNode(data.un, level + delta, mapper, config, w);
}
},
- .call_expr => {
- try w.writeByteNTimes(' ', level + half);
- try w.writeAll("lhs:\n");
- try tree.dumpNode(tree.data[data.range.start], level + delta, mapper, config, w);
+ .call_expr, .call_expr_one => {
+ const child_nodes = tree.childNodes(node);
+ const fn_ptr = child_nodes[0];
+ const args = child_nodes[1..];
- try w.writeByteNTimes(' ', level + half);
- try w.writeAll("args:\n");
- for (tree.data[data.range.start + 1 .. data.range.end]) |arg| try tree.dumpNode(arg, level + delta, mapper, config, w);
- },
- .call_expr_one => {
try w.writeByteNTimes(' ', level + half);
try w.writeAll("lhs:\n");
- try tree.dumpNode(data.bin.lhs, level + delta, mapper, config, w);
- if (data.bin.rhs != .none) {
+ try tree.dumpNode(fn_ptr, level + delta, mapper, config, w);
+
+ if (args.len > 0) {
try w.writeByteNTimes(' ', level + half);
- try w.writeAll("arg:\n");
- try tree.dumpNode(data.bin.rhs, level + delta, mapper, config, w);
+ try w.writeAll("args:\n");
+ for (args) |arg| {
+ try tree.dumpNode(arg, level + delta, mapper, config, w);
+ }
}
},
.builtin_call_expr => {
@@ -1295,28 +1394,25 @@ fn dumpNode(
try tree.dumpNode(data.un, level + delta, mapper, config, w);
}
},
- .generic_expr_one => {
- try w.writeByteNTimes(' ', level + 1);
- try w.writeAll("controlling:\n");
- try tree.dumpNode(data.bin.lhs, level + delta, mapper, config, w);
- try w.writeByteNTimes(' ', level + 1);
- if (data.bin.rhs != .none) {
- try w.writeAll("chosen:\n");
- try tree.dumpNode(data.bin.rhs, level + delta, mapper, config, w);
- }
- },
- .generic_expr => {
- const nodes = tree.data[data.range.start..data.range.end];
+ .generic_expr, .generic_expr_one => {
+ const child_nodes = tree.childNodes(node);
+ const controlling = child_nodes[0];
+ const chosen = child_nodes[1];
+ const rest = child_nodes[2..];
+
try w.writeByteNTimes(' ', level + 1);
try w.writeAll("controlling:\n");
- try tree.dumpNode(nodes[0], level + delta, mapper, config, w);
+ try tree.dumpNode(controlling, level + delta, mapper, config, w);
try w.writeByteNTimes(' ', level + 1);
try w.writeAll("chosen:\n");
- try tree.dumpNode(nodes[1], level + delta, mapper, config, w);
- try w.writeByteNTimes(' ', level + 1);
- try w.writeAll("rest:\n");
- for (nodes[2..]) |expr| {
- try tree.dumpNode(expr, level + delta, mapper, config, w);
+ try tree.dumpNode(chosen, level + delta, mapper, config, w);
+
+ if (rest.len > 0) {
+ try w.writeByteNTimes(' ', level + 1);
+ try w.writeAll("rest:\n");
+ for (rest) |expr| {
+ try tree.dumpNode(expr, level + delta, mapper, config, w);
+ }
}
},
.generic_association_expr, .generic_default_expr, .stmt_expr, .imaginary_literal => {
diff --git a/lib/compiler/aro/aro/Tree/number_affixes.zig b/lib/compiler/aro/aro/Tree/number_affixes.zig
index 7f01e9f2e7ef..38ef6b8a5667 100644
--- a/lib/compiler/aro/aro/Tree/number_affixes.zig
+++ b/lib/compiler/aro/aro/Tree/number_affixes.zig
@@ -74,8 +74,8 @@ pub const Suffix = enum {
// float and imaginary float
F, IF,
- // _Float16
- F16,
+ // _Float16 and imaginary _Float16
+ F16, IF16,
// __float80
W,
@@ -129,6 +129,7 @@ pub const Suffix = enum {
.{ .I, &.{"I"} },
.{ .IL, &.{ "I", "L" } },
+ .{ .IF16, &.{ "I", "F16" } },
.{ .IF, &.{ "I", "F" } },
.{ .IW, &.{ "I", "W" } },
.{ .IF128, &.{ "I", "F128" } },
@@ -161,7 +162,7 @@ pub const Suffix = enum {
pub fn isImaginary(suffix: Suffix) bool {
return switch (suffix) {
- .I, .IL, .IF, .IU, .IUL, .ILL, .IULL, .IWB, .IUWB, .IF128, .IQ, .IW => true,
+ .I, .IL, .IF, .IU, .IUL, .ILL, .IULL, .IWB, .IUWB, .IF128, .IQ, .IW, .IF16 => true,
.None, .L, .F16, .F, .U, .UL, .LL, .ULL, .WB, .UWB, .F128, .Q, .W => false,
};
}
@@ -170,7 +171,7 @@ pub const Suffix = enum {
return switch (suffix) {
.None, .L, .LL, .I, .IL, .ILL, .WB, .IWB => true,
.U, .UL, .ULL, .IU, .IUL, .IULL, .UWB, .IUWB => false,
- .F, .IF, .F16, .F128, .IF128, .Q, .IQ, .W, .IW => unreachable,
+ .F, .IF, .F16, .F128, .IF128, .Q, .IQ, .W, .IW, .IF16 => unreachable,
};
}
@@ -184,4 +185,8 @@ pub const Suffix = enum {
else => false,
};
}
+
+ pub fn isFloat80(suffix: Suffix) bool {
+ return suffix == .W or suffix == .IW;
+ }
};
diff --git a/lib/compiler/aro/aro/Type.zig b/lib/compiler/aro/aro/Type.zig
index 13fa8ce2e204..8ab2d3164a77 100644
--- a/lib/compiler/aro/aro/Type.zig
+++ b/lib/compiler/aro/aro/Type.zig
@@ -146,17 +146,14 @@ pub const Attributed = struct {
attributes: []Attribute,
base: Type,
- pub fn create(allocator: std.mem.Allocator, base: Type, existing_attributes: []const Attribute, attributes: []const Attribute) !*Attributed {
+ pub fn create(allocator: std.mem.Allocator, base_ty: Type, attributes: []const Attribute) !*Attributed {
const attributed_type = try allocator.create(Attributed);
errdefer allocator.destroy(attributed_type);
-
- const all_attrs = try allocator.alloc(Attribute, existing_attributes.len + attributes.len);
- @memcpy(all_attrs[0..existing_attributes.len], existing_attributes);
- @memcpy(all_attrs[existing_attributes.len..], attributes);
+ const duped = try allocator.dupe(Attribute, attributes);
attributed_type.* = .{
- .attributes = all_attrs,
- .base = base,
+ .attributes = duped,
+ .base = base_ty,
};
return attributed_type;
}
@@ -190,13 +187,10 @@ pub const Enum = struct {
}
};
-// might not need all 4 of these when finished,
-// but currently it helps having all 4 when diff-ing
-// the rust code.
pub const TypeLayout = struct {
/// The size of the type in bits.
///
- /// This is the value returned by `sizeof` and C and `std::mem::size_of` in Rust
+ /// This is the value returned by `sizeof` in C
/// (but in bits instead of bytes). This is a multiple of `pointer_alignment_bits`.
size_bits: u64,
/// The alignment of the type, in bits, when used as a field in a record.
@@ -205,9 +199,7 @@ pub const TypeLayout = struct {
/// cases in GCC where `_Alignof` returns a smaller value.
field_alignment_bits: u32,
/// The alignment, in bits, of valid pointers to this type.
- ///
- /// This is the value returned by `std::mem::align_of` in Rust
- /// (but in bits instead of bytes). `size_bits` is a multiple of this value.
+ /// `size_bits` is a multiple of this value.
pointer_alignment_bits: u32,
/// The required alignment of the type in bits.
///
@@ -301,6 +293,15 @@ pub const Record = struct {
}
return false;
}
+
+ pub fn hasField(self: *const Record, name: StringId) bool {
+ std.debug.assert(!self.isIncomplete());
+ for (self.fields) |f| {
+ if (f.isAnonymousRecord() and f.ty.getRecord().?.hasField(name)) return true;
+ if (name == f.name) return true;
+ }
+ return false;
+ }
};
pub const Specifier = enum {
@@ -354,12 +355,11 @@ pub const Specifier = enum {
float,
double,
long_double,
- float80,
float128,
+ complex_float16,
complex_float,
complex_double,
complex_long_double,
- complex_float80,
complex_float128,
// data.sub_type
@@ -422,6 +422,8 @@ data: union {
specifier: Specifier,
qual: Qualifiers = .{},
decayed: bool = false,
+/// typedef name, if any
+name: StringId = .empty,
pub const int = Type{ .specifier = .int };
pub const invalid = Type{ .specifier = .invalid };
@@ -435,8 +437,8 @@ pub fn is(ty: Type, specifier: Specifier) bool {
pub fn withAttributes(self: Type, allocator: std.mem.Allocator, attributes: []const Attribute) !Type {
if (attributes.len == 0) return self;
- const attributed_type = try Type.Attributed.create(allocator, self, self.getAttributes(), attributes);
- return Type{ .specifier = .attributed, .data = .{ .attributed = attributed_type }, .decayed = self.decayed };
+ const attributed_type = try Type.Attributed.create(allocator, self, attributes);
+ return .{ .specifier = .attributed, .data = .{ .attributed = attributed_type }, .decayed = self.decayed };
}
pub fn isCallable(ty: Type) ?Type {
@@ -470,6 +472,23 @@ pub fn isArray(ty: Type) bool {
};
}
+/// Must only be used to set the length of an incomplete array as determined by its initializer
+pub fn setIncompleteArrayLen(ty: *Type, len: u64) void {
+ switch (ty.specifier) {
+ .incomplete_array => {
+ // Modifying .data is exceptionally allowed for .incomplete_array.
+ ty.data.array.len = len;
+ ty.specifier = .array;
+ },
+
+ .typeof_type => ty.data.sub_type.setIncompleteArrayLen(len),
+ .typeof_expr => ty.data.expr.ty.setIncompleteArrayLen(len),
+ .attributed => ty.data.attributed.base.setIncompleteArrayLen(len),
+
+ else => unreachable,
+ }
+}
+
/// Whether the type is promoted if used as a variadic argument or as an argument to a function with no prototype
fn undergoesDefaultArgPromotion(ty: Type, comp: *const Compilation) bool {
return switch (ty.specifier) {
@@ -536,7 +555,7 @@ pub fn isFloat(ty: Type) bool {
return switch (ty.specifier) {
// zig fmt: off
.float, .double, .long_double, .complex_float, .complex_double, .complex_long_double,
- .fp16, .float16, .float80, .float128, .complex_float80, .complex_float128 => true,
+ .fp16, .float16, .float128, .complex_float128, .complex_float16 => true,
// zig fmt: on
.typeof_type => ty.data.sub_type.isFloat(),
.typeof_expr => ty.data.expr.ty.isFloat(),
@@ -548,11 +567,11 @@ pub fn isFloat(ty: Type) bool {
pub fn isReal(ty: Type) bool {
return switch (ty.specifier) {
// zig fmt: off
- .complex_float, .complex_double, .complex_long_double, .complex_float80,
+ .complex_float, .complex_double, .complex_long_double,
.complex_float128, .complex_char, .complex_schar, .complex_uchar, .complex_short,
.complex_ushort, .complex_int, .complex_uint, .complex_long, .complex_ulong,
.complex_long_long, .complex_ulong_long, .complex_int128, .complex_uint128,
- .complex_bit_int => false,
+ .complex_bit_int, .complex_float16 => false,
// zig fmt: on
.typeof_type => ty.data.sub_type.isReal(),
.typeof_expr => ty.data.expr.ty.isReal(),
@@ -564,11 +583,11 @@ pub fn isReal(ty: Type) bool {
pub fn isComplex(ty: Type) bool {
return switch (ty.specifier) {
// zig fmt: off
- .complex_float, .complex_double, .complex_long_double, .complex_float80,
+ .complex_float, .complex_double, .complex_long_double,
.complex_float128, .complex_char, .complex_schar, .complex_uchar, .complex_short,
.complex_ushort, .complex_int, .complex_uint, .complex_long, .complex_ulong,
.complex_long_long, .complex_ulong_long, .complex_int128, .complex_uint128,
- .complex_bit_int => true,
+ .complex_bit_int, .complex_float16 => true,
// zig fmt: on
.typeof_type => ty.data.sub_type.isComplex(),
.typeof_expr => ty.data.expr.ty.isComplex(),
@@ -671,11 +690,11 @@ pub fn elemType(ty: Type) Type {
.attributed => ty.data.attributed.base.elemType(),
.invalid => Type.invalid,
// zig fmt: off
- .complex_float, .complex_double, .complex_long_double, .complex_float80,
+ .complex_float, .complex_double, .complex_long_double,
.complex_float128, .complex_char, .complex_schar, .complex_uchar, .complex_short,
.complex_ushort, .complex_int, .complex_uint, .complex_long, .complex_ulong,
.complex_long_long, .complex_ulong_long, .complex_int128, .complex_uint128,
- .complex_bit_int => ty.makeReal(),
+ .complex_bit_int, .complex_float16 => ty.makeReal(),
// zig fmt: on
else => unreachable,
};
@@ -703,6 +722,16 @@ pub fn params(ty: Type) []Func.Param {
};
}
+/// Returns true if the return value or any param of `ty` is `.invalid`
+/// Asserts that ty is a function type
+pub fn isInvalidFunc(ty: Type) bool {
+ if (ty.returnType().is(.invalid)) return true;
+ for (ty.params()) |param| {
+ if (param.ty.is(.invalid)) return true;
+ }
+ return false;
+}
+
pub fn arrayLen(ty: Type) ?u64 {
return switch (ty.specifier) {
.array, .static_array => ty.data.array.len,
@@ -726,15 +755,6 @@ pub fn anyQual(ty: Type) bool {
};
}
-pub fn getAttributes(ty: Type) []const Attribute {
- return switch (ty.specifier) {
- .attributed => ty.data.attributed.attributes,
- .typeof_type => ty.data.sub_type.getAttributes(),
- .typeof_expr => ty.data.expr.ty.getAttributes(),
- else => &.{},
- };
-}
-
pub fn getRecord(ty: Type) ?*const Type.Record {
return switch (ty.specifier) {
.attributed => ty.data.attributed.base.getRecord(),
@@ -795,8 +815,8 @@ fn realIntegerConversion(a: Type, b: Type, comp: *const Compilation) Type {
pub fn makeIntegerUnsigned(ty: Type) Type {
// TODO discards attributed/typeof
- var base = ty.canonicalize(.standard);
- switch (base.specifier) {
+ var base_ty = ty.canonicalize(.standard);
+ switch (base_ty.specifier) {
// zig fmt: off
.uchar, .ushort, .uint, .ulong, .ulong_long, .uint128,
.complex_uchar, .complex_ushort, .complex_uint, .complex_ulong, .complex_ulong_long, .complex_uint128,
@@ -804,21 +824,21 @@ pub fn makeIntegerUnsigned(ty: Type) Type {
// zig fmt: on
.char, .complex_char => {
- base.specifier = @enumFromInt(@intFromEnum(base.specifier) + 2);
- return base;
+ base_ty.specifier = @enumFromInt(@intFromEnum(base_ty.specifier) + 2);
+ return base_ty;
},
// zig fmt: off
.schar, .short, .int, .long, .long_long, .int128,
.complex_schar, .complex_short, .complex_int, .complex_long, .complex_long_long, .complex_int128 => {
- base.specifier = @enumFromInt(@intFromEnum(base.specifier) + 1);
- return base;
+ base_ty.specifier = @enumFromInt(@intFromEnum(base_ty.specifier) + 1);
+ return base_ty;
},
// zig fmt: on
.bit_int, .complex_bit_int => {
- base.data.int.signedness = .unsigned;
- return base;
+ base_ty.data.int.signedness = .unsigned;
+ return base_ty;
},
else => unreachable,
}
@@ -837,6 +857,8 @@ pub fn integerPromotion(ty: Type, comp: *Compilation) Type {
switch (specifier) {
.@"enum" => {
if (ty.hasIncompleteSize()) return .{ .specifier = .int };
+ if (ty.data.@"enum".fixed) return ty.data.@"enum".tag_ty.integerPromotion(comp);
+
specifier = ty.data.@"enum".tag_ty.specifier;
},
.bit_int, .complex_bit_int => return .{ .specifier = specifier, .data = ty.data },
@@ -915,53 +937,7 @@ pub fn hasUnboundVLA(ty: Type) bool {
}
pub fn hasField(ty: Type, name: StringId) bool {
- switch (ty.specifier) {
- .@"struct" => {
- std.debug.assert(!ty.data.record.isIncomplete());
- for (ty.data.record.fields) |f| {
- if (f.isAnonymousRecord() and f.ty.hasField(name)) return true;
- if (name == f.name) return true;
- }
- },
- .@"union" => {
- std.debug.assert(!ty.data.record.isIncomplete());
- for (ty.data.record.fields) |f| {
- if (f.isAnonymousRecord() and f.ty.hasField(name)) return true;
- if (name == f.name) return true;
- }
- },
- .typeof_type => return ty.data.sub_type.hasField(name),
- .typeof_expr => return ty.data.expr.ty.hasField(name),
- .attributed => return ty.data.attributed.base.hasField(name),
- .invalid => return false,
- else => unreachable,
- }
- return false;
-}
-
-// TODO handle bitints
-pub fn minInt(ty: Type, comp: *const Compilation) i64 {
- std.debug.assert(ty.isInt());
- if (ty.isUnsignedInt(comp)) return 0;
- return switch (ty.sizeof(comp).?) {
- 1 => std.math.minInt(i8),
- 2 => std.math.minInt(i16),
- 4 => std.math.minInt(i32),
- 8 => std.math.minInt(i64),
- else => unreachable,
- };
-}
-
-// TODO handle bitints
-pub fn maxInt(ty: Type, comp: *const Compilation) u64 {
- std.debug.assert(ty.isInt());
- return switch (ty.sizeof(comp).?) {
- 1 => if (ty.isUnsignedInt(comp)) @as(u64, std.math.maxInt(u8)) else std.math.maxInt(i8),
- 2 => if (ty.isUnsignedInt(comp)) @as(u64, std.math.maxInt(u16)) else std.math.maxInt(i16),
- 4 => if (ty.isUnsignedInt(comp)) @as(u64, std.math.maxInt(u32)) else std.math.maxInt(i32),
- 8 => if (ty.isUnsignedInt(comp)) @as(u64, std.math.maxInt(u64)) else std.math.maxInt(i64),
- else => unreachable,
- };
+ return ty.getRecord().?.hasField(name);
}
const TypeSizeOrder = enum {
@@ -1004,16 +980,15 @@ pub fn sizeof(ty: Type, comp: *const Compilation) ?u64 {
.fp16, .float16 => 2,
.float => comp.target.cTypeByteSize(.float),
.double => comp.target.cTypeByteSize(.double),
- .float80 => 16,
.float128 => 16,
.bit_int => {
- return std.mem.alignForward(u64, (ty.data.int.bits + 7) / 8, ty.alignof(comp));
+ return std.mem.alignForward(u64, (@as(u32, ty.data.int.bits) + 7) / 8, ty.alignof(comp));
},
// zig fmt: off
.complex_char, .complex_schar, .complex_uchar, .complex_short, .complex_ushort, .complex_int,
.complex_uint, .complex_long, .complex_ulong, .complex_long_long, .complex_ulong_long,
.complex_int128, .complex_uint128, .complex_float, .complex_double,
- .complex_long_double, .complex_float80, .complex_float128, .complex_bit_int,
+ .complex_long_double, .complex_float128, .complex_bit_int, .complex_float16,
=> return 2 * ty.makeReal().sizeof(comp).?,
// zig fmt: on
.pointer => unreachable,
@@ -1050,7 +1025,6 @@ pub fn bitSizeof(ty: Type, comp: *const Compilation) ?u64 {
.attributed => ty.data.attributed.base.bitSizeof(comp),
.bit_int => return ty.data.int.bits,
.long_double => comp.target.cTypeBitSize(.longdouble),
- .float80 => return 80,
else => 8 * (ty.sizeof(comp) orelse return null),
};
}
@@ -1100,7 +1074,7 @@ pub fn alignof(ty: Type, comp: *const Compilation) u29 {
.complex_char, .complex_schar, .complex_uchar, .complex_short, .complex_ushort, .complex_int,
.complex_uint, .complex_long, .complex_ulong, .complex_long_long, .complex_ulong_long,
.complex_int128, .complex_uint128, .complex_float, .complex_double,
- .complex_long_double, .complex_float80, .complex_float128, .complex_bit_int,
+ .complex_long_double, .complex_float128, .complex_bit_int, .complex_float16,
=> return ty.makeReal().alignof(comp),
// zig fmt: on
@@ -1114,10 +1088,15 @@ pub fn alignof(ty: Type, comp: *const Compilation) u29 {
.long_long => comp.target.cTypeAlignment(.longlong),
.ulong_long => comp.target.cTypeAlignment(.ulonglong),
- .bit_int => @min(
- std.math.ceilPowerOfTwoPromote(u16, (ty.data.int.bits + 7) / 8),
- 16, // comp.target.maxIntAlignment(), please use your own logic for this value as it is implementation-defined
- ),
+ .bit_int => {
+ // https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2709.pdf
+ // _BitInt(N) types align with existing calling conventions. They have the same size and alignment as the
+ // smallest basic type that can contain them. Types that are larger than __int64_t are conceptually treated
+ // as struct of register size chunks. The number of chunks is the smallest number that can contain the type.
+ if (ty.data.int.bits > 64) return 8;
+ const basic_type = comp.intLeastN(ty.data.int.bits, ty.data.int.signedness);
+ return basic_type.alignof(comp);
+ },
.float => comp.target.cTypeAlignment(.float),
.double => comp.target.cTypeAlignment(.double),
@@ -1126,7 +1105,7 @@ pub fn alignof(ty: Type, comp: *const Compilation) u29 {
.int128, .uint128 => if (comp.target.cpu.arch == .s390x and comp.target.os.tag == .linux and comp.target.isGnu()) 8 else 16,
.fp16, .float16 => 2,
- .float80, .float128 => 16,
+ .float128 => 16,
.pointer,
.static_array,
.nullptr_t,
@@ -1142,7 +1121,11 @@ pub fn alignof(ty: Type, comp: *const Compilation) u29 {
};
}
-pub const QualHandling = enum { standard, preserve_quals };
+// This enum should be kept public because it is used by the downstream zig translate-c
+pub const QualHandling = enum {
+ standard,
+ preserve_quals,
+};
/// Canonicalize a possibly-typeof() type. If the type is not a typeof() type, simply
/// return it. Otherwise, determine the actual qualified type.
@@ -1151,17 +1134,12 @@ pub const QualHandling = enum { standard, preserve_quals };
/// arrays and pointers.
pub fn canonicalize(ty: Type, qual_handling: QualHandling) Type {
var cur = ty;
- if (cur.specifier == .attributed) {
- cur = cur.data.attributed.base;
- cur.decayed = ty.decayed;
- }
- if (!cur.isTypeof()) return cur;
-
var qual = cur.qual;
while (true) {
switch (cur.specifier) {
.typeof_type => cur = cur.data.sub_type.*,
.typeof_expr => cur = cur.data.expr.ty,
+ .attributed => cur = cur.data.attributed.base,
else => break,
}
qual = qual.mergeAll(cur.qual);
@@ -1189,7 +1167,7 @@ pub fn requestedAlignment(ty: Type, comp: *const Compilation) ?u29 {
return switch (ty.specifier) {
.typeof_type => ty.data.sub_type.requestedAlignment(comp),
.typeof_expr => ty.data.expr.ty.requestedAlignment(comp),
- .attributed => annotationAlignment(comp, ty.data.attributed.attributes),
+ .attributed => annotationAlignment(comp, Attribute.Iterator.initType(ty)),
else => null,
};
}
@@ -1199,12 +1177,27 @@ pub fn enumIsPacked(ty: Type, comp: *const Compilation) bool {
return comp.langopts.short_enums or target_util.packAllEnums(comp.target) or ty.hasAttribute(.@"packed");
}
-pub fn annotationAlignment(comp: *const Compilation, attrs: ?[]const Attribute) ?u29 {
- const a = attrs orelse return null;
+pub fn getName(ty: Type) StringId {
+ return switch (ty.specifier) {
+ .typeof_type => if (ty.name == .empty) ty.data.sub_type.getName() else ty.name,
+ .typeof_expr => if (ty.name == .empty) ty.data.expr.ty.getName() else ty.name,
+ .attributed => if (ty.name == .empty) ty.data.attributed.base.getName() else ty.name,
+ else => ty.name,
+ };
+}
+pub fn annotationAlignment(comp: *const Compilation, attrs: Attribute.Iterator) ?u29 {
+ var it = attrs;
var max_requested: ?u29 = null;
- for (a) |attribute| {
+ var last_aligned_index: ?usize = null;
+ while (it.next()) |item| {
+ const attribute, const index = item;
if (attribute.tag != .aligned) continue;
+ if (last_aligned_index) |aligned_index| {
+ // once we recurse into a new type, after an `aligned` attribute was found, we're done
+ if (index <= aligned_index) break;
+ }
+ last_aligned_index = index;
const requested = if (attribute.args.aligned.alignment) |alignment| alignment.requested else target_util.defaultAlignment(comp.target);
if (max_requested == null or max_requested.? < requested) {
max_requested = requested;
@@ -1225,6 +1218,10 @@ pub fn eql(a_param: Type, b_param: Type, comp: *const Compilation, check_qualifi
if (!b.isFunc()) return false;
} else if (a.isArray()) {
if (!b.isArray()) return false;
+ } else if (a.specifier == .@"enum" and b.specifier != .@"enum") {
+ return a.data.@"enum".tag_ty.eql(b, comp, check_qualifiers);
+ } else if (b.specifier == .@"enum" and a.specifier != .@"enum") {
+ return a.eql(b.data.@"enum".tag_ty, comp, check_qualifiers);
} else if (a.specifier != b.specifier) return false;
if (a.qual.atomic != b.qual.atomic) return false;
@@ -1315,6 +1312,12 @@ pub fn integerRank(ty: Type, comp: *const Compilation) usize {
.long_long, .ulong_long => 6 + (ty.bitSizeof(comp).? << 3),
.int128, .uint128 => 7 + (ty.bitSizeof(comp).? << 3),
+ .typeof_type => ty.data.sub_type.integerRank(comp),
+ .typeof_expr => ty.data.expr.ty.integerRank(comp),
+ .attributed => ty.data.attributed.base.integerRank(comp),
+
+ .@"enum" => real.data.@"enum".tag_ty.integerRank(comp),
+
else => unreachable,
});
}
@@ -1322,25 +1325,26 @@ pub fn integerRank(ty: Type, comp: *const Compilation) usize {
/// Returns true if `a` and `b` are integer types that differ only in sign
pub fn sameRankDifferentSign(a: Type, b: Type, comp: *const Compilation) bool {
if (!a.isInt() or !b.isInt()) return false;
+ if (a.hasIncompleteSize() or b.hasIncompleteSize()) return false;
if (a.integerRank(comp) != b.integerRank(comp)) return false;
return a.isUnsignedInt(comp) != b.isUnsignedInt(comp);
}
pub fn makeReal(ty: Type) Type {
// TODO discards attributed/typeof
- var base = ty.canonicalize(.standard);
- switch (base.specifier) {
- .complex_float, .complex_double, .complex_long_double, .complex_float80, .complex_float128 => {
- base.specifier = @enumFromInt(@intFromEnum(base.specifier) - 5);
- return base;
+ var base_ty = ty.canonicalize(.standard);
+ switch (base_ty.specifier) {
+ .complex_float16, .complex_float, .complex_double, .complex_long_double, .complex_float128 => {
+ base_ty.specifier = @enumFromInt(@intFromEnum(base_ty.specifier) - 5);
+ return base_ty;
},
.complex_char, .complex_schar, .complex_uchar, .complex_short, .complex_ushort, .complex_int, .complex_uint, .complex_long, .complex_ulong, .complex_long_long, .complex_ulong_long, .complex_int128, .complex_uint128 => {
- base.specifier = @enumFromInt(@intFromEnum(base.specifier) - 13);
- return base;
+ base_ty.specifier = @enumFromInt(@intFromEnum(base_ty.specifier) - 13);
+ return base_ty;
},
.complex_bit_int => {
- base.specifier = .bit_int;
- return base;
+ base_ty.specifier = .bit_int;
+ return base_ty;
},
else => return ty,
}
@@ -1348,19 +1352,19 @@ pub fn makeReal(ty: Type) Type {
pub fn makeComplex(ty: Type) Type {
// TODO discards attributed/typeof
- var base = ty.canonicalize(.standard);
- switch (base.specifier) {
- .float, .double, .long_double, .float80, .float128 => {
- base.specifier = @enumFromInt(@intFromEnum(base.specifier) + 5);
- return base;
+ var base_ty = ty.canonicalize(.standard);
+ switch (base_ty.specifier) {
+ .float, .double, .long_double, .float128 => {
+ base_ty.specifier = @enumFromInt(@intFromEnum(base_ty.specifier) + 5);
+ return base_ty;
},
.char, .schar, .uchar, .short, .ushort, .int, .uint, .long, .ulong, .long_long, .ulong_long, .int128, .uint128 => {
- base.specifier = @enumFromInt(@intFromEnum(base.specifier) + 13);
- return base;
+ base_ty.specifier = @enumFromInt(@intFromEnum(base_ty.specifier) + 13);
+ return base_ty;
},
.bit_int => {
- base.specifier = .complex_bit_int;
- return base;
+ base_ty.specifier = .complex_bit_int;
+ return base_ty;
},
else => return ty,
}
@@ -1541,13 +1545,12 @@ pub const Builder = struct {
float,
double,
long_double,
- float80,
float128,
complex,
+ complex_float16,
complex_float,
complex_double,
complex_long_double,
- complex_float80,
complex_float128,
pointer: *Type,
@@ -1613,9 +1616,6 @@ pub const Builder = struct {
.int128 => "__int128",
.sint128 => "signed __int128",
.uint128 => "unsigned __int128",
- .bit_int => "_BitInt",
- .sbit_int => "signed _BitInt",
- .ubit_int => "unsigned _BitInt",
.complex_char => "_Complex char",
.complex_schar => "_Complex signed char",
.complex_uchar => "_Complex unsigned char",
@@ -1645,22 +1645,18 @@ pub const Builder = struct {
.complex_int128 => "_Complex __int128",
.complex_sint128 => "_Complex signed __int128",
.complex_uint128 => "_Complex unsigned __int128",
- .complex_bit_int => "_Complex _BitInt",
- .complex_sbit_int => "_Complex signed _BitInt",
- .complex_ubit_int => "_Complex unsigned _BitInt",
.fp16 => "__fp16",
.float16 => "_Float16",
.float => "float",
.double => "double",
.long_double => "long double",
- .float80 => "__float80",
.float128 => "__float128",
.complex => "_Complex",
+ .complex_float16 => "_Complex _Float16",
.complex_float => "_Complex float",
.complex_double => "_Complex double",
.complex_long_double => "_Complex long double",
- .complex_float80 => "_Complex __float80",
.complex_float128 => "_Complex __float128",
.attributed => |attributed| Builder.fromType(attributed.base).str(langopts),
@@ -1757,19 +1753,20 @@ pub const Builder = struct {
.complex_uint128 => ty.specifier = .complex_uint128,
.bit_int, .sbit_int, .ubit_int, .complex_bit_int, .complex_ubit_int, .complex_sbit_int => |bits| {
const unsigned = b.specifier == .ubit_int or b.specifier == .complex_ubit_int;
+ const complex_str = if (b.complex_tok != null) "_Complex " else "";
if (unsigned) {
if (bits < 1) {
- try p.errStr(.unsigned_bit_int_too_small, b.bit_int_tok.?, b.specifier.str(p.comp.langopts).?);
+ try p.errStr(.unsigned_bit_int_too_small, b.bit_int_tok.?, complex_str);
return Type.invalid;
}
} else {
if (bits < 2) {
- try p.errStr(.signed_bit_int_too_small, b.bit_int_tok.?, b.specifier.str(p.comp.langopts).?);
+ try p.errStr(.signed_bit_int_too_small, b.bit_int_tok.?, complex_str);
return Type.invalid;
}
}
if (bits > Compilation.bit_int_max_bits) {
- try p.errStr(.bit_int_too_big, b.bit_int_tok.?, b.specifier.str(p.comp.langopts).?);
+ try p.errStr(if (unsigned) .unsigned_bit_int_too_big else .signed_bit_int_too_big, b.bit_int_tok.?, complex_str);
return Type.invalid;
}
ty.specifier = if (b.complex_tok != null) .complex_bit_int else .bit_int;
@@ -1784,12 +1781,11 @@ pub const Builder = struct {
.float => ty.specifier = .float,
.double => ty.specifier = .double,
.long_double => ty.specifier = .long_double,
- .float80 => ty.specifier = .float80,
.float128 => ty.specifier = .float128,
+ .complex_float16 => ty.specifier = .complex_float16,
.complex_float => ty.specifier = .complex_float,
.complex_double => ty.specifier = .complex_double,
.complex_long_double => ty.specifier = .complex_long_double,
- .complex_float80 => ty.specifier = .complex_float80,
.complex_float128 => ty.specifier = .complex_float128,
.complex => {
try p.errTok(.plain_complex, p.tok_i - 1);
@@ -1907,6 +1903,7 @@ pub const Builder = struct {
/// Try to combine type from typedef, returns true if successful.
pub fn combineTypedef(b: *Builder, p: *Parser, typedef_ty: Type, name_tok: TokenIndex) bool {
+ if (typedef_ty.is(.invalid)) return false;
b.error_on_invalid = true;
defer b.error_on_invalid = false;
@@ -2094,6 +2091,7 @@ pub const Builder = struct {
},
.long => b.specifier = switch (b.specifier) {
.none => .long,
+ .double => .long_double,
.long => .long_long,
.unsigned => .ulong,
.signed => .long,
@@ -2106,6 +2104,7 @@ pub const Builder = struct {
.complex_long => .complex_long_long,
.complex_slong => .complex_slong_long,
.complex_ulong => .complex_ulong_long,
+ .complex_double => .complex_long_double,
else => return b.cannotCombine(p, source_tok),
},
.int128 => b.specifier = switch (b.specifier) {
@@ -2140,6 +2139,7 @@ pub const Builder = struct {
},
.float16 => b.specifier = switch (b.specifier) {
.none => .float16,
+ .complex => .complex_float16,
else => return b.cannotCombine(p, source_tok),
},
.float => b.specifier = switch (b.specifier) {
@@ -2154,11 +2154,6 @@ pub const Builder = struct {
.complex => .complex_double,
else => return b.cannotCombine(p, source_tok),
},
- .float80 => b.specifier = switch (b.specifier) {
- .none => .float80,
- .complex => .complex_float80,
- else => return b.cannotCombine(p, source_tok),
- },
.float128 => b.specifier = switch (b.specifier) {
.none => .float128,
.complex => .complex_float128,
@@ -2166,10 +2161,10 @@ pub const Builder = struct {
},
.complex => b.specifier = switch (b.specifier) {
.none => .complex,
+ .float16 => .complex_float16,
.float => .complex_float,
.double => .complex_double,
.long_double => .complex_long_double,
- .float80 => .complex_float80,
.float128 => .complex_float128,
.char => .complex_char,
.schar => .complex_schar,
@@ -2207,7 +2202,6 @@ pub const Builder = struct {
.complex_float,
.complex_double,
.complex_long_double,
- .complex_float80,
.complex_float128,
.complex_char,
.complex_schar,
@@ -2294,13 +2288,12 @@ pub const Builder = struct {
.float16 => .float16,
.float => .float,
.double => .double,
- .float80 => .float80,
.float128 => .float128,
.long_double => .long_double,
+ .complex_float16 => .complex_float16,
.complex_float => .complex_float,
.complex_double => .complex_double,
.complex_long_double => .complex_long_double,
- .complex_float80 => .complex_float80,
.complex_float128 => .complex_float128,
.pointer => .{ .pointer = ty.data.sub_type },
@@ -2350,22 +2343,30 @@ pub const Builder = struct {
}
};
+/// Use with caution
+pub fn base(ty: *Type) *Type {
+ return switch (ty.specifier) {
+ .typeof_type => ty.data.sub_type.base(),
+ .typeof_expr => ty.data.expr.ty.base(),
+ .attributed => ty.data.attributed.base.base(),
+ else => ty,
+ };
+}
+
pub fn getAttribute(ty: Type, comptime tag: Attribute.Tag) ?Attribute.ArgumentsForTag(tag) {
- switch (ty.specifier) {
- .typeof_type => return ty.data.sub_type.getAttribute(tag),
- .typeof_expr => return ty.data.expr.ty.getAttribute(tag),
- .attributed => {
- for (ty.data.attributed.attributes) |attribute| {
- if (attribute.tag == tag) return @field(attribute.args, @tagName(tag));
- }
- return null;
- },
- else => return null,
+ if (tag == .aligned) @compileError("use requestedAlignment");
+ var it = Attribute.Iterator.initType(ty);
+ while (it.next()) |item| {
+ const attribute, _ = item;
+ if (attribute.tag == tag) return @field(attribute.args, @tagName(tag));
}
+ return null;
}
pub fn hasAttribute(ty: Type, tag: Attribute.Tag) bool {
- for (ty.getAttributes()) |attr| {
+ var it = Attribute.Iterator.initType(ty);
+ while (it.next()) |item| {
+ const attr, _ = item;
if (attr.tag == tag) return true;
}
return false;
@@ -2489,6 +2490,8 @@ fn printPrologue(ty: Type, mapper: StringInterner.TypeMapper, langopts: LangOpts
_ = try elem_ty.printPrologue(mapper, langopts, w);
try w.writeAll("' values)");
},
+ .bit_int => try w.print("{s} _BitInt({d})", .{ @tagName(ty.data.int.signedness), ty.data.int.bits }),
+ .complex_bit_int => try w.print("_Complex {s} _BitInt({d})", .{ @tagName(ty.data.int.signedness), ty.data.int.bits }),
else => try w.writeAll(Builder.fromType(ty).str(langopts).?),
}
return true;
@@ -2644,15 +2647,12 @@ pub fn dump(ty: Type, mapper: StringInterner.TypeMapper, langopts: LangOpts, w:
.attributed => {
if (ty.isDecayed()) try w.writeAll("*d:");
try w.writeAll("attributed(");
- try ty.data.attributed.base.dump(mapper, langopts, w);
+ try ty.data.attributed.base.canonicalize(.standard).dump(mapper, langopts, w);
try w.writeAll(")");
},
- else => {
- try w.writeAll(Builder.fromType(ty).str(langopts).?);
- if (ty.specifier == .bit_int or ty.specifier == .complex_bit_int) {
- try w.print("({d})", .{ty.data.int.bits});
- }
- },
+ .bit_int => try w.print("{s} _BitInt({d})", .{ @tagName(ty.data.int.signedness), ty.data.int.bits }),
+ .complex_bit_int => try w.print("_Complex {s} _BitInt({d})", .{ @tagName(ty.data.int.signedness), ty.data.int.bits }),
+ else => try w.writeAll(Builder.fromType(ty).str(langopts).?),
}
}
diff --git a/lib/compiler/aro/aro/Value.zig b/lib/compiler/aro/aro/Value.zig
index 2dd9a86abe24..892a09b1d67d 100644
--- a/lib/compiler/aro/aro/Value.zig
+++ b/lib/compiler/aro/aro/Value.zig
@@ -8,6 +8,7 @@ const BigIntSpace = Interner.Tag.Int.BigIntSpace;
const Compilation = @import("Compilation.zig");
const Type = @import("Type.zig");
const target_util = @import("target.zig");
+const annex_g = @import("annex_g.zig");
const Value = @This();
@@ -41,6 +42,14 @@ pub fn is(v: Value, tag: std.meta.Tag(Interner.Key), comp: *const Compilation) b
return comp.interner.get(v.ref()) == tag;
}
+pub fn isArithmetic(v: Value, comp: *const Compilation) bool {
+ if (v.opt_ref == .none) return false;
+ return switch (comp.interner.get(v.ref())) {
+ .int, .float, .complex => true,
+ else => false,
+ };
+}
+
/// Number of bits needed to hold `v`.
/// Asserts that `v` is not negative
pub fn minUnsignedBits(v: Value, comp: *const Compilation) usize {
@@ -58,7 +67,7 @@ test "minUnsignedBits" {
}
};
- var comp = Compilation.init(std.testing.allocator);
+ var comp = Compilation.init(std.testing.allocator, std.fs.cwd());
defer comp.deinit();
const target_query = try std.Target.Query.parse(.{ .arch_os_abi = "x86_64-linux-gnu" });
comp.target = try std.zig.system.resolveTargetQuery(target_query);
@@ -93,7 +102,7 @@ test "minSignedBits" {
}
};
- var comp = Compilation.init(std.testing.allocator);
+ var comp = Compilation.init(std.testing.allocator, std.fs.cwd());
defer comp.deinit();
const target_query = try std.Target.Query.parse(.{ .arch_os_abi = "x86_64-linux-gnu" });
comp.target = try std.zig.system.resolveTargetQuery(target_query);
@@ -134,7 +143,7 @@ pub fn floatToInt(v: *Value, dest_ty: Type, comp: *Compilation) !FloatToIntChang
v.* = fromBool(!was_zero);
if (was_zero or was_one) return .none;
return .value_changed;
- } else if (dest_ty.isUnsignedInt(comp) and v.compare(.lt, zero, comp)) {
+ } else if (dest_ty.isUnsignedInt(comp) and float_val < 0) {
v.* = zero;
return .out_of_range;
}
@@ -154,7 +163,7 @@ pub fn floatToInt(v: *Value, dest_ty: Type, comp: *Compilation) !FloatToIntChang
};
// The float is reduced in rational.setFloat, so we assert that denominator is equal to one
- const big_one = std.math.big.int.Const{ .limbs = &.{1}, .positive = true };
+ const big_one = BigIntConst{ .limbs = &.{1}, .positive = true };
assert(rational.q.toConst().eqlAbs(big_one));
if (is_negative) {
@@ -179,6 +188,20 @@ pub fn floatToInt(v: *Value, dest_ty: Type, comp: *Compilation) !FloatToIntChang
/// `.none` value remains unchanged.
pub fn intToFloat(v: *Value, dest_ty: Type, comp: *Compilation) !void {
if (v.opt_ref == .none) return;
+
+ if (dest_ty.isComplex()) {
+ const bits = dest_ty.bitSizeof(comp).?;
+ const cf: Interner.Key.Complex = switch (bits) {
+ 32 => .{ .cf16 = .{ v.toFloat(f16, comp), 0 } },
+ 64 => .{ .cf32 = .{ v.toFloat(f32, comp), 0 } },
+ 128 => .{ .cf64 = .{ v.toFloat(f64, comp), 0 } },
+ 160 => .{ .cf80 = .{ v.toFloat(f80, comp), 0 } },
+ 256 => .{ .cf128 = .{ v.toFloat(f128, comp), 0 } },
+ else => unreachable,
+ };
+ v.* = try intern(comp, .{ .complex = cf });
+ return;
+ }
const bits = dest_ty.bitSizeof(comp).?;
return switch (comp.interner.get(v.ref()).int) {
inline .u64, .i64 => |data| {
@@ -207,40 +230,89 @@ pub fn intToFloat(v: *Value, dest_ty: Type, comp: *Compilation) !void {
};
}
+pub const IntCastChangeKind = enum {
+ /// value did not change
+ none,
+ /// Truncation occurred (e.g., i32 to i16)
+ truncated,
+ /// Sign conversion occurred (e.g., i32 to u32)
+ sign_changed,
+};
+
/// Truncates or extends bits based on type.
/// `.none` value remains unchanged.
-pub fn intCast(v: *Value, dest_ty: Type, comp: *Compilation) !void {
- if (v.opt_ref == .none) return;
- const bits: usize = @intCast(dest_ty.bitSizeof(comp).?);
+pub fn intCast(v: *Value, dest_ty: Type, comp: *Compilation) !IntCastChangeKind {
+ if (v.opt_ref == .none) return .none;
+
+ const dest_bits: usize = @intCast(dest_ty.bitSizeof(comp).?);
+ const dest_signed = dest_ty.signedness(comp) == .signed;
+
var space: BigIntSpace = undefined;
const big = v.toBigInt(&space, comp);
+ const value_bits = big.bitCountTwosComp();
+
+ // if big is negative, then is signed.
+ const src_signed = !big.positive;
+ const sign_change = src_signed != dest_signed;
const limbs = try comp.gpa.alloc(
std.math.big.Limb,
- std.math.big.int.calcTwosCompLimbCount(@max(big.bitCountTwosComp(), bits)),
+ std.math.big.int.calcTwosCompLimbCount(@max(value_bits, dest_bits)),
);
defer comp.gpa.free(limbs);
- var result_bigint = std.math.big.int.Mutable{ .limbs = limbs, .positive = undefined, .len = undefined };
- result_bigint.truncate(big, dest_ty.signedness(comp), bits);
+
+ var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
+ result_bigint.truncate(big, dest_ty.signedness(comp), dest_bits);
v.* = try intern(comp, .{ .int = .{ .big_int = result_bigint.toConst() } });
+
+ const truncation_occurred = value_bits > dest_bits;
+ if (truncation_occurred) {
+ return .truncated;
+ } else if (sign_change) {
+ return .sign_changed;
+ } else {
+ return .none;
+ }
}
/// Converts the stored value to a float of the specified type
/// `.none` value remains unchanged.
pub fn floatCast(v: *Value, dest_ty: Type, comp: *Compilation) !void {
if (v.opt_ref == .none) return;
- // TODO complex values
- const bits = dest_ty.makeReal().bitSizeof(comp).?;
- const f: Interner.Key.Float = switch (bits) {
- 16 => .{ .f16 = v.toFloat(f16, comp) },
- 32 => .{ .f32 = v.toFloat(f32, comp) },
- 64 => .{ .f64 = v.toFloat(f64, comp) },
- 80 => .{ .f80 = v.toFloat(f80, comp) },
- 128 => .{ .f128 = v.toFloat(f128, comp) },
+ const bits = dest_ty.bitSizeof(comp).?;
+ if (dest_ty.isComplex()) {
+ const cf: Interner.Key.Complex = switch (bits) {
+ 32 => .{ .cf16 = .{ v.toFloat(f16, comp), v.imag(f16, comp) } },
+ 64 => .{ .cf32 = .{ v.toFloat(f32, comp), v.imag(f32, comp) } },
+ 128 => .{ .cf64 = .{ v.toFloat(f64, comp), v.imag(f64, comp) } },
+ 160 => .{ .cf80 = .{ v.toFloat(f80, comp), v.imag(f80, comp) } },
+ 256 => .{ .cf128 = .{ v.toFloat(f128, comp), v.imag(f128, comp) } },
+ else => unreachable,
+ };
+ v.* = try intern(comp, .{ .complex = cf });
+ } else {
+ const f: Interner.Key.Float = switch (bits) {
+ 16 => .{ .f16 = v.toFloat(f16, comp) },
+ 32 => .{ .f32 = v.toFloat(f32, comp) },
+ 64 => .{ .f64 = v.toFloat(f64, comp) },
+ 80 => .{ .f80 = v.toFloat(f80, comp) },
+ 128 => .{ .f128 = v.toFloat(f128, comp) },
+ else => unreachable,
+ };
+ v.* = try intern(comp, .{ .float = f });
+ }
+}
+
+pub fn imag(v: Value, comptime T: type, comp: *const Compilation) T {
+ return switch (comp.interner.get(v.ref())) {
+ .int => 0.0,
+ .float => 0.0,
+ .complex => |repr| switch (repr) {
+ inline else => |components| return @floatCast(components[1]),
+ },
else => unreachable,
};
- v.* = try intern(comp, .{ .float = f });
}
pub fn toFloat(v: Value, comptime T: type, comp: *const Compilation) T {
@@ -252,6 +324,39 @@ pub fn toFloat(v: Value, comptime T: type, comp: *const Compilation) T {
.float => |repr| switch (repr) {
inline else => |data| @floatCast(data),
},
+ .complex => |repr| switch (repr) {
+ inline else => |components| @floatCast(components[0]),
+ },
+ else => unreachable,
+ };
+}
+
+pub fn realPart(v: Value, comp: *Compilation) !Value {
+ if (v.opt_ref == .none) return v;
+ return switch (comp.interner.get(v.ref())) {
+ .int, .float => v,
+ .complex => |repr| Value.intern(comp, switch (repr) {
+ .cf16 => |components| .{ .float = .{ .f16 = components[0] } },
+ .cf32 => |components| .{ .float = .{ .f32 = components[0] } },
+ .cf64 => |components| .{ .float = .{ .f64 = components[0] } },
+ .cf80 => |components| .{ .float = .{ .f80 = components[0] } },
+ .cf128 => |components| .{ .float = .{ .f128 = components[0] } },
+ }),
+ else => unreachable,
+ };
+}
+
+pub fn imaginaryPart(v: Value, comp: *Compilation) !Value {
+ if (v.opt_ref == .none) return v;
+ return switch (comp.interner.get(v.ref())) {
+ .int, .float => Value.zero,
+ .complex => |repr| Value.intern(comp, switch (repr) {
+ .cf16 => |components| .{ .float = .{ .f16 = components[1] } },
+ .cf32 => |components| .{ .float = .{ .f32 = components[1] } },
+ .cf64 => |components| .{ .float = .{ .f64 = components[1] } },
+ .cf80 => |components| .{ .float = .{ .f80 = components[1] } },
+ .cf128 => |components| .{ .float = .{ .f128 = components[1] } },
+ }),
else => unreachable,
};
}
@@ -298,11 +403,56 @@ pub fn isZero(v: Value, comp: *const Compilation) bool {
inline .i64, .u64 => |data| return data == 0,
.big_int => |data| return data.eqlZero(),
},
+ .complex => |repr| switch (repr) {
+ inline else => |data| return data[0] == 0.0 and data[1] == 0.0,
+ },
.bytes => return false,
else => unreachable,
}
}
+const IsInfKind = enum(i32) {
+ negative = -1,
+ finite = 0,
+ positive = 1,
+ unknown = std.math.maxInt(i32),
+};
+
+pub fn isInfSign(v: Value, comp: *const Compilation) IsInfKind {
+ if (v.opt_ref == .none) return .unknown;
+ return switch (comp.interner.get(v.ref())) {
+ .float => |repr| switch (repr) {
+ inline else => |data| if (std.math.isPositiveInf(data)) .positive else if (std.math.isNegativeInf(data)) .negative else .finite,
+ },
+ else => .unknown,
+ };
+}
+pub fn isInf(v: Value, comp: *const Compilation) bool {
+ if (v.opt_ref == .none) return false;
+ return switch (comp.interner.get(v.ref())) {
+ .float => |repr| switch (repr) {
+ inline else => |data| std.math.isInf(data),
+ },
+ .complex => |repr| switch (repr) {
+ inline else => |components| std.math.isInf(components[0]) or std.math.isInf(components[1]),
+ },
+ else => false,
+ };
+}
+
+pub fn isNan(v: Value, comp: *const Compilation) bool {
+ if (v.opt_ref == .none) return false;
+ return switch (comp.interner.get(v.ref())) {
+ .float => |repr| switch (repr) {
+ inline else => |data| std.math.isNan(data),
+ },
+ .complex => |repr| switch (repr) {
+ inline else => |components| std.math.isNan(components[0]) or std.math.isNan(components[1]),
+ },
+ else => false,
+ };
+}
+
/// Converts value to zero or one;
/// `.none` value remains unchanged.
pub fn boolCast(v: *Value, comp: *const Compilation) void {
@@ -326,9 +476,45 @@ pub fn toInt(v: Value, comptime T: type, comp: *const Compilation) ?T {
return big_int.to(T) catch null;
}
+const ComplexOp = enum {
+ add,
+ sub,
+};
+
+fn complexAddSub(lhs: Value, rhs: Value, comptime T: type, op: ComplexOp, comp: *Compilation) !Value {
+ const res_re = switch (op) {
+ .add => lhs.toFloat(T, comp) + rhs.toFloat(T, comp),
+ .sub => lhs.toFloat(T, comp) - rhs.toFloat(T, comp),
+ };
+ const res_im = switch (op) {
+ .add => lhs.imag(T, comp) + rhs.imag(T, comp),
+ .sub => lhs.imag(T, comp) - rhs.imag(T, comp),
+ };
+
+ return switch (T) {
+ f16 => intern(comp, .{ .complex = .{ .cf16 = .{ res_re, res_im } } }),
+ f32 => intern(comp, .{ .complex = .{ .cf32 = .{ res_re, res_im } } }),
+ f64 => intern(comp, .{ .complex = .{ .cf64 = .{ res_re, res_im } } }),
+ f80 => intern(comp, .{ .complex = .{ .cf80 = .{ res_re, res_im } } }),
+ f128 => intern(comp, .{ .complex = .{ .cf128 = .{ res_re, res_im } } }),
+ else => unreachable,
+ };
+}
+
pub fn add(res: *Value, lhs: Value, rhs: Value, ty: Type, comp: *Compilation) !bool {
const bits: usize = @intCast(ty.bitSizeof(comp).?);
if (ty.isFloat()) {
+ if (ty.isComplex()) {
+ res.* = switch (bits) {
+ 32 => try complexAddSub(lhs, rhs, f16, .add, comp),
+ 64 => try complexAddSub(lhs, rhs, f32, .add, comp),
+ 128 => try complexAddSub(lhs, rhs, f64, .add, comp),
+ 160 => try complexAddSub(lhs, rhs, f80, .add, comp),
+ 256 => try complexAddSub(lhs, rhs, f128, .add, comp),
+ else => unreachable,
+ };
+ return false;
+ }
const f: Interner.Key.Float = switch (bits) {
16 => .{ .f16 = lhs.toFloat(f16, comp) + rhs.toFloat(f16, comp) },
32 => .{ .f32 = lhs.toFloat(f32, comp) + rhs.toFloat(f32, comp) },
@@ -350,7 +536,7 @@ pub fn add(res: *Value, lhs: Value, rhs: Value, ty: Type, comp: *Compilation) !b
std.math.big.int.calcTwosCompLimbCount(bits),
);
defer comp.gpa.free(limbs);
- var result_bigint = std.math.big.int.Mutable{ .limbs = limbs, .positive = undefined, .len = undefined };
+ var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
const overflowed = result_bigint.addWrap(lhs_bigint, rhs_bigint, ty.signedness(comp), bits);
res.* = try intern(comp, .{ .int = .{ .big_int = result_bigint.toConst() } });
@@ -361,6 +547,17 @@ pub fn add(res: *Value, lhs: Value, rhs: Value, ty: Type, comp: *Compilation) !b
pub fn sub(res: *Value, lhs: Value, rhs: Value, ty: Type, comp: *Compilation) !bool {
const bits: usize = @intCast(ty.bitSizeof(comp).?);
if (ty.isFloat()) {
+ if (ty.isComplex()) {
+ res.* = switch (bits) {
+ 32 => try complexAddSub(lhs, rhs, f16, .sub, comp),
+ 64 => try complexAddSub(lhs, rhs, f32, .sub, comp),
+ 128 => try complexAddSub(lhs, rhs, f64, .sub, comp),
+ 160 => try complexAddSub(lhs, rhs, f80, .sub, comp),
+ 256 => try complexAddSub(lhs, rhs, f128, .sub, comp),
+ else => unreachable,
+ };
+ return false;
+ }
const f: Interner.Key.Float = switch (bits) {
16 => .{ .f16 = lhs.toFloat(f16, comp) - rhs.toFloat(f16, comp) },
32 => .{ .f32 = lhs.toFloat(f32, comp) - rhs.toFloat(f32, comp) },
@@ -382,7 +579,7 @@ pub fn sub(res: *Value, lhs: Value, rhs: Value, ty: Type, comp: *Compilation) !b
std.math.big.int.calcTwosCompLimbCount(bits),
);
defer comp.gpa.free(limbs);
- var result_bigint = std.math.big.int.Mutable{ .limbs = limbs, .positive = undefined, .len = undefined };
+ var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
const overflowed = result_bigint.subWrap(lhs_bigint, rhs_bigint, ty.signedness(comp), bits);
res.* = try intern(comp, .{ .int = .{ .big_int = result_bigint.toConst() } });
@@ -393,6 +590,18 @@ pub fn sub(res: *Value, lhs: Value, rhs: Value, ty: Type, comp: *Compilation) !b
pub fn mul(res: *Value, lhs: Value, rhs: Value, ty: Type, comp: *Compilation) !bool {
const bits: usize = @intCast(ty.bitSizeof(comp).?);
if (ty.isFloat()) {
+ if (ty.isComplex()) {
+ const cf: Interner.Key.Complex = switch (bits) {
+ 32 => .{ .cf16 = annex_g.complexFloatMul(f16, lhs.toFloat(f16, comp), lhs.imag(f16, comp), rhs.toFloat(f16, comp), rhs.imag(f16, comp)) },
+ 64 => .{ .cf32 = annex_g.complexFloatMul(f32, lhs.toFloat(f32, comp), lhs.imag(f32, comp), rhs.toFloat(f32, comp), rhs.imag(f32, comp)) },
+ 128 => .{ .cf64 = annex_g.complexFloatMul(f64, lhs.toFloat(f64, comp), lhs.imag(f64, comp), rhs.toFloat(f64, comp), rhs.imag(f64, comp)) },
+ 160 => .{ .cf80 = annex_g.complexFloatMul(f80, lhs.toFloat(f80, comp), lhs.imag(f80, comp), rhs.toFloat(f80, comp), rhs.imag(f80, comp)) },
+ 256 => .{ .cf128 = annex_g.complexFloatMul(f128, lhs.toFloat(f128, comp), lhs.imag(f128, comp), rhs.toFloat(f128, comp), rhs.imag(f128, comp)) },
+ else => unreachable,
+ };
+ res.* = try intern(comp, .{ .complex = cf });
+ return false;
+ }
const f: Interner.Key.Float = switch (bits) {
16 => .{ .f16 = lhs.toFloat(f16, comp) * rhs.toFloat(f16, comp) },
32 => .{ .f32 = lhs.toFloat(f32, comp) * rhs.toFloat(f32, comp) },
@@ -438,6 +647,18 @@ pub fn mul(res: *Value, lhs: Value, rhs: Value, ty: Type, comp: *Compilation) !b
pub fn div(res: *Value, lhs: Value, rhs: Value, ty: Type, comp: *Compilation) !bool {
const bits: usize = @intCast(ty.bitSizeof(comp).?);
if (ty.isFloat()) {
+ if (ty.isComplex()) {
+ const cf: Interner.Key.Complex = switch (bits) {
+ 32 => .{ .cf16 = annex_g.complexFloatDiv(f16, lhs.toFloat(f16, comp), lhs.imag(f16, comp), rhs.toFloat(f16, comp), rhs.imag(f16, comp)) },
+ 64 => .{ .cf32 = annex_g.complexFloatDiv(f32, lhs.toFloat(f32, comp), lhs.imag(f32, comp), rhs.toFloat(f32, comp), rhs.imag(f32, comp)) },
+ 128 => .{ .cf64 = annex_g.complexFloatDiv(f64, lhs.toFloat(f64, comp), lhs.imag(f64, comp), rhs.toFloat(f64, comp), rhs.imag(f64, comp)) },
+ 160 => .{ .cf80 = annex_g.complexFloatDiv(f80, lhs.toFloat(f80, comp), lhs.imag(f80, comp), rhs.toFloat(f80, comp), rhs.imag(f80, comp)) },
+ 256 => .{ .cf128 = annex_g.complexFloatDiv(f128, lhs.toFloat(f128, comp), lhs.imag(f128, comp), rhs.toFloat(f128, comp), rhs.imag(f128, comp)) },
+ else => unreachable,
+ };
+ res.* = try intern(comp, .{ .complex = cf });
+ return false;
+ }
const f: Interner.Key.Float = switch (bits) {
16 => .{ .f16 = lhs.toFloat(f16, comp) / rhs.toFloat(f16, comp) },
32 => .{ .f32 = lhs.toFloat(f32, comp) / rhs.toFloat(f32, comp) },
@@ -491,11 +712,11 @@ pub fn rem(lhs: Value, rhs: Value, ty: Type, comp: *Compilation) !Value {
const signedness = ty.signedness(comp);
if (signedness == .signed) {
- var spaces: [3]BigIntSpace = undefined;
- const min_val = BigIntMutable.init(&spaces[0].limbs, ty.minInt(comp)).toConst();
- const negative = BigIntMutable.init(&spaces[1].limbs, -1).toConst();
- const big_one = BigIntMutable.init(&spaces[2].limbs, 1).toConst();
- if (lhs_bigint.eql(min_val) and rhs_bigint.eql(negative)) {
+ var spaces: [2]BigIntSpace = undefined;
+ const min_val = try Value.minInt(ty, comp);
+ const negative = BigIntMutable.init(&spaces[0].limbs, -1).toConst();
+ const big_one = BigIntMutable.init(&spaces[1].limbs, 1).toConst();
+ if (lhs.compare(.eq, min_val, comp) and rhs_bigint.eql(negative)) {
return .{};
} else if (rhs_bigint.order(big_one).compare(.lt)) {
// lhs - @divTrunc(lhs, rhs) * rhs
@@ -542,7 +763,7 @@ pub fn bitOr(lhs: Value, rhs: Value, comp: *Compilation) !Value {
@max(lhs_bigint.limbs.len, rhs_bigint.limbs.len),
);
defer comp.gpa.free(limbs);
- var result_bigint = std.math.big.int.Mutable{ .limbs = limbs, .positive = undefined, .len = undefined };
+ var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
result_bigint.bitOr(lhs_bigint, rhs_bigint);
return intern(comp, .{ .int = .{ .big_int = result_bigint.toConst() } });
@@ -554,12 +775,13 @@ pub fn bitXor(lhs: Value, rhs: Value, comp: *Compilation) !Value {
const lhs_bigint = lhs.toBigInt(&lhs_space, comp);
const rhs_bigint = rhs.toBigInt(&rhs_space, comp);
+ const extra = @intFromBool(lhs_bigint.positive != rhs_bigint.positive);
const limbs = try comp.gpa.alloc(
std.math.big.Limb,
- @max(lhs_bigint.limbs.len, rhs_bigint.limbs.len),
+ @max(lhs_bigint.limbs.len, rhs_bigint.limbs.len) + extra,
);
defer comp.gpa.free(limbs);
- var result_bigint = std.math.big.int.Mutable{ .limbs = limbs, .positive = undefined, .len = undefined };
+ var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
result_bigint.bitXor(lhs_bigint, rhs_bigint);
return intern(comp, .{ .int = .{ .big_int = result_bigint.toConst() } });
@@ -571,12 +793,18 @@ pub fn bitAnd(lhs: Value, rhs: Value, comp: *Compilation) !Value {
const lhs_bigint = lhs.toBigInt(&lhs_space, comp);
const rhs_bigint = rhs.toBigInt(&rhs_space, comp);
- const limbs = try comp.gpa.alloc(
- std.math.big.Limb,
- @max(lhs_bigint.limbs.len, rhs_bigint.limbs.len),
- );
+ const limb_count = if (lhs_bigint.positive and rhs_bigint.positive)
+ @min(lhs_bigint.limbs.len, rhs_bigint.limbs.len)
+ else if (lhs_bigint.positive)
+ lhs_bigint.limbs.len
+ else if (rhs_bigint.positive)
+ rhs_bigint.limbs.len
+ else
+ @max(lhs_bigint.limbs.len, rhs_bigint.limbs.len) + 1;
+
+ const limbs = try comp.gpa.alloc(std.math.big.Limb, limb_count);
defer comp.gpa.free(limbs);
- var result_bigint = std.math.big.int.Mutable{ .limbs = limbs, .positive = undefined, .len = undefined };
+ var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
result_bigint.bitAnd(lhs_bigint, rhs_bigint);
return intern(comp, .{ .int = .{ .big_int = result_bigint.toConst() } });
@@ -592,7 +820,7 @@ pub fn bitNot(val: Value, ty: Type, comp: *Compilation) !Value {
std.math.big.int.calcTwosCompLimbCount(bits),
);
defer comp.gpa.free(limbs);
- var result_bigint = std.math.big.int.Mutable{ .limbs = limbs, .positive = undefined, .len = undefined };
+ var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
result_bigint.bitNotWrap(val_bigint, ty.signedness(comp), bits);
return intern(comp, .{ .int = .{ .big_int = result_bigint.toConst() } });
@@ -606,9 +834,9 @@ pub fn shl(res: *Value, lhs: Value, rhs: Value, ty: Type, comp: *Compilation) !b
const bits: usize = @intCast(ty.bitSizeof(comp).?);
if (shift > bits) {
if (lhs_bigint.positive) {
- res.* = try intern(comp, .{ .int = .{ .u64 = ty.maxInt(comp) } });
+ res.* = try Value.maxInt(ty, comp);
} else {
- res.* = try intern(comp, .{ .int = .{ .i64 = ty.minInt(comp) } });
+ res.* = try Value.minInt(ty, comp);
}
return true;
}
@@ -618,7 +846,7 @@ pub fn shl(res: *Value, lhs: Value, rhs: Value, ty: Type, comp: *Compilation) !b
lhs_bigint.limbs.len + (shift / (@sizeOf(std.math.big.Limb) * 8)) + 1,
);
defer comp.gpa.free(limbs);
- var result_bigint = std.math.big.int.Mutable{ .limbs = limbs, .positive = undefined, .len = undefined };
+ var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
result_bigint.shiftLeft(lhs_bigint, shift);
const signedness = ty.signedness(comp);
@@ -652,12 +880,25 @@ pub fn shr(lhs: Value, rhs: Value, ty: Type, comp: *Compilation) !Value {
std.math.big.int.calcTwosCompLimbCount(bits),
);
defer comp.gpa.free(limbs);
- var result_bigint = std.math.big.int.Mutable{ .limbs = limbs, .positive = undefined, .len = undefined };
+ var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
result_bigint.shiftRight(lhs_bigint, shift);
return intern(comp, .{ .int = .{ .big_int = result_bigint.toConst() } });
}
+pub fn complexConj(val: Value, ty: Type, comp: *Compilation) !Value {
+ const bits = ty.bitSizeof(comp).?;
+ const cf: Interner.Key.Complex = switch (bits) {
+ 32 => .{ .cf16 = .{ val.toFloat(f16, comp), -val.imag(f16, comp) } },
+ 64 => .{ .cf32 = .{ val.toFloat(f32, comp), -val.imag(f32, comp) } },
+ 128 => .{ .cf64 = .{ val.toFloat(f64, comp), -val.imag(f64, comp) } },
+ 160 => .{ .cf80 = .{ val.toFloat(f80, comp), -val.imag(f80, comp) } },
+ 256 => .{ .cf128 = .{ val.toFloat(f128, comp), -val.imag(f128, comp) } },
+ else => unreachable,
+ };
+ return intern(comp, .{ .complex = cf });
+}
+
pub fn compare(lhs: Value, op: std.math.CompareOperator, rhs: Value, comp: *const Compilation) bool {
if (op == .eq) {
return lhs.opt_ref == rhs.opt_ref;
@@ -672,6 +913,12 @@ pub fn compare(lhs: Value, op: std.math.CompareOperator, rhs: Value, comp: *cons
const rhs_f128 = rhs.toFloat(f128, comp);
return std.math.compare(lhs_f128, op, rhs_f128);
}
+ if (lhs_key == .complex or rhs_key == .complex) {
+ assert(op == .neq);
+ const real_equal = std.math.compare(lhs.toFloat(f128, comp), .eq, rhs.toFloat(f128, comp));
+ const imag_equal = std.math.compare(lhs.imag(f128, comp), .eq, rhs.imag(f128, comp));
+ return !real_equal or !imag_equal;
+ }
var lhs_bigint_space: BigIntSpace = undefined;
var rhs_bigint_space: BigIntSpace = undefined;
@@ -680,6 +927,42 @@ pub fn compare(lhs: Value, op: std.math.CompareOperator, rhs: Value, comp: *cons
return lhs_bigint.order(rhs_bigint).compare(op);
}
+fn twosCompIntLimit(limit: std.math.big.int.TwosCompIntLimit, ty: Type, comp: *Compilation) !Value {
+ const signedness = ty.signedness(comp);
+ if (limit == .min and signedness == .unsigned) return Value.zero;
+ const mag_bits: usize = @intCast(ty.bitSizeof(comp).?);
+ switch (mag_bits) {
+ inline 8, 16, 32, 64 => |bits| {
+ if (limit == .min) return Value.int(@as(i64, std.math.minInt(std.meta.Int(.signed, bits))), comp);
+ return switch (signedness) {
+ inline else => |sign| Value.int(std.math.maxInt(std.meta.Int(sign, bits)), comp),
+ };
+ },
+ else => {},
+ }
+
+ const sign_bits = @intFromBool(signedness == .signed);
+ const total_bits = mag_bits + sign_bits;
+
+ const limbs = try comp.gpa.alloc(
+ std.math.big.Limb,
+ std.math.big.int.calcTwosCompLimbCount(total_bits),
+ );
+ defer comp.gpa.free(limbs);
+
+ var result_bigint: BigIntMutable = .{ .limbs = limbs, .positive = undefined, .len = undefined };
+ result_bigint.setTwosCompIntLimit(limit, signedness, mag_bits);
+ return Value.intern(comp, .{ .int = .{ .big_int = result_bigint.toConst() } });
+}
+
+pub fn minInt(ty: Type, comp: *Compilation) !Value {
+ return twosCompIntLimit(.min, ty, comp);
+}
+
+pub fn maxInt(ty: Type, comp: *Compilation) !Value {
+ return twosCompIntLimit(.max, ty, comp);
+}
+
pub fn print(v: Value, ty: Type, comp: *const Compilation, w: anytype) @TypeOf(w).Error!void {
if (ty.is(.bool)) {
return w.writeAll(if (v.isZero(comp)) "false" else "true");
@@ -696,6 +979,10 @@ pub fn print(v: Value, ty: Type, comp: *const Compilation, w: anytype) @TypeOf(w
inline else => |x| return w.print("{d}", .{@as(f64, @floatCast(x))}),
},
.bytes => |b| return printString(b, ty, comp, w),
+ .complex => |repr| switch (repr) {
+ .cf32 => |components| return w.print("{d} + {d}i", .{ @round(@as(f64, @floatCast(components[0])) * 1000000) / 1000000, @round(@as(f64, @floatCast(components[1])) * 1000000) / 1000000 }),
+ inline else => |components| return w.print("{d} + {d}i", .{ @as(f64, @floatCast(components[0])), @as(f64, @floatCast(components[1])) }),
+ },
else => unreachable, // not a value
}
}
@@ -703,26 +990,44 @@ pub fn print(v: Value, ty: Type, comp: *const Compilation, w: anytype) @TypeOf(w
pub fn printString(bytes: []const u8, ty: Type, comp: *const Compilation, w: anytype) @TypeOf(w).Error!void {
const size: Compilation.CharUnitSize = @enumFromInt(ty.elemType().sizeof(comp).?);
const without_null = bytes[0 .. bytes.len - @intFromEnum(size)];
+ try w.writeByte('"');
switch (size) {
- inline .@"1", .@"2" => |sz| {
- const data_slice: []const sz.Type() = @alignCast(std.mem.bytesAsSlice(sz.Type(), without_null));
- const formatter = if (sz == .@"1") std.zig.fmtEscapes(data_slice) else std.unicode.fmtUtf16Le(data_slice);
- try w.print("\"{}\"", .{formatter});
+ .@"1" => try w.print("{}", .{std.zig.fmtEscapes(without_null)}),
+ .@"2" => {
+ var items: [2]u16 = undefined;
+ var i: usize = 0;
+ while (i < without_null.len) {
+ @memcpy(std.mem.sliceAsBytes(items[0..1]), without_null[i..][0..2]);
+ i += 2;
+ const is_surrogate = std.unicode.utf16IsHighSurrogate(items[0]);
+ if (is_surrogate and i < without_null.len) {
+ @memcpy(std.mem.sliceAsBytes(items[1..2]), without_null[i..][0..2]);
+ if (std.unicode.utf16DecodeSurrogatePair(&items)) |decoded| {
+ i += 2;
+ try w.print("{u}", .{decoded});
+ } else |_| {
+ try w.print("\\x{x}", .{items[0]});
+ }
+ } else if (is_surrogate) {
+ try w.print("\\x{x}", .{items[0]});
+ } else {
+ try w.print("{u}", .{items[0]});
+ }
+ }
},
.@"4" => {
- try w.writeByte('"');
- const data_slice = std.mem.bytesAsSlice(u32, without_null);
- var buf: [4]u8 = undefined;
- for (data_slice) |item| {
- if (item <= std.math.maxInt(u21) and std.unicode.utf8ValidCodepoint(@intCast(item))) {
- const codepoint: u21 = @intCast(item);
- const written = std.unicode.utf8Encode(codepoint, &buf) catch unreachable;
- try w.print("{s}", .{buf[0..written]});
+ var item: [1]u32 = undefined;
+ const data_slice = std.mem.sliceAsBytes(item[0..1]);
+ for (0..@divExact(without_null.len, 4)) |n| {
+ @memcpy(data_slice, without_null[n * 4 ..][0..4]);
+ if (item[0] <= std.math.maxInt(u21) and std.unicode.utf8ValidCodepoint(@intCast(item[0]))) {
+ const codepoint: u21 = @intCast(item[0]);
+ try w.print("{u}", .{codepoint});
} else {
- try w.print("\\x{x}", .{item});
+ try w.print("\\x{x}", .{item[0]});
}
}
- try w.writeByte('"');
},
}
+ try w.writeByte('"');
}
diff --git a/lib/compiler/aro/aro/annex_g.zig b/lib/compiler/aro/aro/annex_g.zig
new file mode 100644
index 000000000000..56765ee3530f
--- /dev/null
+++ b/lib/compiler/aro/aro/annex_g.zig
@@ -0,0 +1,118 @@
+//! Complex arithmetic algorithms from C99 Annex G
+
+const std = @import("std");
+const copysign = std.math.copysign;
+const ilogb = std.math.ilogb;
+const inf = std.math.inf;
+const isFinite = std.math.isFinite;
+const isInf = std.math.isInf;
+const isNan = std.math.isNan;
+const isPositiveZero = std.math.isPositiveZero;
+const scalbn = std.math.scalbn;
+
+/// computes floating point z*w where a_param, b_param are real, imaginary parts of z and c_param, d_param are real, imaginary parts of w
+pub fn complexFloatMul(comptime T: type, a_param: T, b_param: T, c_param: T, d_param: T) [2]T {
+ var a = a_param;
+ var b = b_param;
+ var c = c_param;
+ var d = d_param;
+
+ const ac = a * c;
+ const bd = b * d;
+ const ad = a * d;
+ const bc = b * c;
+ var x = ac - bd;
+ var y = ad + bc;
+ if (isNan(x) and isNan(y)) {
+ var recalc = false;
+ if (isInf(a) or isInf(b)) {
+ // lhs infinite
+ // Box the infinity and change NaNs in the other factor to 0
+ a = copysign(if (isInf(a)) @as(T, 1.0) else @as(T, 0.0), a);
+ b = copysign(if (isInf(b)) @as(T, 1.0) else @as(T, 0.0), b);
+ if (isNan(c)) c = copysign(@as(T, 0.0), c);
+ if (isNan(d)) d = copysign(@as(T, 0.0), d);
+ recalc = true;
+ }
+ if (isInf(c) or isInf(d)) {
+ // rhs infinite
+ // Box the infinity and change NaNs in the other factor to 0
+ c = copysign(if (isInf(c)) @as(T, 1.0) else @as(T, 0.0), c);
+ d = copysign(if (isInf(d)) @as(T, 1.0) else @as(T, 0.0), d);
+ if (isNan(a)) a = copysign(@as(T, 0.0), a);
+ if (isNan(b)) b = copysign(@as(T, 0.0), b);
+ recalc = true;
+ }
+ if (!recalc and (isInf(ac) or isInf(bd) or isInf(ad) or isInf(bc))) {
+ // Recover infinities from overflow by changing NaN's to 0
+ if (isNan(a)) a = copysign(@as(T, 0.0), a);
+ if (isNan(b)) b = copysign(@as(T, 0.0), b);
+ if (isNan(c)) c = copysign(@as(T, 0.0), c);
+ if (isNan(d)) d = copysign(@as(T, 0.0), d);
+ }
+ if (recalc) {
+ x = inf(T) * (a * c - b * d);
+ y = inf(T) * (a * d + b * c);
+ }
+ }
+ return .{ x, y };
+}
+
+/// computes floating point z / w where a_param, b_param are real, imaginary parts of z and c_param, d_param are real, imaginary parts of w
+pub fn complexFloatDiv(comptime T: type, a_param: T, b_param: T, c_param: T, d_param: T) [2]T {
+ var a = a_param;
+ var b = b_param;
+ var c = c_param;
+ var d = d_param;
+ var denom_logb: i32 = 0;
+ const max_cd = @max(@abs(c), @abs(d));
+ if (isFinite(max_cd)) {
+ if (max_cd == 0) {
+ denom_logb = std.math.minInt(i32) + 1;
+ c = 0;
+ d = 0;
+ } else {
+ denom_logb = ilogb(max_cd);
+ c = scalbn(c, -denom_logb);
+ d = scalbn(d, -denom_logb);
+ }
+ }
+ const denom = c * c + d * d;
+ var x = scalbn((a * c + b * d) / denom, -denom_logb);
+ var y = scalbn((b * c - a * d) / denom, -denom_logb);
+ if (isNan(x) and isNan(y)) {
+ if (isPositiveZero(denom) and (!isNan(a) or !isNan(b))) {
+ x = copysign(inf(T), c) * a;
+ y = copysign(inf(T), c) * b;
+ } else if ((isInf(a) or isInf(b)) and isFinite(c) and isFinite(d)) {
+ a = copysign(if (isInf(a)) @as(T, 1.0) else @as(T, 0.0), a);
+ b = copysign(if (isInf(b)) @as(T, 1.0) else @as(T, 0.0), b);
+ x = inf(T) * (a * c + b * d);
+ y = inf(T) * (b * c - a * d);
+ } else if (isInf(max_cd) and isFinite(a) and isFinite(b)) {
+ c = copysign(if (isInf(c)) @as(T, 1.0) else @as(T, 0.0), c);
+ d = copysign(if (isInf(d)) @as(T, 1.0) else @as(T, 0.0), d);
+ x = 0.0 * (a * c + b * d);
+ y = 0.0 * (b * c - a * d);
+ }
+ }
+ return .{ x, y };
+}
+
+test complexFloatMul {
+ // Naive algorithm would produce NaN + NaNi instead of inf + NaNi
+ const result = complexFloatMul(f64, inf(f64), std.math.nan(f64), 2, 0);
+ try std.testing.expect(isInf(result[0]));
+ try std.testing.expect(isNan(result[1]));
+}
+
+test complexFloatDiv {
+ // Naive algorithm would produce NaN + NaNi instead of inf + NaNi
+ var result = complexFloatDiv(f64, inf(f64), std.math.nan(f64), 2, 0);
+ try std.testing.expect(isInf(result[0]));
+ try std.testing.expect(isNan(result[1]));
+
+ result = complexFloatDiv(f64, 2.0, 2.0, 0.0, 0.0);
+ try std.testing.expect(isInf(result[0]));
+ try std.testing.expect(isInf(result[1]));
+}
diff --git a/lib/compiler/aro/aro/features.zig b/lib/compiler/aro/aro/features.zig
index d66ba7cabc81..fdc49b722bea 100644
--- a/lib/compiler/aro/aro/features.zig
+++ b/lib/compiler/aro/aro/features.zig
@@ -45,7 +45,7 @@ pub fn hasFeature(comp: *Compilation, ext: []const u8) bool {
.c_static_assert = comp.langopts.standard.atLeast(.c11),
.c_thread_local = comp.langopts.standard.atLeast(.c11) and target_util.isTlsSupported(comp.target),
};
- inline for (std.meta.fields(@TypeOf(list))) |f| {
+ inline for (@typeInfo(@TypeOf(list)).@"struct".fields) |f| {
if (std.mem.eql(u8, f.name, ext)) return @field(list, f.name);
}
return false;
@@ -69,7 +69,7 @@ pub fn hasExtension(comp: *Compilation, ext: []const u8) bool {
.matrix_types = false, // TODO
.matrix_types_scalar_division = false, // TODO
};
- inline for (std.meta.fields(@TypeOf(list))) |f| {
+ inline for (@typeInfo(@TypeOf(list)).@"struct".fields) |f| {
if (std.mem.eql(u8, f.name, ext)) return @field(list, f.name);
}
return false;
diff --git a/lib/compiler/aro/aro/pragmas/gcc.zig b/lib/compiler/aro/aro/pragmas/gcc.zig
index 91ab750b4c81..a382f4daac75 100644
--- a/lib/compiler/aro/aro/pragmas/gcc.zig
+++ b/lib/compiler/aro/aro/pragmas/gcc.zig
@@ -19,7 +19,7 @@ pragma: Pragma = .{
.preserveTokens = preserveTokens,
},
original_options: Diagnostics.Options = .{},
-options_stack: std.ArrayListUnmanaged(Diagnostics.Options) = .{},
+options_stack: std.ArrayListUnmanaged(Diagnostics.Options) = .empty,
const Directive = enum {
warning,
diff --git a/lib/compiler/aro/aro/pragmas/pack.zig b/lib/compiler/aro/aro/pragmas/pack.zig
index 81d1dbc59a1c..24cfcc81a2a9 100644
--- a/lib/compiler/aro/aro/pragmas/pack.zig
+++ b/lib/compiler/aro/aro/pragmas/pack.zig
@@ -15,7 +15,7 @@ pragma: Pragma = .{
.parserHandler = parserHandler,
.preserveTokens = preserveTokens,
},
-stack: std.ArrayListUnmanaged(struct { label: []const u8, val: u8 }) = .{},
+stack: std.ArrayListUnmanaged(struct { label: []const u8, val: u8 }) = .empty,
pub fn init(allocator: mem.Allocator) !*Pragma {
var pack = try allocator.create(Pack);
diff --git a/lib/compiler/aro/aro/record_layout.zig b/lib/compiler/aro/aro/record_layout.zig
index 2009a29bc9ec..da0517d9fc5b 100644
--- a/lib/compiler/aro/aro/record_layout.zig
+++ b/lib/compiler/aro/aro/record_layout.zig
@@ -19,6 +19,13 @@ const OngoingBitfield = struct {
unused_size_bits: u64,
};
+pub const Error = error{Overflow};
+
+fn alignForward(addr: u64, alignment: u64) !u64 {
+ const forward_addr = try std.math.add(u64, addr, alignment - 1);
+ return std.mem.alignBackward(u64, forward_addr, alignment);
+}
+
const SysVContext = struct {
/// Does the record have an __attribute__((packed)) annotation.
attr_packed: bool,
@@ -36,14 +43,8 @@ const SysVContext = struct {
comp: *const Compilation,
fn init(ty: Type, comp: *const Compilation, pragma_pack: ?u8) SysVContext {
- var pack_value: ?u64 = null;
- if (pragma_pack) |pak| {
- pack_value = pak * BITS_PER_BYTE;
- }
- var req_align: u29 = BITS_PER_BYTE;
- if (ty.requestedAlignment(comp)) |aln| {
- req_align = aln * BITS_PER_BYTE;
- }
+ const pack_value: ?u64 = if (pragma_pack) |pak| @as(u64, pak) * BITS_PER_BYTE else null;
+ const req_align = @as(u32, (ty.requestedAlignment(comp) orelse 1)) * BITS_PER_BYTE;
return SysVContext{
.attr_packed = ty.hasAttribute(.@"packed"),
.max_field_align_bits = pack_value,
@@ -55,7 +56,7 @@ const SysVContext = struct {
};
}
- fn layoutFields(self: *SysVContext, rec: *const Record) void {
+ fn layoutFields(self: *SysVContext, rec: *const Record) !void {
for (rec.fields, 0..) |*fld, fld_indx| {
if (fld.ty.specifier == .invalid) continue;
const type_layout = computeLayout(fld.ty, self.comp);
@@ -65,12 +66,12 @@ const SysVContext = struct {
field_attrs = attrs[fld_indx];
}
if (self.comp.target.isMinGW()) {
- fld.layout = self.layoutMinGWField(fld, field_attrs, type_layout);
+ fld.layout = try self.layoutMinGWField(fld, field_attrs, type_layout);
} else {
if (fld.isRegularField()) {
- fld.layout = self.layoutRegularField(field_attrs, type_layout);
+ fld.layout = try self.layoutRegularField(field_attrs, type_layout);
} else {
- fld.layout = self.layoutBitField(field_attrs, type_layout, fld.isNamed(), fld.specifiedBitWidth());
+ fld.layout = try self.layoutBitField(field_attrs, type_layout, fld.isNamed(), fld.specifiedBitWidth());
}
}
}
@@ -99,8 +100,8 @@ const SysVContext = struct {
field: *const Field,
field_attrs: ?[]const Attribute,
field_layout: TypeLayout,
- ) FieldLayout {
- const annotation_alignment_bits = BITS_PER_BYTE * (Type.annotationAlignment(self.comp, field_attrs) orelse 1);
+ ) !FieldLayout {
+ const annotation_alignment_bits = BITS_PER_BYTE * @as(u32, (Type.annotationAlignment(self.comp, Attribute.Iterator.initSlice(field_attrs)) orelse 1));
const is_attr_packed = self.attr_packed or isPacked(field_attrs);
const ignore_type_alignment = ignoreTypeAlignment(is_attr_packed, field.bit_width, self.ongoing_bitfield, field_layout);
@@ -157,7 +158,7 @@ const SysVContext = struct {
field_alignment_bits: u64,
is_named: bool,
width: u64,
- ) FieldLayout {
+ ) !FieldLayout {
std.debug.assert(width <= ty_size_bits); // validated in parser
// In a union, the size of the underlying type does not affect the size of the union.
@@ -194,8 +195,8 @@ const SysVContext = struct {
.unused_size_bits = ty_size_bits - width,
};
}
- const offset_bits = std.mem.alignForward(u64, self.size_bits, field_alignment_bits);
- self.size_bits = if (width == 0) offset_bits else offset_bits + ty_size_bits;
+ const offset_bits = try alignForward(self.size_bits, field_alignment_bits);
+ self.size_bits = if (width == 0) offset_bits else try std.math.add(u64, offset_bits, ty_size_bits);
if (!is_named) return .{};
return .{
.offset_bits = offset_bits,
@@ -207,16 +208,16 @@ const SysVContext = struct {
self: *SysVContext,
ty_size_bits: u64,
field_alignment_bits: u64,
- ) FieldLayout {
+ ) !FieldLayout {
self.ongoing_bitfield = null;
// A struct field starts at the next offset in the struct that is properly
// aligned with respect to the start of the struct. See test case 0033.
// A union field always starts at offset 0.
- const offset_bits = if (self.is_union) 0 else std.mem.alignForward(u64, self.size_bits, field_alignment_bits);
+ const offset_bits = if (self.is_union) 0 else try alignForward(self.size_bits, field_alignment_bits);
// Set the size of the record to the maximum of the current size and the end of
// the field. See test case 0034.
- self.size_bits = @max(self.size_bits, offset_bits + ty_size_bits);
+ self.size_bits = @max(self.size_bits, try std.math.add(u64, offset_bits, ty_size_bits));
return .{
.offset_bits = offset_bits,
@@ -228,7 +229,7 @@ const SysVContext = struct {
self: *SysVContext,
fld_attrs: ?[]const Attribute,
fld_layout: TypeLayout,
- ) FieldLayout {
+ ) !FieldLayout {
var fld_align_bits = fld_layout.field_alignment_bits;
// If the struct or the field is packed, then the alignment of the underlying type is
@@ -239,8 +240,8 @@ const SysVContext = struct {
// The field alignment can be increased by __attribute__((aligned)) annotations on the
// field. See test case 0085.
- if (Type.annotationAlignment(self.comp, fld_attrs)) |anno| {
- fld_align_bits = @max(fld_align_bits, anno * BITS_PER_BYTE);
+ if (Type.annotationAlignment(self.comp, Attribute.Iterator.initSlice(fld_attrs))) |anno| {
+ fld_align_bits = @max(fld_align_bits, @as(u32, anno) * BITS_PER_BYTE);
}
// #pragma pack takes precedence over all other attributes. See test cases 0084 and
@@ -251,12 +252,12 @@ const SysVContext = struct {
// A struct field starts at the next offset in the struct that is properly
// aligned with respect to the start of the struct.
- const offset_bits = if (self.is_union) 0 else std.mem.alignForward(u64, self.size_bits, fld_align_bits);
+ const offset_bits = if (self.is_union) 0 else try alignForward(self.size_bits, fld_align_bits);
const size_bits = fld_layout.size_bits;
// The alignment of a record is the maximum of its field alignments. See test cases
// 0084, 0085, 0086.
- self.size_bits = @max(self.size_bits, offset_bits + size_bits);
+ self.size_bits = @max(self.size_bits, try std.math.add(u64, offset_bits, size_bits));
self.aligned_bits = @max(self.aligned_bits, fld_align_bits);
return .{
@@ -271,7 +272,7 @@ const SysVContext = struct {
fld_layout: TypeLayout,
is_named: bool,
bit_width: u64,
- ) FieldLayout {
+ ) !FieldLayout {
const ty_size_bits = fld_layout.size_bits;
var ty_fld_algn_bits: u32 = fld_layout.field_alignment_bits;
@@ -301,7 +302,7 @@ const SysVContext = struct {
const attr_packed = self.attr_packed or isPacked(fld_attrs);
const has_packing_annotation = attr_packed or self.max_field_align_bits != null;
- const annotation_alignment: u32 = if (Type.annotationAlignment(self.comp, fld_attrs)) |anno| anno * BITS_PER_BYTE else 1;
+ const annotation_alignment = if (Type.annotationAlignment(self.comp, Attribute.Iterator.initSlice(fld_attrs))) |anno| @as(u32, anno) * BITS_PER_BYTE else 1;
const first_unused_bit: u64 = if (self.is_union) 0 else self.size_bits;
var field_align_bits: u64 = 1;
@@ -322,7 +323,7 @@ const SysVContext = struct {
// - the alignment of the type is larger than its size,
// then it is aligned to the type's field alignment. See test case 0083.
if (!has_packing_annotation) {
- const start_bit = std.mem.alignForward(u64, first_unused_bit, field_align_bits);
+ const start_bit = try alignForward(first_unused_bit, field_align_bits);
const does_field_cross_boundary = start_bit % ty_fld_algn_bits + bit_width > ty_size_bits;
@@ -349,8 +350,8 @@ const SysVContext = struct {
}
}
- const offset_bits = std.mem.alignForward(u64, first_unused_bit, field_align_bits);
- self.size_bits = @max(self.size_bits, offset_bits + bit_width);
+ const offset_bits = try alignForward(first_unused_bit, field_align_bits);
+ self.size_bits = @max(self.size_bits, try std.math.add(u64, offset_bits, bit_width));
// Unnamed fields do not contribute to the record alignment except on a few targets.
// See test case 0079.
@@ -419,10 +420,7 @@ const MsvcContext = struct {
// The required alignment can be increased by adding a __declspec(align)
// annotation. See test case 0023.
- var must_align: u29 = BITS_PER_BYTE;
- if (ty.requestedAlignment(comp)) |req_align| {
- must_align = req_align * BITS_PER_BYTE;
- }
+ const must_align = @as(u32, (ty.requestedAlignment(comp) orelse 1)) * BITS_PER_BYTE;
return MsvcContext{
.req_align_bits = must_align,
.pointer_align_bits = must_align,
@@ -436,15 +434,15 @@ const MsvcContext = struct {
};
}
- fn layoutField(self: *MsvcContext, fld: *const Field, fld_attrs: ?[]const Attribute) FieldLayout {
+ fn layoutField(self: *MsvcContext, fld: *const Field, fld_attrs: ?[]const Attribute) !FieldLayout {
const type_layout = computeLayout(fld.ty, self.comp);
// The required alignment of the field is the maximum of the required alignment of the
// underlying type and the __declspec(align) annotation on the field itself.
// See test case 0028.
var req_align = type_layout.required_alignment_bits;
- if (Type.annotationAlignment(self.comp, fld_attrs)) |anno| {
- req_align = @max(anno * BITS_PER_BYTE, req_align);
+ if (Type.annotationAlignment(self.comp, Attribute.Iterator.initSlice(fld_attrs))) |anno| {
+ req_align = @max(@as(u32, anno) * BITS_PER_BYTE, req_align);
}
// The required alignment of a record is the maximum of the required alignments of its
@@ -480,7 +478,7 @@ const MsvcContext = struct {
}
}
- fn layoutBitField(self: *MsvcContext, ty_size_bits: u64, field_align: u32, bit_width: u32) FieldLayout {
+ fn layoutBitField(self: *MsvcContext, ty_size_bits: u64, field_align: u32, bit_width: u32) !FieldLayout {
if (bit_width == 0) {
// A zero-sized bit-field that does not follow a non-zero-sized bit-field does not affect
// the overall layout of the record. Even in a union where the order would otherwise
@@ -522,7 +520,7 @@ const MsvcContext = struct {
self.pointer_align_bits = @max(self.pointer_align_bits, p_align);
self.field_align_bits = @max(self.field_align_bits, field_align);
- const offset_bits = std.mem.alignForward(u64, self.size_bits, field_align);
+ const offset_bits = try alignForward(self.size_bits, field_align);
self.size_bits = if (bit_width == 0) offset_bits else offset_bits + ty_size_bits;
break :bits offset_bits;
@@ -534,7 +532,7 @@ const MsvcContext = struct {
return .{ .offset_bits = offset_bits, .size_bits = bit_width };
}
- fn layoutRegularField(self: *MsvcContext, size_bits: u64, field_align: u32) FieldLayout {
+ fn layoutRegularField(self: *MsvcContext, size_bits: u64, field_align: u32) !FieldLayout {
self.contains_non_bitfield = true;
self.ongoing_bitfield = null;
// The alignment of the field affects both the pointer alignment and the field
@@ -543,7 +541,7 @@ const MsvcContext = struct {
self.field_align_bits = @max(self.field_align_bits, field_align);
const offset_bits = switch (self.is_union) {
true => 0,
- false => std.mem.alignForward(u64, self.size_bits, field_align),
+ false => try alignForward(self.size_bits, field_align),
};
self.size_bits = @max(self.size_bits, offset_bits + size_bits);
return .{ .offset_bits = offset_bits, .size_bits = size_bits };
@@ -569,14 +567,14 @@ const MsvcContext = struct {
}
};
-pub fn compute(rec: *Type.Record, ty: Type, comp: *const Compilation, pragma_pack: ?u8) void {
+pub fn compute(rec: *Type.Record, ty: Type, comp: *const Compilation, pragma_pack: ?u8) Error!void {
switch (comp.langopts.emulate) {
.gcc, .clang => {
var context = SysVContext.init(ty, comp, pragma_pack);
- context.layoutFields(rec);
+ try context.layoutFields(rec);
- context.size_bits = std.mem.alignForward(u64, context.size_bits, context.aligned_bits);
+ context.size_bits = try alignForward(context.size_bits, context.aligned_bits);
rec.type_layout = .{
.size_bits = context.size_bits,
@@ -594,7 +592,7 @@ pub fn compute(rec: *Type.Record, ty: Type, comp: *const Compilation, pragma_pac
field_attrs = attrs[fld_indx];
}
- fld.layout = context.layoutField(fld, field_attrs);
+ fld.layout = try context.layoutField(fld, field_attrs);
}
if (context.size_bits == 0) {
// As an extension, MSVC allows records that only contain zero-sized bitfields and empty
@@ -602,7 +600,7 @@ pub fn compute(rec: *Type.Record, ty: Type, comp: *const Compilation, pragma_pac
// ensure that there are no zero-sized records.
context.handleZeroSizedRecord();
}
- context.size_bits = std.mem.alignForward(u64, context.size_bits, context.pointer_align_bits);
+ context.size_bits = try alignForward(context.size_bits, context.pointer_align_bits);
rec.type_layout = .{
.size_bits = context.size_bits,
.field_alignment_bits = context.field_align_bits,
diff --git a/lib/compiler/aro/aro/target.zig b/lib/compiler/aro/aro/target.zig
index 407ef4dfd01b..b84788429af3 100644
--- a/lib/compiler/aro/aro/target.zig
+++ b/lib/compiler/aro/aro/target.zig
@@ -35,10 +35,7 @@ pub fn intMaxType(target: std.Target) Type {
/// intptr_t for this target
pub fn intPtrType(target: std.Target) Type {
- switch (target.os.tag) {
- .haiku => return .{ .specifier = .long },
- else => {},
- }
+ if (target.os.tag == .haiku) return .{ .specifier = .long };
switch (target.cpu.arch) {
.aarch64, .aarch64_be => switch (target.os.tag) {
@@ -127,6 +124,14 @@ pub fn int64Type(target: std.Target) Type {
return .{ .specifier = .long_long };
}
+pub fn float80Type(target: std.Target) ?Type {
+ switch (target.cpu.arch) {
+ .x86, .x86_64 => return .{ .specifier = .long_double },
+ else => {},
+ }
+ return null;
+}
+
/// This function returns 1 if function alignment is not observable or settable.
pub fn defaultFunctionAlignment(target: std.Target) u8 {
return switch (target.cpu.arch) {
@@ -474,6 +479,7 @@ pub fn get32BitArchVariant(target: std.Target) ?std.Target {
.kalimba,
.lanai,
.wasm32,
+ .spirv,
.spirv32,
.loongarch32,
.dxil,
@@ -544,6 +550,7 @@ pub fn get64BitArchVariant(target: std.Target) ?std.Target {
.powerpcle => copy.cpu.arch = .powerpc64le,
.riscv32 => copy.cpu.arch = .riscv64,
.sparc => copy.cpu.arch = .sparc64,
+ .spirv => copy.cpu.arch = .spirv64,
.spirv32 => copy.cpu.arch = .spirv64,
.thumb => copy.cpu.arch = .aarch64,
.thumbeb => copy.cpu.arch = .aarch64_be,
@@ -599,6 +606,7 @@ pub fn toLLVMTriple(target: std.Target, buf: []u8) []const u8 {
.xtensa => "xtensa",
.nvptx => "nvptx",
.nvptx64 => "nvptx64",
+ .spirv => "spirv",
.spirv32 => "spirv32",
.spirv64 => "spirv64",
.kalimba => "kalimba",
@@ -646,9 +654,11 @@ pub fn toLLVMTriple(target: std.Target, buf: []u8) []const u8 {
.ios => "ios",
.tvos => "tvos",
.watchos => "watchos",
- .visionos => "xros",
.driverkit => "driverkit",
.shadermodel => "shadermodel",
+ .visionos => "xros",
+ .serenity => "serenity",
+ .bridgeos => "bridgeos",
.opencl,
.opengl,
.vulkan,
@@ -707,6 +717,7 @@ pub fn toLLVMTriple(target: std.Target, buf: []u8) []const u8 {
.callable => "callable",
.mesh => "mesh",
.amplification => "amplification",
+ .ohos => "openhos",
};
writer.writeAll(llvm_abi) catch unreachable;
return stream.getWritten();
diff --git a/lib/compiler/aro/aro/text_literal.zig b/lib/compiler/aro/aro/text_literal.zig
index 1c5d59298234..d9f6b2a88bc8 100644
--- a/lib/compiler/aro/aro/text_literal.zig
+++ b/lib/compiler/aro/aro/text_literal.zig
@@ -71,7 +71,7 @@ pub const Kind = enum {
pub fn maxCodepoint(kind: Kind, comp: *const Compilation) u21 {
return @intCast(switch (kind) {
.char => std.math.maxInt(u7),
- .wide => @min(0x10FFFF, comp.types.wchar.maxInt(comp)),
+ .wide => @min(0x10FFFF, comp.wcharMax()),
.utf_8 => std.math.maxInt(u7),
.utf_16 => std.math.maxInt(u16),
.utf_32 => 0x10FFFF,
@@ -83,7 +83,7 @@ pub const Kind = enum {
pub fn maxInt(kind: Kind, comp: *const Compilation) u32 {
return @intCast(switch (kind) {
.char, .utf_8 => std.math.maxInt(u8),
- .wide => comp.types.wchar.maxInt(comp),
+ .wide => comp.wcharMax(),
.utf_16 => std.math.maxInt(u16),
.utf_32 => std.math.maxInt(u32),
.unterminated => unreachable,
diff --git a/lib/compiler/aro/aro/toolchains/Linux.zig b/lib/compiler/aro/aro/toolchains/Linux.zig
index 36ab916b10fb..9666c8e3b062 100644
--- a/lib/compiler/aro/aro/toolchains/Linux.zig
+++ b/lib/compiler/aro/aro/toolchains/Linux.zig
@@ -11,7 +11,7 @@ const system_defaults = @import("system_defaults");
const Linux = @This();
distro: Distro.Tag = .unknown,
-extra_opts: std.ArrayListUnmanaged([]const u8) = .{},
+extra_opts: std.ArrayListUnmanaged([]const u8) = .empty,
gcc_detector: GCCDetector = .{},
pub fn discover(self: *Linux, tc: *Toolchain) !void {
@@ -423,7 +423,7 @@ test Linux {
defer arena_instance.deinit();
const arena = arena_instance.allocator();
- var comp = Compilation.init(std.testing.allocator);
+ var comp = Compilation.init(std.testing.allocator, std.fs.cwd());
defer comp.deinit();
comp.environment = .{
.path = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
diff --git a/lib/compiler/aro/backend/Interner.zig b/lib/compiler/aro/backend/Interner.zig
index 45b6e51fd950..818afe869116 100644
--- a/lib/compiler/aro/backend/Interner.zig
+++ b/lib/compiler/aro/backend/Interner.zig
@@ -8,14 +8,14 @@ const Limb = std.math.big.Limb;
const Interner = @This();
-map: std.AutoArrayHashMapUnmanaged(void, void) = .{},
+map: std.AutoArrayHashMapUnmanaged(void, void) = .empty,
items: std.MultiArrayList(struct {
tag: Tag,
data: u32,
}) = .{},
-extra: std.ArrayListUnmanaged(u32) = .{},
-limbs: std.ArrayListUnmanaged(Limb) = .{},
-strings: std.ArrayListUnmanaged(u8) = .{},
+extra: std.ArrayListUnmanaged(u32) = .empty,
+limbs: std.ArrayListUnmanaged(Limb) = .empty,
+strings: std.ArrayListUnmanaged(u8) = .empty,
const KeyAdapter = struct {
interner: *const Interner,
@@ -34,6 +34,7 @@ const KeyAdapter = struct {
pub const Key = union(enum) {
int_ty: u16,
float_ty: u16,
+ complex_ty: u16,
ptr_ty,
noreturn_ty,
void_ty,
@@ -62,6 +63,7 @@ pub const Key = union(enum) {
}
},
float: Float,
+ complex: Complex,
bytes: []const u8,
pub const Float = union(enum) {
@@ -71,6 +73,13 @@ pub const Key = union(enum) {
f80: f80,
f128: f128,
};
+ pub const Complex = union(enum) {
+ cf16: [2]f16,
+ cf32: [2]f32,
+ cf64: [2]f64,
+ cf80: [2]f80,
+ cf128: [2]f128,
+ };
pub fn hash(key: Key) u32 {
var hasher = Hash.init(0);
@@ -89,6 +98,12 @@ pub const Key = union(enum) {
@as(std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(data))), @bitCast(data)),
),
},
+ .complex => |repr| switch (repr) {
+ inline else => |data| std.hash.autoHash(
+ &hasher,
+ @as(std.meta.Int(.unsigned, @bitSizeOf(@TypeOf(data))), @bitCast(data)),
+ ),
+ },
.int => |repr| {
var space: Tag.Int.BigIntSpace = undefined;
const big = repr.toBigInt(&space);
@@ -154,6 +169,14 @@ pub const Key = union(enum) {
128 => return .f128,
else => unreachable,
},
+ .complex_ty => |bits| switch (bits) {
+ 16 => return .cf16,
+ 32 => return .cf32,
+ 64 => return .cf64,
+ 80 => return .cf80,
+ 128 => return .cf128,
+ else => unreachable,
+ },
.ptr_ty => return .ptr,
.func_ty => return .func,
.noreturn_ty => return .noreturn,
@@ -199,6 +222,11 @@ pub const Ref = enum(u32) {
zero = max - 16,
one = max - 17,
null = max - 18,
+ cf16 = max - 19,
+ cf32 = max - 20,
+ cf64 = max - 21,
+ cf80 = max - 22,
+ cf128 = max - 23,
_,
};
@@ -224,6 +252,11 @@ pub const OptRef = enum(u32) {
zero = max - 16,
one = max - 17,
null = max - 18,
+ cf16 = max - 19,
+ cf32 = max - 20,
+ cf64 = max - 21,
+ cf80 = max - 22,
+ cf128 = max - 23,
_,
};
@@ -232,6 +265,8 @@ pub const Tag = enum(u8) {
int_ty,
/// `data` is `u16`
float_ty,
+ /// `data` is `u16`
+ complex_ty,
/// `data` is index to `Array`
array_ty,
/// `data` is index to `Vector`
@@ -254,6 +289,16 @@ pub const Tag = enum(u8) {
f80,
/// `data` is `F128`
f128,
+ /// `data` is `CF16`
+ cf16,
+ /// `data` is `CF32`
+ cf32,
+ /// `data` is `CF64`
+ cf64,
+ /// `data` is `CF80`
+ cf80,
+ /// `data` is `CF128`
+ cf128,
/// `data` is `Bytes`
bytes,
/// `data` is `Record`
@@ -354,6 +399,134 @@ pub const Tag = enum(u8) {
}
};
+ pub const CF16 = struct {
+ piece0: u32,
+
+ pub fn get(self: CF16) [2]f16 {
+ const real: f16 = @bitCast(@as(u16, @truncate(self.piece0 >> 16)));
+ const imag: f16 = @bitCast(@as(u16, @truncate(self.piece0)));
+ return .{
+ real,
+ imag,
+ };
+ }
+
+ fn pack(val: [2]f16) CF16 {
+ const real: u16 = @bitCast(val[0]);
+ const imag: u16 = @bitCast(val[1]);
+ return .{
+ .piece0 = (@as(u32, real) << 16) | @as(u32, imag),
+ };
+ }
+ };
+
+ pub const CF32 = struct {
+ piece0: u32,
+ piece1: u32,
+
+ pub fn get(self: CF32) [2]f32 {
+ return .{
+ @bitCast(self.piece0),
+ @bitCast(self.piece1),
+ };
+ }
+
+ fn pack(val: [2]f32) CF32 {
+ return .{
+ .piece0 = @bitCast(val[0]),
+ .piece1 = @bitCast(val[1]),
+ };
+ }
+ };
+
+ pub const CF64 = struct {
+ piece0: u32,
+ piece1: u32,
+ piece2: u32,
+ piece3: u32,
+
+ pub fn get(self: CF64) [2]f64 {
+ return .{
+ (F64{ .piece0 = self.piece0, .piece1 = self.piece1 }).get(),
+ (F64{ .piece0 = self.piece2, .piece1 = self.piece3 }).get(),
+ };
+ }
+
+ fn pack(val: [2]f64) CF64 {
+ const real = F64.pack(val[0]);
+ const imag = F64.pack(val[1]);
+ return .{
+ .piece0 = real.piece0,
+ .piece1 = real.piece1,
+ .piece2 = imag.piece0,
+ .piece3 = imag.piece1,
+ };
+ }
+ };
+
+ /// TODO pack into 5 pieces
+ pub const CF80 = struct {
+ piece0: u32,
+ piece1: u32,
+ piece2: u32, // u16 part, top bits
+ piece3: u32,
+ piece4: u32,
+ piece5: u32, // u16 part, top bits
+
+ pub fn get(self: CF80) [2]f80 {
+ return .{
+ (F80{ .piece0 = self.piece0, .piece1 = self.piece1, .piece2 = self.piece2 }).get(),
+ (F80{ .piece0 = self.piece3, .piece1 = self.piece4, .piece2 = self.piece5 }).get(),
+ };
+ }
+
+ fn pack(val: [2]f80) CF80 {
+ const real = F80.pack(val[0]);
+ const imag = F80.pack(val[1]);
+ return .{
+ .piece0 = real.piece0,
+ .piece1 = real.piece1,
+ .piece2 = real.piece2,
+ .piece3 = imag.piece0,
+ .piece4 = imag.piece1,
+ .piece5 = imag.piece2,
+ };
+ }
+ };
+
+ pub const CF128 = struct {
+ piece0: u32,
+ piece1: u32,
+ piece2: u32,
+ piece3: u32,
+ piece4: u32,
+ piece5: u32,
+ piece6: u32,
+ piece7: u32,
+
+ pub fn get(self: CF128) [2]f128 {
+ return .{
+ (F128{ .piece0 = self.piece0, .piece1 = self.piece1, .piece2 = self.piece2, .piece3 = self.piece3 }).get(),
+ (F128{ .piece0 = self.piece4, .piece1 = self.piece5, .piece2 = self.piece6, .piece3 = self.piece7 }).get(),
+ };
+ }
+
+ fn pack(val: [2]f128) CF128 {
+ const real = F128.pack(val[0]);
+ const imag = F128.pack(val[1]);
+ return .{
+ .piece0 = real.piece0,
+ .piece1 = real.piece1,
+ .piece2 = real.piece2,
+ .piece3 = real.piece3,
+ .piece4 = imag.piece0,
+ .piece5 = imag.piece1,
+ .piece6 = imag.piece2,
+ .piece7 = imag.piece3,
+ };
+ }
+ };
+
pub const Bytes = struct {
strings_index: u32,
len: u32,
@@ -407,6 +580,12 @@ pub fn put(i: *Interner, gpa: Allocator, key: Key) !Ref {
.data = bits,
});
},
+ .complex_ty => |bits| {
+ i.items.appendAssumeCapacity(.{
+ .tag = .complex_ty,
+ .data = bits,
+ });
+ },
.array_ty => |info| {
const split_len = PackedU64.init(info.len);
i.items.appendAssumeCapacity(.{
@@ -493,6 +672,28 @@ pub fn put(i: *Interner, gpa: Allocator, key: Key) !Ref {
.data = try i.addExtra(gpa, Tag.F128.pack(data)),
}),
},
+ .complex => |repr| switch (repr) {
+ .cf16 => |data| i.items.appendAssumeCapacity(.{
+ .tag = .cf16,
+ .data = try i.addExtra(gpa, Tag.CF16.pack(data)),
+ }),
+ .cf32 => |data| i.items.appendAssumeCapacity(.{
+ .tag = .cf32,
+ .data = try i.addExtra(gpa, Tag.CF32.pack(data)),
+ }),
+ .cf64 => |data| i.items.appendAssumeCapacity(.{
+ .tag = .cf64,
+ .data = try i.addExtra(gpa, Tag.CF64.pack(data)),
+ }),
+ .cf80 => |data| i.items.appendAssumeCapacity(.{
+ .tag = .cf80,
+ .data = try i.addExtra(gpa, Tag.CF80.pack(data)),
+ }),
+ .cf128 => |data| i.items.appendAssumeCapacity(.{
+ .tag = .cf128,
+ .data = try i.addExtra(gpa, Tag.CF128.pack(data)),
+ }),
+ },
.bytes => |bytes| {
const strings_index: u32 = @intCast(i.strings.items.len);
try i.strings.appendSlice(gpa, bytes);
@@ -564,6 +765,10 @@ pub fn get(i: *const Interner, ref: Ref) Key {
.zero => return .{ .int = .{ .u64 = 0 } },
.one => return .{ .int = .{ .u64 = 1 } },
.null => return .null,
+ .cf16 => return .{ .complex_ty = 16 },
+ .cf32 => return .{ .complex_ty = 32 },
+ .cf64 => return .{ .complex_ty = 64 },
+ .cf80 => return .{ .complex_ty = 80 },
else => {},
}
@@ -572,6 +777,7 @@ pub fn get(i: *const Interner, ref: Ref) Key {
return switch (item.tag) {
.int_ty => .{ .int_ty = @intCast(data) },
.float_ty => .{ .float_ty = @intCast(data) },
+ .complex_ty => .{ .complex_ty = @intCast(data) },
.array_ty => {
const array_ty = i.extraData(Tag.Array, data);
return .{ .array_ty = .{
@@ -612,6 +818,26 @@ pub fn get(i: *const Interner, ref: Ref) Key {
const float = i.extraData(Tag.F128, data);
return .{ .float = .{ .f128 = float.get() } };
},
+ .cf16 => {
+ const components = i.extraData(Tag.CF16, data);
+ return .{ .complex = .{ .cf16 = components.get() } };
+ },
+ .cf32 => {
+ const components = i.extraData(Tag.CF32, data);
+ return .{ .complex = .{ .cf32 = components.get() } };
+ },
+ .cf64 => {
+ const components = i.extraData(Tag.CF64, data);
+ return .{ .complex = .{ .cf64 = components.get() } };
+ },
+ .cf80 => {
+ const components = i.extraData(Tag.CF80, data);
+ return .{ .complex = .{ .cf80 = components.get() } };
+ },
+ .cf128 => {
+ const components = i.extraData(Tag.CF128, data);
+ return .{ .complex = .{ .cf128 = components.get() } };
+ },
.bytes => {
const bytes = i.extraData(Tag.Bytes, data);
return .{ .bytes = i.strings.items[bytes.strings_index..][0..bytes.len] };
diff --git a/lib/compiler/aro/backend/Ir.zig b/lib/compiler/aro/backend/Ir.zig
index 15c153e8f178..e90bf56cbd20 100644
--- a/lib/compiler/aro/backend/Ir.zig
+++ b/lib/compiler/aro/backend/Ir.zig
@@ -26,9 +26,9 @@ pub const Builder = struct {
arena: std.heap.ArenaAllocator,
interner: *Interner,
- decls: std.StringArrayHashMapUnmanaged(Decl) = .{},
+ decls: std.StringArrayHashMapUnmanaged(Decl) = .empty,
instructions: std.MultiArrayList(Ir.Inst) = .{},
- body: std.ArrayListUnmanaged(Ref) = .{},
+ body: std.ArrayListUnmanaged(Ref) = .empty,
alloc_count: u32 = 0,
arg_count: u32 = 0,
current_label: Ref = undefined,
@@ -37,6 +37,7 @@ pub const Builder = struct {
for (b.decls.values()) |*decl| {
decl.deinit(b.gpa);
}
+ b.decls.deinit(b.gpa);
b.arena.deinit();
b.instructions.deinit(b.gpa);
b.body.deinit(b.gpa);
diff --git a/lib/compiler/aro/backend/Object.zig b/lib/compiler/aro/backend/Object.zig
index b42ad4bdcbb7..98355e88b6a0 100644
--- a/lib/compiler/aro/backend/Object.zig
+++ b/lib/compiler/aro/backend/Object.zig
@@ -16,7 +16,7 @@ pub fn create(gpa: Allocator, target: std.Target) !*Object {
pub fn deinit(obj: *Object) void {
switch (obj.format) {
- .elf => @as(*Elf, @fieldParentPtr("obj", obj)).deinit(),
+ .elf => @as(*Elf, @alignCast(@fieldParentPtr("obj", obj))).deinit(),
else => unreachable,
}
}
@@ -32,7 +32,7 @@ pub const Section = union(enum) {
pub fn getSection(obj: *Object, section: Section) !*std.ArrayList(u8) {
switch (obj.format) {
- .elf => return @as(*Elf, @fieldParentPtr("obj", obj)).getSection(section),
+ .elf => return @as(*Elf, @alignCast(@fieldParentPtr("obj", obj))).getSection(section),
else => unreachable,
}
}
@@ -53,21 +53,21 @@ pub fn declareSymbol(
size: u64,
) ![]const u8 {
switch (obj.format) {
- .elf => return @as(*Elf, @fieldParentPtr("obj", obj)).declareSymbol(section, name, linkage, @"type", offset, size),
+ .elf => return @as(*Elf, @alignCast(@fieldParentPtr("obj", obj))).declareSymbol(section, name, linkage, @"type", offset, size),
else => unreachable,
}
}
pub fn addRelocation(obj: *Object, name: []const u8, section: Section, address: u64, addend: i64) !void {
switch (obj.format) {
- .elf => return @as(*Elf, @fieldParentPtr("obj", obj)).addRelocation(name, section, address, addend),
+ .elf => return @as(*Elf, @alignCast(@fieldParentPtr("obj", obj))).addRelocation(name, section, address, addend),
else => unreachable,
}
}
pub fn finish(obj: *Object, file: std.fs.File) !void {
switch (obj.format) {
- .elf => return @as(*Elf, @fieldParentPtr("obj", obj)).finish(file),
+ .elf => return @as(*Elf, @alignCast(@fieldParentPtr("obj", obj))).finish(file),
else => unreachable,
}
}
diff --git a/lib/compiler/aro/backend/Object/Elf.zig b/lib/compiler/aro/backend/Object/Elf.zig
index 2a303d348cb7..9b4f347de575 100644
--- a/lib/compiler/aro/backend/Object/Elf.zig
+++ b/lib/compiler/aro/backend/Object/Elf.zig
@@ -5,7 +5,7 @@ const Object = @import("../Object.zig");
const Section = struct {
data: std.ArrayList(u8),
- relocations: std.ArrayListUnmanaged(Relocation) = .{},
+ relocations: std.ArrayListUnmanaged(Relocation) = .empty,
flags: u64,
type: u32,
index: u16 = undefined,
@@ -37,9 +37,9 @@ const Elf = @This();
obj: Object,
/// The keys are owned by the Codegen.tree
-sections: std.StringHashMapUnmanaged(*Section) = .{},
-local_symbols: std.StringHashMapUnmanaged(*Symbol) = .{},
-global_symbols: std.StringHashMapUnmanaged(*Symbol) = .{},
+sections: std.StringHashMapUnmanaged(*Section) = .empty,
+local_symbols: std.StringHashMapUnmanaged(*Symbol) = .empty,
+global_symbols: std.StringHashMapUnmanaged(*Symbol) = .empty,
unnamed_symbol_mangle: u32 = 0,
strtab_len: u64 = strtab_default.len,
arena: std.heap.ArenaAllocator,
diff --git a/lib/compiler/aro_translate_c.zig b/lib/compiler/aro_translate_c.zig
index 692786c2bead..910d12d32be6 100644
--- a/lib/compiler/aro_translate_c.zig
+++ b/lib/compiler/aro_translate_c.zig
@@ -16,22 +16,22 @@ const Context = @This();
gpa: mem.Allocator,
arena: mem.Allocator,
-decl_table: std.AutoArrayHashMapUnmanaged(usize, []const u8) = .{},
+decl_table: std.AutoArrayHashMapUnmanaged(usize, []const u8) = .empty,
alias_list: AliasList,
global_scope: *Scope.Root,
mangle_count: u32 = 0,
/// Table of record decls that have been demoted to opaques.
-opaque_demotes: std.AutoHashMapUnmanaged(usize, void) = .{},
+opaque_demotes: std.AutoHashMapUnmanaged(usize, void) = .empty,
/// Table of unnamed enums and records that are child types of typedefs.
-unnamed_typedefs: std.AutoHashMapUnmanaged(usize, []const u8) = .{},
+unnamed_typedefs: std.AutoHashMapUnmanaged(usize, []const u8) = .empty,
/// Needed to decide if we are parsing a typename
-typedefs: std.StringArrayHashMapUnmanaged(void) = .{},
+typedefs: std.StringArrayHashMapUnmanaged(void) = .empty,
/// This one is different than the root scope's name table. This contains
/// a list of names that we found by visiting all the top level decls without
/// translating them. The other maps are updated as we translate; this one is updated
/// up front in a pre-processing step.
-global_names: std.StringArrayHashMapUnmanaged(void) = .{},
+global_names: std.StringArrayHashMapUnmanaged(void) = .empty,
/// This is similar to `global_names`, but contains names which we would
/// *like* to use, but do not strictly *have* to if they are unavailable.
@@ -40,7 +40,7 @@ global_names: std.StringArrayHashMapUnmanaged(void) = .{},
/// may be mangled.
/// This is distinct from `global_names` so we can detect at a type
/// declaration whether or not the name is available.
-weak_global_names: std.StringArrayHashMapUnmanaged(void) = .{},
+weak_global_names: std.StringArrayHashMapUnmanaged(void) = .empty,
pattern_list: PatternList,
tree: Tree,
@@ -697,7 +697,7 @@ fn transEnumDecl(c: *Context, scope: *Scope, enum_decl: *const Type.Enum, field_
}
fn getTypeStr(c: *Context, ty: Type) ![]const u8 {
- var buf: std.ArrayListUnmanaged(u8) = .{};
+ var buf: std.ArrayListUnmanaged(u8) = .empty;
defer buf.deinit(c.gpa);
const w = buf.writer(c.gpa);
try ty.print(c.mapper, c.comp.langopts, w);
@@ -731,7 +731,6 @@ fn transType(c: *Context, scope: *Scope, raw_ty: Type, qual_handling: Type.QualH
.float => return ZigTag.type.create(c.arena, "f32"),
.double => return ZigTag.type.create(c.arena, "f64"),
.long_double => return ZigTag.type.create(c.arena, "c_longdouble"),
- .float80 => return ZigTag.type.create(c.arena, "f80"),
.float128 => return ZigTag.type.create(c.arena, "f128"),
.@"enum" => {
const enum_decl = ty.data.@"enum";
@@ -1794,12 +1793,12 @@ pub fn main() !void {
defer arena_instance.deinit();
const arena = arena_instance.allocator();
- var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .{};
+ var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .init;
const gpa = general_purpose_allocator.allocator();
const args = try std.process.argsAlloc(arena);
- var aro_comp = aro.Compilation.init(gpa);
+ var aro_comp = aro.Compilation.init(gpa, std.fs.cwd());
defer aro_comp.deinit();
var tree = translate(gpa, &aro_comp, args) catch |err| switch (err) {
diff --git a/lib/compiler/aro_translate_c/ast.zig b/lib/compiler/aro_translate_c/ast.zig
index 853fcb748cb5..8cd331d2940d 100644
--- a/lib/compiler/aro_translate_c/ast.zig
+++ b/lib/compiler/aro_translate_c/ast.zig
@@ -808,7 +808,7 @@ const Context = struct {
gpa: Allocator,
buf: std.ArrayList(u8),
nodes: std.zig.Ast.NodeList = .{},
- extra_data: std.ArrayListUnmanaged(std.zig.Ast.Node.Index) = .{},
+ extra_data: std.ArrayListUnmanaged(std.zig.Ast.Node.Index) = .empty,
tokens: std.zig.Ast.TokenList = .{},
fn addTokenFmt(c: *Context, tag: TokenTag, comptime format: []const u8, args: anytype) Allocator.Error!TokenIndex {
diff --git a/lib/compiler/build_runner.zig b/lib/compiler/build_runner.zig
index 690c93754553..4d643222d723 100644
--- a/lib/compiler/build_runner.zig
+++ b/lib/compiler/build_runner.zig
@@ -336,7 +336,7 @@ pub fn main() !void {
}
if (graph.needed_lazy_dependencies.entries.len != 0) {
- var buffer: std.ArrayListUnmanaged(u8) = .{};
+ var buffer: std.ArrayListUnmanaged(u8) = .empty;
for (graph.needed_lazy_dependencies.keys()) |k| {
try buffer.appendSlice(arena, k);
try buffer.append(arena, '\n');
@@ -1173,7 +1173,7 @@ pub fn printErrorMessages(
// Provide context for where these error messages are coming from by
// printing the corresponding Step subtree.
- var step_stack: std.ArrayListUnmanaged(*Step) = .{};
+ var step_stack: std.ArrayListUnmanaged(*Step) = .empty;
defer step_stack.deinit(gpa);
try step_stack.append(gpa, failing_step);
while (step_stack.items[step_stack.items.len - 1].dependants.items.len != 0) {
diff --git a/lib/compiler/objcopy.zig b/lib/compiler/objcopy.zig
index b48fb52e821b..ac609c94e5fc 100644
--- a/lib/compiler/objcopy.zig
+++ b/lib/compiler/objcopy.zig
@@ -15,7 +15,7 @@ pub fn main() !void {
defer arena_instance.deinit();
const arena = arena_instance.allocator();
- var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .{};
+ var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .init;
const gpa = general_purpose_allocator.allocator();
const args = try std.process.argsAlloc(arena);
diff --git a/lib/compiler/reduce.zig b/lib/compiler/reduce.zig
index ad536376da61..826c2bccf7e1 100644
--- a/lib/compiler/reduce.zig
+++ b/lib/compiler/reduce.zig
@@ -51,7 +51,7 @@ pub fn main() !void {
defer arena_instance.deinit();
const arena = arena_instance.allocator();
- var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .{};
+ var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .init;
const gpa = general_purpose_allocator.allocator();
const args = try std.process.argsAlloc(arena);
@@ -109,7 +109,7 @@ pub fn main() !void {
const root_source_file_path = opt_root_source_file_path orelse
fatal("missing root source file path argument; see -h for usage", .{});
- var interestingness_argv: std.ArrayListUnmanaged([]const u8) = .{};
+ var interestingness_argv: std.ArrayListUnmanaged([]const u8) = .empty;
try interestingness_argv.ensureUnusedCapacity(arena, argv.len + 1);
interestingness_argv.appendAssumeCapacity(checker_path);
interestingness_argv.appendSliceAssumeCapacity(argv);
diff --git a/lib/compiler/resinator/ast.zig b/lib/compiler/resinator/ast.zig
index d55d91e52c64..31250ea71e2c 100644
--- a/lib/compiler/resinator/ast.zig
+++ b/lib/compiler/resinator/ast.zig
@@ -28,7 +28,7 @@ pub const Tree = struct {
};
pub const CodePageLookup = struct {
- lookup: std.ArrayListUnmanaged(CodePage) = .{},
+ lookup: std.ArrayListUnmanaged(CodePage) = .empty,
allocator: Allocator,
default_code_page: CodePage,
diff --git a/lib/compiler/resinator/cli.zig b/lib/compiler/resinator/cli.zig
index 6aebf9a0229d..1223b069d76d 100644
--- a/lib/compiler/resinator/cli.zig
+++ b/lib/compiler/resinator/cli.zig
@@ -70,13 +70,13 @@ pub fn writeUsage(writer: anytype, command_name: []const u8) !void {
}
pub const Diagnostics = struct {
- errors: std.ArrayListUnmanaged(ErrorDetails) = .{},
+ errors: std.ArrayListUnmanaged(ErrorDetails) = .empty,
allocator: Allocator,
pub const ErrorDetails = struct {
arg_index: usize,
arg_span: ArgSpan = .{},
- msg: std.ArrayListUnmanaged(u8) = .{},
+ msg: std.ArrayListUnmanaged(u8) = .empty,
type: Type = .err,
print_args: bool = true,
@@ -132,13 +132,13 @@ pub const Options = struct {
allocator: Allocator,
input_filename: []const u8 = &[_]u8{},
output_filename: []const u8 = &[_]u8{},
- extra_include_paths: std.ArrayListUnmanaged([]const u8) = .{},
+ extra_include_paths: std.ArrayListUnmanaged([]const u8) = .empty,
ignore_include_env_var: bool = false,
preprocess: Preprocess = .yes,
default_language_id: ?u16 = null,
default_code_page: ?CodePage = null,
verbose: bool = false,
- symbols: std.StringArrayHashMapUnmanaged(SymbolValue) = .{},
+ symbols: std.StringArrayHashMapUnmanaged(SymbolValue) = .empty,
null_terminate_string_table_strings: bool = false,
max_string_literal_codepoints: u15 = lex.default_max_string_literal_codepoints,
silent_duplicate_control_ids: bool = false,
diff --git a/lib/compiler/resinator/compile.zig b/lib/compiler/resinator/compile.zig
index f9e211a4dc27..58259cf4c47a 100644
--- a/lib/compiler/resinator/compile.zig
+++ b/lib/compiler/resinator/compile.zig
@@ -3004,9 +3004,9 @@ test "limitedWriter basic usage" {
}
pub const FontDir = struct {
- fonts: std.ArrayListUnmanaged(Font) = .{},
+ fonts: std.ArrayListUnmanaged(Font) = .empty,
/// To keep track of which ids are set and where they were set from
- ids: std.AutoHashMapUnmanaged(u16, Token) = .{},
+ ids: std.AutoHashMapUnmanaged(u16, Token) = .empty,
pub const Font = struct {
id: u16,
@@ -3112,7 +3112,7 @@ pub const StringTablesByLanguage = struct {
/// when the first STRINGTABLE for the language was defined, and all blocks for a given
/// language are written contiguously.
/// Using an ArrayHashMap here gives us this property for free.
- tables: std.AutoArrayHashMapUnmanaged(res.Language, StringTable) = .{},
+ tables: std.AutoArrayHashMapUnmanaged(res.Language, StringTable) = .empty,
pub fn deinit(self: *StringTablesByLanguage, allocator: Allocator) void {
self.tables.deinit(allocator);
@@ -3143,10 +3143,10 @@ pub const StringTable = struct {
/// was added to the block (i.e. `STRINGTABLE { 16 "b" 0 "a" }` would then get written
/// with block ID 2 (the one with "b") first and block ID 1 (the one with "a") second).
/// Using an ArrayHashMap here gives us this property for free.
- blocks: std.AutoArrayHashMapUnmanaged(u16, Block) = .{},
+ blocks: std.AutoArrayHashMapUnmanaged(u16, Block) = .empty,
pub const Block = struct {
- strings: std.ArrayListUnmanaged(Token) = .{},
+ strings: std.ArrayListUnmanaged(Token) = .empty,
set_indexes: std.bit_set.IntegerBitSet(16) = .{ .mask = 0 },
memory_flags: MemoryFlags = MemoryFlags.defaults(res.RT.STRING),
characteristics: u32,
diff --git a/lib/compiler/resinator/errors.zig b/lib/compiler/resinator/errors.zig
index 90744e993419..67a5a09d3ba0 100644
--- a/lib/compiler/resinator/errors.zig
+++ b/lib/compiler/resinator/errors.zig
@@ -13,10 +13,10 @@ const builtin = @import("builtin");
const native_endian = builtin.cpu.arch.endian();
pub const Diagnostics = struct {
- errors: std.ArrayListUnmanaged(ErrorDetails) = .{},
+ errors: std.ArrayListUnmanaged(ErrorDetails) = .empty,
/// Append-only, cannot handle removing strings.
/// Expects to own all strings within the list.
- strings: std.ArrayListUnmanaged([]const u8) = .{},
+ strings: std.ArrayListUnmanaged([]const u8) = .empty,
allocator: std.mem.Allocator,
pub fn init(allocator: std.mem.Allocator) Diagnostics {
@@ -968,7 +968,7 @@ pub fn renderErrorMessage(allocator: std.mem.Allocator, writer: anytype, tty_con
const CorrespondingLines = struct {
worth_printing_note: bool = true,
worth_printing_lines: bool = true,
- lines: std.ArrayListUnmanaged(u8) = .{},
+ lines: std.ArrayListUnmanaged(u8) = .empty,
lines_is_error_message: bool = false,
pub fn init(allocator: std.mem.Allocator, cwd: std.fs.Dir, err_details: ErrorDetails, lines_for_comparison: []const u8, corresponding_span: SourceMappings.CorrespondingSpan, corresponding_file: []const u8) !CorrespondingLines {
diff --git a/lib/compiler/resinator/main.zig b/lib/compiler/resinator/main.zig
index c09801096cc2..a918081226f5 100644
--- a/lib/compiler/resinator/main.zig
+++ b/lib/compiler/resinator/main.zig
@@ -10,7 +10,7 @@ const renderErrorMessage = @import("utils.zig").renderErrorMessage;
const aro = @import("aro");
pub fn main() !void {
- var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+ var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
defer std.debug.assert(gpa.deinit() == .ok);
const allocator = gpa.allocator();
@@ -126,7 +126,7 @@ pub fn main() !void {
defer aro_arena_state.deinit();
const aro_arena = aro_arena_state.allocator();
- var comp = aro.Compilation.init(aro_arena);
+ var comp = aro.Compilation.init(aro_arena, std.fs.cwd());
defer comp.deinit();
var argv = std.ArrayList([]const u8).init(comp.gpa);
@@ -432,7 +432,7 @@ fn cliDiagnosticsToErrorBundle(
});
var cur_err: ?ErrorBundle.ErrorMessage = null;
- var cur_notes: std.ArrayListUnmanaged(ErrorBundle.ErrorMessage) = .{};
+ var cur_notes: std.ArrayListUnmanaged(ErrorBundle.ErrorMessage) = .empty;
defer cur_notes.deinit(gpa);
for (diagnostics.errors.items) |err_details| {
switch (err_details.type) {
@@ -474,10 +474,10 @@ fn diagnosticsToErrorBundle(
try bundle.init(gpa);
errdefer bundle.deinit();
- var msg_buf: std.ArrayListUnmanaged(u8) = .{};
+ var msg_buf: std.ArrayListUnmanaged(u8) = .empty;
defer msg_buf.deinit(gpa);
var cur_err: ?ErrorBundle.ErrorMessage = null;
- var cur_notes: std.ArrayListUnmanaged(ErrorBundle.ErrorMessage) = .{};
+ var cur_notes: std.ArrayListUnmanaged(ErrorBundle.ErrorMessage) = .empty;
defer cur_notes.deinit(gpa);
for (diagnostics.errors.items) |err_details| {
switch (err_details.type) {
@@ -587,7 +587,7 @@ fn aroDiagnosticsToErrorBundle(
var msg_writer = MsgWriter.init(gpa);
defer msg_writer.deinit();
var cur_err: ?ErrorBundle.ErrorMessage = null;
- var cur_notes: std.ArrayListUnmanaged(ErrorBundle.ErrorMessage) = .{};
+ var cur_notes: std.ArrayListUnmanaged(ErrorBundle.ErrorMessage) = .empty;
defer cur_notes.deinit(gpa);
for (comp.diagnostics.list.items) |msg| {
switch (msg.kind) {
diff --git a/lib/compiler/resinator/parse.zig b/lib/compiler/resinator/parse.zig
index e6fe228dcc49..3bfd7fd7e257 100644
--- a/lib/compiler/resinator/parse.zig
+++ b/lib/compiler/resinator/parse.zig
@@ -111,7 +111,7 @@ pub const Parser = struct {
/// current token is unchanged.
/// The returned slice is allocated by the parser's arena
fn parseCommonResourceAttributes(self: *Self) ![]Token {
- var common_resource_attributes = std.ArrayListUnmanaged(Token){};
+ var common_resource_attributes: std.ArrayListUnmanaged(Token) = .empty;
while (true) {
const maybe_common_resource_attribute = try self.lookaheadToken(.normal);
if (maybe_common_resource_attribute.id == .literal and rc.CommonResourceAttributes.map.has(maybe_common_resource_attribute.slice(self.lexer.buffer))) {
@@ -131,7 +131,7 @@ pub const Parser = struct {
/// current token is unchanged.
/// The returned slice is allocated by the parser's arena
fn parseOptionalStatements(self: *Self, resource: Resource) ![]*Node {
- var optional_statements = std.ArrayListUnmanaged(*Node){};
+ var optional_statements: std.ArrayListUnmanaged(*Node) = .empty;
while (true) {
const lookahead_token = try self.lookaheadToken(.normal);
if (lookahead_token.id != .literal) break;
@@ -445,7 +445,7 @@ pub const Parser = struct {
const begin_token = self.state.token;
try self.check(.begin);
- var accelerators = std.ArrayListUnmanaged(*Node){};
+ var accelerators: std.ArrayListUnmanaged(*Node) = .empty;
while (true) {
const lookahead = try self.lookaheadToken(.normal);
@@ -463,7 +463,7 @@ pub const Parser = struct {
const idvalue = try self.parseExpression(.{ .allowed_types = .{ .number = true } });
- var type_and_options = std.ArrayListUnmanaged(Token){};
+ var type_and_options: std.ArrayListUnmanaged(Token) = .empty;
while (true) {
if (!(try self.parseOptionalToken(.comma))) break;
@@ -528,7 +528,7 @@ pub const Parser = struct {
const begin_token = self.state.token;
try self.check(.begin);
- var controls = std.ArrayListUnmanaged(*Node){};
+ var controls: std.ArrayListUnmanaged(*Node) = .empty;
defer controls.deinit(self.state.allocator);
while (try self.parseControlStatement(resource)) |control_node| {
// The number of controls must fit in a u16 in order for it to
@@ -587,7 +587,7 @@ pub const Parser = struct {
const begin_token = self.state.token;
try self.check(.begin);
- var buttons = std.ArrayListUnmanaged(*Node){};
+ var buttons: std.ArrayListUnmanaged(*Node) = .empty;
defer buttons.deinit(self.state.allocator);
while (try self.parseToolbarButtonStatement()) |button_node| {
// The number of buttons must fit in a u16 in order for it to
@@ -645,7 +645,7 @@ pub const Parser = struct {
const begin_token = self.state.token;
try self.check(.begin);
- var items = std.ArrayListUnmanaged(*Node){};
+ var items: std.ArrayListUnmanaged(*Node) = .empty;
defer items.deinit(self.state.allocator);
while (try self.parseMenuItemStatement(resource, id_token, 1)) |item_node| {
try items.append(self.state.allocator, item_node);
@@ -679,7 +679,7 @@ pub const Parser = struct {
// common resource attributes must all be contiguous and come before optional-statements
const common_resource_attributes = try self.parseCommonResourceAttributes();
- var fixed_info = std.ArrayListUnmanaged(*Node){};
+ var fixed_info: std.ArrayListUnmanaged(*Node) = .empty;
while (try self.parseVersionStatement()) |version_statement| {
try fixed_info.append(self.state.arena, version_statement);
}
@@ -688,7 +688,7 @@ pub const Parser = struct {
const begin_token = self.state.token;
try self.check(.begin);
- var block_statements = std.ArrayListUnmanaged(*Node){};
+ var block_statements: std.ArrayListUnmanaged(*Node) = .empty;
while (try self.parseVersionBlockOrValue(id_token, 1)) |block_node| {
try block_statements.append(self.state.arena, block_node);
}
@@ -1064,7 +1064,7 @@ pub const Parser = struct {
_ = try self.parseOptionalToken(.comma);
- var options = std.ArrayListUnmanaged(Token){};
+ var options: std.ArrayListUnmanaged(Token) = .empty;
while (true) {
const option_token = try self.lookaheadToken(.normal);
if (!rc.MenuItem.Option.map.has(option_token.slice(self.lexer.buffer))) {
@@ -1099,7 +1099,7 @@ pub const Parser = struct {
}
try self.skipAnyCommas();
- var options = std.ArrayListUnmanaged(Token){};
+ var options: std.ArrayListUnmanaged(Token) = .empty;
while (true) {
const option_token = try self.lookaheadToken(.normal);
if (!rc.MenuItem.Option.map.has(option_token.slice(self.lexer.buffer))) {
@@ -1114,7 +1114,7 @@ pub const Parser = struct {
const begin_token = self.state.token;
try self.check(.begin);
- var items = std.ArrayListUnmanaged(*Node){};
+ var items: std.ArrayListUnmanaged(*Node) = .empty;
while (try self.parseMenuItemStatement(resource, top_level_menu_id_token, nesting_level + 1)) |item_node| {
try items.append(self.state.arena, item_node);
}
@@ -1184,7 +1184,7 @@ pub const Parser = struct {
const begin_token = self.state.token;
try self.check(.begin);
- var items = std.ArrayListUnmanaged(*Node){};
+ var items: std.ArrayListUnmanaged(*Node) = .empty;
while (try self.parseMenuItemStatement(resource, top_level_menu_id_token, nesting_level + 1)) |item_node| {
try items.append(self.state.arena, item_node);
}
@@ -1341,7 +1341,7 @@ pub const Parser = struct {
const begin_token = self.state.token;
try self.check(.begin);
- var children = std.ArrayListUnmanaged(*Node){};
+ var children: std.ArrayListUnmanaged(*Node) = .empty;
while (try self.parseVersionBlockOrValue(top_level_version_id_token, nesting_level + 1)) |value_node| {
try children.append(self.state.arena, value_node);
}
@@ -1374,7 +1374,7 @@ pub const Parser = struct {
}
fn parseBlockValuesList(self: *Self, had_comma_before_first_value: bool) Error![]*Node {
- var values = std.ArrayListUnmanaged(*Node){};
+ var values: std.ArrayListUnmanaged(*Node) = .empty;
var seen_number: bool = false;
var first_string_value: ?*Node = null;
while (true) {
diff --git a/lib/compiler/resinator/preprocess.zig b/lib/compiler/resinator/preprocess.zig
index 3d6912a7c095..c5b4b1edea54 100644
--- a/lib/compiler/resinator/preprocess.zig
+++ b/lib/compiler/resinator/preprocess.zig
@@ -59,7 +59,7 @@ pub fn preprocess(
if (hasAnyErrors(comp)) return error.PreprocessError;
- try pp.prettyPrintTokens(writer);
+ try pp.prettyPrintTokens(writer, .result_only);
if (maybe_dependencies_list) |dependencies_list| {
for (comp.sources.values()) |comp_source| {
diff --git a/lib/compiler/resinator/source_mapping.zig b/lib/compiler/resinator/source_mapping.zig
index 1144340252a5..ba396b019c89 100644
--- a/lib/compiler/resinator/source_mapping.zig
+++ b/lib/compiler/resinator/source_mapping.zig
@@ -10,7 +10,7 @@ pub const ParseLineCommandsResult = struct {
const CurrentMapping = struct {
line_num: usize = 1,
- filename: std.ArrayListUnmanaged(u8) = .{},
+ filename: std.ArrayListUnmanaged(u8) = .empty,
pending: bool = true,
ignore_contents: bool = false,
};
@@ -626,8 +626,8 @@ test "SourceMappings collapse" {
/// Same thing as StringTable in Zig's src/Wasm.zig
pub const StringTable = struct {
- data: std.ArrayListUnmanaged(u8) = .{},
- map: std.HashMapUnmanaged(u32, void, std.hash_map.StringIndexContext, std.hash_map.default_max_load_percentage) = .{},
+ data: std.ArrayListUnmanaged(u8) = .empty,
+ map: std.HashMapUnmanaged(u32, void, std.hash_map.StringIndexContext, std.hash_map.default_max_load_percentage) = .empty,
pub fn deinit(self: *StringTable, allocator: Allocator) void {
self.data.deinit(allocator);
diff --git a/lib/compiler/std-docs.zig b/lib/compiler/std-docs.zig
index 0382bbf971a3..9ed1acdc2c38 100644
--- a/lib/compiler/std-docs.zig
+++ b/lib/compiler/std-docs.zig
@@ -25,7 +25,7 @@ pub fn main() !void {
defer arena_instance.deinit();
const arena = arena_instance.allocator();
- var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .{};
+ var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .init;
const gpa = general_purpose_allocator.allocator();
var argv = try std.process.argsWithAllocator(arena);
@@ -265,7 +265,7 @@ fn buildWasmBinary(
) !Cache.Path {
const gpa = context.gpa;
- var argv: std.ArrayListUnmanaged([]const u8) = .{};
+ var argv: std.ArrayListUnmanaged([]const u8) = .empty;
try argv.appendSlice(arena, &.{
context.zig_exe_path, //
diff --git a/lib/compiler/test_runner.zig b/lib/compiler/test_runner.zig
index ac9629a57dd6..f88354623d22 100644
--- a/lib/compiler/test_runner.zig
+++ b/lib/compiler/test_runner.zig
@@ -85,7 +85,7 @@ fn mainServer() !void {
@panic("internal test runner memory leak");
};
- var string_bytes: std.ArrayListUnmanaged(u8) = .{};
+ var string_bytes: std.ArrayListUnmanaged(u8) = .empty;
defer string_bytes.deinit(testing.allocator);
try string_bytes.append(testing.allocator, 0); // Reserve 0 for null.
@@ -145,31 +145,23 @@ fn mainServer() !void {
.start_fuzzing => {
if (!builtin.fuzz) unreachable;
const index = try server.receiveBody_u32();
- var first = true;
const test_fn = builtin.test_functions[index];
- while (true) {
- testing.allocator_instance = .{};
- defer if (testing.allocator_instance.deinit() == .leak) std.process.exit(1);
- log_err_count = 0;
- is_fuzz_test = false;
- test_fn.func() catch |err| switch (err) {
- error.SkipZigTest => continue,
- else => {
- if (@errorReturnTrace()) |trace| {
- std.debug.dumpStackTrace(trace.*);
- }
- std.debug.print("failed with error.{s}\n", .{@errorName(err)});
- std.process.exit(1);
- },
- };
- if (!is_fuzz_test) @panic("missed call to std.testing.fuzzInput");
- if (log_err_count != 0) @panic("error logs detected");
- if (first) {
- first = false;
- const entry_addr = @intFromPtr(test_fn.func);
- try server.serveU64Message(.fuzz_start_addr, entry_addr);
- }
- }
+ const entry_addr = @intFromPtr(test_fn.func);
+ try server.serveU64Message(.fuzz_start_addr, entry_addr);
+ defer if (testing.allocator_instance.deinit() == .leak) std.process.exit(1);
+ is_fuzz_test = false;
+ test_fn.func() catch |err| switch (err) {
+ error.SkipZigTest => return,
+ else => {
+ if (@errorReturnTrace()) |trace| {
+ std.debug.dumpStackTrace(trace.*);
+ }
+ std.debug.print("failed with error.{s}\n", .{@errorName(err)});
+ std.process.exit(1);
+ },
+ };
+ if (!is_fuzz_test) @panic("missed call to std.testing.fuzz");
+ if (log_err_count != 0) @panic("error logs detected");
},
else => {
@@ -349,19 +341,72 @@ const FuzzerSlice = extern struct {
var is_fuzz_test: bool = undefined;
-extern fn fuzzer_next() FuzzerSlice;
+extern fn fuzzer_start(testOne: *const fn ([*]const u8, usize) callconv(.C) void) void;
extern fn fuzzer_init(cache_dir: FuzzerSlice) void;
extern fn fuzzer_coverage_id() u64;
-pub fn fuzzInput(options: testing.FuzzInputOptions) []const u8 {
+pub fn fuzz(
+ comptime testOne: fn ([]const u8) anyerror!void,
+ options: testing.FuzzInputOptions,
+) anyerror!void {
+ // Prevent this function from confusing the fuzzer by omitting its own code
+ // coverage from being considered.
@disableInstrumentation();
- if (crippled) return "";
+
+ // Some compiler backends are not capable of handling fuzz testing yet but
+ // we still want CI test coverage enabled.
+ if (crippled) return;
+
+ // Smoke test to ensure the test did not use conditional compilation to
+ // contradict itself by making it not actually be a fuzz test when the test
+ // is built in fuzz mode.
is_fuzz_test = true;
+
+ // Ensure no test failure occurred before starting fuzzing.
+ if (log_err_count != 0) @panic("error logs detected");
+
+ // libfuzzer is in a separate compilation unit so that its own code can be
+ // excluded from code coverage instrumentation. It needs a function pointer
+ // it can call for checking exactly one input. Inside this function we do
+ // our standard unit test checks such as memory leaks, and interaction with
+ // error logs.
+ const global = struct {
+ fn fuzzer_one(input_ptr: [*]const u8, input_len: usize) callconv(.C) void {
+ @disableInstrumentation();
+ testing.allocator_instance = .{};
+ defer if (testing.allocator_instance.deinit() == .leak) std.process.exit(1);
+ log_err_count = 0;
+ testOne(input_ptr[0..input_len]) catch |err| switch (err) {
+ error.SkipZigTest => return,
+ else => {
+ std.debug.lockStdErr();
+ if (@errorReturnTrace()) |trace| std.debug.dumpStackTrace(trace.*);
+ std.debug.print("failed with error.{s}\n", .{@errorName(err)});
+ std.process.exit(1);
+ },
+ };
+ if (log_err_count != 0) {
+ std.debug.lockStdErr();
+ std.debug.print("error logs detected\n", .{});
+ std.process.exit(1);
+ }
+ }
+ };
if (builtin.fuzz) {
- return fuzzer_next().toSlice();
+ const prev_allocator_state = testing.allocator_instance;
+ testing.allocator_instance = .{};
+ fuzzer_start(&global.fuzzer_one);
+ testing.allocator_instance = prev_allocator_state;
+ return;
}
- if (options.corpus.len == 0) return "";
- var prng = std.Random.DefaultPrng.init(testing.random_seed);
- const random = prng.random();
- return options.corpus[random.uintLessThan(usize, options.corpus.len)];
+
+ // When the unit test executable is not built in fuzz mode, only run the
+ // provided corpus.
+ for (options.corpus) |input| {
+ try testOne(input);
+ }
+
+ // In case there is no provided corpus, also use an empty
+ // string as a smoke test.
+ try testOne("");
}
diff --git a/lib/compiler_rt/common.zig b/lib/compiler_rt/common.zig
index 1dfd4be07f7c..63fc48cbed95 100644
--- a/lib/compiler_rt/common.zig
+++ b/lib/compiler_rt/common.zig
@@ -1,8 +1,14 @@
const std = @import("std");
const builtin = @import("builtin");
const native_endian = builtin.cpu.arch.endian();
+const ofmt_c = builtin.object_format == .c;
-pub const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .internal else .weak;
+pub const linkage: std.builtin.GlobalLinkage = if (builtin.is_test)
+ .internal
+else if (ofmt_c)
+ .strong
+else
+ .weak;
/// Determines the symbol's visibility to other objects.
/// For WebAssembly this allows the symbol to be resolved to other modules, but will not
/// export it to the host runtime.
@@ -28,7 +34,7 @@ pub const want_float_exceptions = !builtin.cpu.arch.isWasm();
// Libcalls that involve u128 on Windows x86-64 are expected by LLVM to use the
// calling convention of @Vector(2, u64), rather than what's standard.
-pub const want_windows_v2u64_abi = builtin.os.tag == .windows and builtin.cpu.arch == .x86_64 and @import("builtin").object_format != .c;
+pub const want_windows_v2u64_abi = builtin.os.tag == .windows and builtin.cpu.arch == .x86_64 and !ofmt_c;
/// This governs whether to use these symbol names for f16/f32 conversions
/// rather than the standard names:
diff --git a/lib/compiler_rt/truncdfhf2.zig b/lib/compiler_rt/truncdfhf2.zig
index e15a2202a165..10f13d504788 100644
--- a/lib/compiler_rt/truncdfhf2.zig
+++ b/lib/compiler_rt/truncdfhf2.zig
@@ -6,9 +6,8 @@ pub const panic = common.panic;
comptime {
if (common.want_aeabi) {
@export(&__aeabi_d2h, .{ .name = "__aeabi_d2h", .linkage = common.linkage, .visibility = common.visibility });
- } else {
- @export(&__truncdfhf2, .{ .name = "__truncdfhf2", .linkage = common.linkage, .visibility = common.visibility });
}
+ @export(&__truncdfhf2, .{ .name = "__truncdfhf2", .linkage = common.linkage, .visibility = common.visibility });
}
pub fn __truncdfhf2(a: f64) callconv(.C) common.F16T(f64) {
diff --git a/lib/docs/wasm/Walk.zig b/lib/docs/wasm/Walk.zig
index 611830fcb89d..49a5e738fc20 100644
--- a/lib/docs/wasm/Walk.zig
+++ b/lib/docs/wasm/Walk.zig
@@ -10,9 +10,9 @@ const Oom = error{OutOfMemory};
pub const Decl = @import("Decl.zig");
-pub var files: std.StringArrayHashMapUnmanaged(File) = .{};
-pub var decls: std.ArrayListUnmanaged(Decl) = .{};
-pub var modules: std.StringArrayHashMapUnmanaged(File.Index) = .{};
+pub var files: std.StringArrayHashMapUnmanaged(File) = .empty;
+pub var decls: std.ArrayListUnmanaged(Decl) = .empty;
+pub var modules: std.StringArrayHashMapUnmanaged(File.Index) = .empty;
file: File.Index,
@@ -42,17 +42,17 @@ pub const Category = union(enum(u8)) {
pub const File = struct {
ast: Ast,
/// Maps identifiers to the declarations they point to.
- ident_decls: std.AutoArrayHashMapUnmanaged(Ast.TokenIndex, Ast.Node.Index) = .{},
+ ident_decls: std.AutoArrayHashMapUnmanaged(Ast.TokenIndex, Ast.Node.Index) = .empty,
/// Maps field access identifiers to the containing field access node.
- token_parents: std.AutoArrayHashMapUnmanaged(Ast.TokenIndex, Ast.Node.Index) = .{},
+ token_parents: std.AutoArrayHashMapUnmanaged(Ast.TokenIndex, Ast.Node.Index) = .empty,
/// Maps declarations to their global index.
- node_decls: std.AutoArrayHashMapUnmanaged(Ast.Node.Index, Decl.Index) = .{},
+ node_decls: std.AutoArrayHashMapUnmanaged(Ast.Node.Index, Decl.Index) = .empty,
/// Maps function declarations to doctests.
- doctests: std.AutoArrayHashMapUnmanaged(Ast.Node.Index, Ast.Node.Index) = .{},
+ doctests: std.AutoArrayHashMapUnmanaged(Ast.Node.Index, Ast.Node.Index) = .empty,
/// root node => its namespace scope
/// struct/union/enum/opaque decl node => its namespace scope
/// local var decl node => its local variable scope
- scopes: std.AutoArrayHashMapUnmanaged(Ast.Node.Index, *Scope) = .{},
+ scopes: std.AutoArrayHashMapUnmanaged(Ast.Node.Index, *Scope) = .empty,
pub fn lookup_token(file: *File, token: Ast.TokenIndex) Decl.Index {
const decl_node = file.ident_decls.get(token) orelse return .none;
@@ -464,8 +464,8 @@ pub const Scope = struct {
const Namespace = struct {
base: Scope = .{ .tag = .namespace },
parent: *Scope,
- names: std.StringArrayHashMapUnmanaged(Ast.Node.Index) = .{},
- doctests: std.StringArrayHashMapUnmanaged(Ast.Node.Index) = .{},
+ names: std.StringArrayHashMapUnmanaged(Ast.Node.Index) = .empty,
+ doctests: std.StringArrayHashMapUnmanaged(Ast.Node.Index) = .empty,
decl_index: Decl.Index,
};
diff --git a/lib/docs/wasm/html_render.zig b/lib/docs/wasm/html_render.zig
index a5211fc77f4d..d9cb74f152e8 100644
--- a/lib/docs/wasm/html_render.zig
+++ b/lib/docs/wasm/html_render.zig
@@ -38,7 +38,7 @@ pub fn fileSourceHtml(
const file = file_index.get();
const g = struct {
- var field_access_buffer: std.ArrayListUnmanaged(u8) = .{};
+ var field_access_buffer: std.ArrayListUnmanaged(u8) = .empty;
};
const token_tags = ast.tokens.items(.tag);
diff --git a/lib/docs/wasm/main.zig b/lib/docs/wasm/main.zig
index 55882aaf7df5..0ec222751283 100644
--- a/lib/docs/wasm/main.zig
+++ b/lib/docs/wasm/main.zig
@@ -60,8 +60,8 @@ export fn unpack(tar_ptr: [*]u8, tar_len: usize) void {
};
}
-var query_string: std.ArrayListUnmanaged(u8) = .{};
-var query_results: std.ArrayListUnmanaged(Decl.Index) = .{};
+var query_string: std.ArrayListUnmanaged(u8) = .empty;
+var query_results: std.ArrayListUnmanaged(Decl.Index) = .empty;
/// Resizes the query string to be the correct length; returns the pointer to
/// the query string.
@@ -93,11 +93,11 @@ fn query_exec_fallible(query: []const u8, ignore_case: bool) !void {
segments: u16,
};
const g = struct {
- var full_path_search_text: std.ArrayListUnmanaged(u8) = .{};
- var full_path_search_text_lower: std.ArrayListUnmanaged(u8) = .{};
- var doc_search_text: std.ArrayListUnmanaged(u8) = .{};
+ var full_path_search_text: std.ArrayListUnmanaged(u8) = .empty;
+ var full_path_search_text_lower: std.ArrayListUnmanaged(u8) = .empty;
+ var doc_search_text: std.ArrayListUnmanaged(u8) = .empty;
/// Each element matches a corresponding query_results element.
- var scores: std.ArrayListUnmanaged(Score) = .{};
+ var scores: std.ArrayListUnmanaged(Score) = .empty;
};
// First element stores the size of the list.
@@ -255,8 +255,8 @@ const ErrorIdentifier = packed struct(u64) {
}
};
-var string_result: std.ArrayListUnmanaged(u8) = .{};
-var error_set_result: std.StringArrayHashMapUnmanaged(ErrorIdentifier) = .{};
+var string_result: std.ArrayListUnmanaged(u8) = .empty;
+var error_set_result: std.StringArrayHashMapUnmanaged(ErrorIdentifier) = .empty;
export fn decl_error_set(decl_index: Decl.Index) Slice(ErrorIdentifier) {
return Slice(ErrorIdentifier).init(decl_error_set_fallible(decl_index) catch @panic("OOM"));
@@ -381,7 +381,7 @@ export fn decl_params(decl_index: Decl.Index) Slice(Ast.Node.Index) {
fn decl_fields_fallible(decl_index: Decl.Index) ![]Ast.Node.Index {
const g = struct {
- var result: std.ArrayListUnmanaged(Ast.Node.Index) = .{};
+ var result: std.ArrayListUnmanaged(Ast.Node.Index) = .empty;
};
g.result.clearRetainingCapacity();
const decl = decl_index.get();
@@ -403,7 +403,7 @@ fn decl_fields_fallible(decl_index: Decl.Index) ![]Ast.Node.Index {
fn decl_params_fallible(decl_index: Decl.Index) ![]Ast.Node.Index {
const g = struct {
- var result: std.ArrayListUnmanaged(Ast.Node.Index) = .{};
+ var result: std.ArrayListUnmanaged(Ast.Node.Index) = .empty;
};
g.result.clearRetainingCapacity();
const decl = decl_index.get();
@@ -672,7 +672,7 @@ fn render_docs(
defer parsed_doc.deinit(gpa);
const g = struct {
- var link_buffer: std.ArrayListUnmanaged(u8) = .{};
+ var link_buffer: std.ArrayListUnmanaged(u8) = .empty;
};
const Writer = std.ArrayListUnmanaged(u8).Writer;
@@ -817,7 +817,7 @@ export fn find_module_root(pkg: Walk.ModuleIndex) Decl.Index {
}
/// Set by `set_input_string`.
-var input_string: std.ArrayListUnmanaged(u8) = .{};
+var input_string: std.ArrayListUnmanaged(u8) = .empty;
export fn set_input_string(len: usize) [*]u8 {
input_string.resize(gpa, len) catch @panic("OOM");
@@ -839,7 +839,7 @@ export fn find_decl() Decl.Index {
if (result != .none) return result;
const g = struct {
- var match_fqn: std.ArrayListUnmanaged(u8) = .{};
+ var match_fqn: std.ArrayListUnmanaged(u8) = .empty;
};
for (Walk.decls.items, 0..) |*decl, decl_index| {
g.match_fqn.clearRetainingCapacity();
@@ -888,7 +888,7 @@ export fn type_fn_members(parent: Decl.Index, include_private: bool) Slice(Decl.
export fn namespace_members(parent: Decl.Index, include_private: bool) Slice(Decl.Index) {
const g = struct {
- var members: std.ArrayListUnmanaged(Decl.Index) = .{};
+ var members: std.ArrayListUnmanaged(Decl.Index) = .empty;
};
g.members.clearRetainingCapacity();
diff --git a/lib/docs/wasm/markdown/Parser.zig b/lib/docs/wasm/markdown/Parser.zig
index 024a16a2d7a3..32c172968456 100644
--- a/lib/docs/wasm/markdown/Parser.zig
+++ b/lib/docs/wasm/markdown/Parser.zig
@@ -31,11 +31,11 @@ const ExtraData = Document.ExtraData;
const StringIndex = Document.StringIndex;
nodes: Node.List = .{},
-extra: std.ArrayListUnmanaged(u32) = .{},
-scratch_extra: std.ArrayListUnmanaged(u32) = .{},
-string_bytes: std.ArrayListUnmanaged(u8) = .{},
-scratch_string: std.ArrayListUnmanaged(u8) = .{},
-pending_blocks: std.ArrayListUnmanaged(Block) = .{},
+extra: std.ArrayListUnmanaged(u32) = .empty,
+scratch_extra: std.ArrayListUnmanaged(u32) = .empty,
+string_bytes: std.ArrayListUnmanaged(u8) = .empty,
+scratch_string: std.ArrayListUnmanaged(u8) = .empty,
+pending_blocks: std.ArrayListUnmanaged(Block) = .empty,
allocator: Allocator,
const Parser = @This();
@@ -928,8 +928,8 @@ const InlineParser = struct {
parent: *Parser,
content: []const u8,
pos: usize = 0,
- pending_inlines: std.ArrayListUnmanaged(PendingInline) = .{},
- completed_inlines: std.ArrayListUnmanaged(CompletedInline) = .{},
+ pending_inlines: std.ArrayListUnmanaged(PendingInline) = .empty,
+ completed_inlines: std.ArrayListUnmanaged(CompletedInline) = .empty,
const PendingInline = struct {
tag: Tag,
diff --git a/lib/fuzzer.zig b/lib/fuzzer.zig
index 9c67756a6d97..d8f405dccb29 100644
--- a/lib/fuzzer.zig
+++ b/lib/fuzzer.zig
@@ -28,7 +28,8 @@ fn logOverride(
f.writer().print(prefix1 ++ prefix2 ++ format ++ "\n", args) catch @panic("failed to write to fuzzer log");
}
-export threadlocal var __sancov_lowest_stack: usize = std.math.maxInt(usize);
+/// Helps determine run uniqueness in the face of recursion.
+export threadlocal var __sancov_lowest_stack: usize = 0;
export fn __sanitizer_cov_trace_const_cmp1(arg1: u8, arg2: u8) void {
handleCmp(@returnAddress(), arg1, arg2);
@@ -220,7 +221,6 @@ const Fuzzer = struct {
.n_runs = 0,
.unique_runs = 0,
.pcs_len = pcs.len,
- .lowest_stack = std.math.maxInt(usize),
};
f.seen_pcs.appendSliceAssumeCapacity(std.mem.asBytes(&header));
f.seen_pcs.appendNTimesAssumeCapacity(0, n_bitset_elems * @sizeOf(usize));
@@ -235,22 +235,41 @@ const Fuzzer = struct {
};
}
- fn next(f: *Fuzzer) ![]const u8 {
+ fn start(f: *Fuzzer) !void {
const gpa = f.gpa;
const rng = fuzzer.rng.random();
- if (f.recent_cases.entries.len == 0) {
- // Prepare initial input.
- try f.recent_cases.ensureUnusedCapacity(gpa, 100);
- const len = rng.uintLessThanBiased(usize, 80);
- try f.input.resize(gpa, len);
- rng.bytes(f.input.items);
- f.recent_cases.putAssumeCapacity(.{
- .id = 0,
- .input = try gpa.dupe(u8, f.input.items),
- .score = 0,
- }, {});
- } else {
+ // Prepare initial input.
+ assert(f.recent_cases.entries.len == 0);
+ assert(f.n_runs == 0);
+ try f.recent_cases.ensureUnusedCapacity(gpa, 100);
+ const len = rng.uintLessThanBiased(usize, 80);
+ try f.input.resize(gpa, len);
+ rng.bytes(f.input.items);
+ f.recent_cases.putAssumeCapacity(.{
+ .id = 0,
+ .input = try gpa.dupe(u8, f.input.items),
+ .score = 0,
+ }, {});
+
+ const header: *volatile SeenPcsHeader = @ptrCast(f.seen_pcs.items[0..@sizeOf(SeenPcsHeader)]);
+
+ while (true) {
+ const chosen_index = rng.uintLessThanBiased(usize, f.recent_cases.entries.len);
+ const run = &f.recent_cases.keys()[chosen_index];
+ f.input.clearRetainingCapacity();
+ f.input.appendSliceAssumeCapacity(run.input);
+ try f.mutate();
+
+ @memset(f.pc_counters, 0);
+ __sancov_lowest_stack = std.math.maxInt(usize);
+ f.coverage.reset();
+
+ fuzzer_one(f.input.items.ptr, f.input.items.len);
+
+ f.n_runs += 1;
+ _ = @atomicRmw(usize, &header.n_runs, .Add, 1, .monotonic);
+
if (f.n_runs % 10000 == 0) f.dumpStats();
const analysis = f.analyzeLastRun();
@@ -301,7 +320,6 @@ const Fuzzer = struct {
}
}
- const header: *volatile SeenPcsHeader = @ptrCast(f.seen_pcs.items[0..@sizeOf(SeenPcsHeader)]);
_ = @atomicRmw(usize, &header.unique_runs, .Add, 1, .monotonic);
}
@@ -317,26 +335,12 @@ const Fuzzer = struct {
// This has to be done before deinitializing the deleted items.
const doomed_runs = f.recent_cases.keys()[cap..];
f.recent_cases.shrinkRetainingCapacity(cap);
- for (doomed_runs) |*run| {
- std.log.info("culling score={d} id={d}", .{ run.score, run.id });
- run.deinit(gpa);
+ for (doomed_runs) |*doomed_run| {
+ std.log.info("culling score={d} id={d}", .{ doomed_run.score, doomed_run.id });
+ doomed_run.deinit(gpa);
}
}
}
-
- const chosen_index = rng.uintLessThanBiased(usize, f.recent_cases.entries.len);
- const run = &f.recent_cases.keys()[chosen_index];
- f.input.clearRetainingCapacity();
- f.input.appendSliceAssumeCapacity(run.input);
- try f.mutate();
-
- f.n_runs += 1;
- const header: *volatile SeenPcsHeader = @ptrCast(f.seen_pcs.items[0..@sizeOf(SeenPcsHeader)]);
- _ = @atomicRmw(usize, &header.n_runs, .Add, 1, .monotonic);
- _ = @atomicRmw(usize, &header.lowest_stack, .Min, __sancov_lowest_stack, .monotonic);
- @memset(f.pc_counters, 0);
- f.coverage.reset();
- return f.input.items;
}
fn visitPc(f: *Fuzzer, pc: usize) void {
@@ -398,7 +402,7 @@ fn oom(err: anytype) noreturn {
}
}
-var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .{};
+var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .init;
var fuzzer: Fuzzer = .{
.gpa = general_purpose_allocator.allocator(),
@@ -419,10 +423,13 @@ export fn fuzzer_coverage_id() u64 {
return fuzzer.coverage_id;
}
-export fn fuzzer_next() Fuzzer.Slice {
- return Fuzzer.Slice.fromZig(fuzzer.next() catch |err| switch (err) {
- error.OutOfMemory => @panic("out of memory"),
- });
+var fuzzer_one: *const fn (input_ptr: [*]const u8, input_len: usize) callconv(.C) void = undefined;
+
+export fn fuzzer_start(testOne: @TypeOf(fuzzer_one)) void {
+ fuzzer_one = testOne;
+ fuzzer.start() catch |err| switch (err) {
+ error.OutOfMemory => fatal("out of memory", .{}),
+ };
}
export fn fuzzer_init(cache_dir_struct: Fuzzer.Slice) void {
@@ -432,24 +439,24 @@ export fn fuzzer_init(cache_dir_struct: Fuzzer.Slice) void {
const pc_counters_start = @extern([*]u8, .{
.name = "__start___sancov_cntrs",
.linkage = .weak,
- }) orelse fatal("missing __start___sancov_cntrs symbol");
+ }) orelse fatal("missing __start___sancov_cntrs symbol", .{});
const pc_counters_end = @extern([*]u8, .{
.name = "__stop___sancov_cntrs",
.linkage = .weak,
- }) orelse fatal("missing __stop___sancov_cntrs symbol");
+ }) orelse fatal("missing __stop___sancov_cntrs symbol", .{});
const pc_counters = pc_counters_start[0 .. pc_counters_end - pc_counters_start];
const pcs_start = @extern([*]usize, .{
.name = "__start___sancov_pcs1",
.linkage = .weak,
- }) orelse fatal("missing __start___sancov_pcs1 symbol");
+ }) orelse fatal("missing __start___sancov_pcs1 symbol", .{});
const pcs_end = @extern([*]usize, .{
.name = "__stop___sancov_pcs1",
.linkage = .weak,
- }) orelse fatal("missing __stop___sancov_pcs1 symbol");
+ }) orelse fatal("missing __stop___sancov_pcs1 symbol", .{});
const pcs = pcs_start[0 .. pcs_end - pcs_start];
diff --git a/lib/fuzzer/index.html b/lib/fuzzer/web/index.html
similarity index 98%
rename from lib/fuzzer/index.html
rename to lib/fuzzer/web/index.html
index 16fa87991377..325342e8ebf5 100644
--- a/lib/fuzzer/index.html
+++ b/lib/fuzzer/web/index.html
@@ -146,8 +146,8 @@
- Total Runs:
- Unique Runs:
+ - Speed (Runs/Second):
- Coverage:
- - Lowest Stack:
- Entry Points:
diff --git a/lib/fuzzer/main.js b/lib/fuzzer/web/main.js
similarity index 97%
rename from lib/fuzzer/main.js
rename to lib/fuzzer/web/main.js
index ce02276f9819..94f09391bb67 100644
--- a/lib/fuzzer/main.js
+++ b/lib/fuzzer/web/main.js
@@ -5,8 +5,8 @@
const domSourceText = document.getElementById("sourceText");
const domStatTotalRuns = document.getElementById("statTotalRuns");
const domStatUniqueRuns = document.getElementById("statUniqueRuns");
+ const domStatSpeed = document.getElementById("statSpeed");
const domStatCoverage = document.getElementById("statCoverage");
- const domStatLowestStack = document.getElementById("statLowestStack");
const domEntryPointsList = document.getElementById("entryPointsList");
let wasm_promise = fetch("main.wasm");
@@ -32,6 +32,9 @@
const msg = decodeString(ptr, len);
throw new Error("panic: " + msg);
},
+ timestamp: function () {
+ return BigInt(new Date());
+ },
emitSourceIndexChange: onSourceIndexChange,
emitCoverageUpdate: onCoverageUpdate,
emitEntryPointsUpdate: renderStats,
@@ -158,7 +161,7 @@
domStatTotalRuns.innerText = totalRuns;
domStatUniqueRuns.innerText = uniqueRuns + " (" + percent(uniqueRuns, totalRuns) + "%)";
domStatCoverage.innerText = coveredSourceLocations + " / " + totalSourceLocations + " (" + percent(coveredSourceLocations, totalSourceLocations) + "%)";
- domStatLowestStack.innerText = unwrapString(wasm_exports.lowestStack());
+ domStatSpeed.innerText = wasm_exports.totalRunsPerSecond().toFixed(0);
const entryPoints = unwrapInt32Array(wasm_exports.entryPoints());
resizeDomList(domEntryPointsList, entryPoints.length, "");
diff --git a/lib/fuzzer/wasm/main.zig b/lib/fuzzer/web/main.zig
similarity index 90%
rename from lib/fuzzer/wasm/main.zig
rename to lib/fuzzer/web/main.zig
index 342adc3b5608..c6d6810e1b95 100644
--- a/lib/fuzzer/wasm/main.zig
+++ b/lib/fuzzer/web/main.zig
@@ -10,9 +10,17 @@ const Walk = @import("Walk");
const Decl = Walk.Decl;
const html_render = @import("html_render");
+/// Nanoseconds.
+var server_base_timestamp: i64 = 0;
+/// Milliseconds.
+var client_base_timestamp: i64 = 0;
+/// Relative to `server_base_timestamp`.
+var start_fuzzing_timestamp: i64 = undefined;
+
const js = struct {
extern "js" fn log(ptr: [*]const u8, len: usize) void;
extern "js" fn panic(ptr: [*]const u8, len: usize) noreturn;
+ extern "js" fn timestamp() i64;
extern "js" fn emitSourceIndexChange() void;
extern "js" fn emitCoverageUpdate() void;
extern "js" fn emitEntryPointsUpdate() void;
@@ -50,7 +58,7 @@ export fn alloc(n: usize) [*]u8 {
return slice.ptr;
}
-var message_buffer: std.ArrayListAlignedUnmanaged(u8, @alignOf(u64)) = .{};
+var message_buffer: std.ArrayListAlignedUnmanaged(u8, @alignOf(u64)) = .empty;
/// Resizes the message buffer to be the correct length; returns the pointer to
/// the query string.
@@ -64,6 +72,7 @@ export fn message_end() void {
const tag: abi.ToClientTag = @enumFromInt(msg_bytes[0]);
switch (tag) {
+ .current_time => return currentTimeMessage(msg_bytes),
.source_index => return sourceIndexMessage(msg_bytes) catch @panic("OOM"),
.coverage_update => return coverageUpdateMessage(msg_bytes) catch @panic("OOM"),
.entry_points => return entryPointsMessage(msg_bytes) catch @panic("OOM"),
@@ -81,8 +90,8 @@ export fn unpack(tar_ptr: [*]u8, tar_len: usize) void {
}
/// Set by `set_input_string`.
-var input_string: std.ArrayListUnmanaged(u8) = .{};
-var string_result: std.ArrayListUnmanaged(u8) = .{};
+var input_string: std.ArrayListUnmanaged(u8) = .empty;
+var string_result: std.ArrayListUnmanaged(u8) = .empty;
export fn set_input_string(len: usize) [*]u8 {
input_string.resize(gpa, len) catch @panic("OOM");
@@ -106,13 +115,6 @@ export fn decl_source_html(decl_index: Decl.Index) String {
return String.init(string_result.items);
}
-export fn lowestStack() String {
- const header: *abi.CoverageUpdateHeader = @ptrCast(recent_coverage_update.items[0..@sizeOf(abi.CoverageUpdateHeader)]);
- string_result.clearRetainingCapacity();
- string_result.writer(gpa).print("0x{d}", .{header.lowest_stack}) catch @panic("OOM");
- return String.init(string_result.items);
-}
-
export fn totalSourceLocations() usize {
return coverage_source_locations.items.len;
}
@@ -124,16 +126,28 @@ export fn coveredSourceLocations() usize {
return count;
}
+fn getCoverageUpdateHeader() *abi.CoverageUpdateHeader {
+ return @alignCast(@ptrCast(recent_coverage_update.items[0..@sizeOf(abi.CoverageUpdateHeader)]));
+}
+
export fn totalRuns() u64 {
- const header: *abi.CoverageUpdateHeader = @alignCast(@ptrCast(recent_coverage_update.items[0..@sizeOf(abi.CoverageUpdateHeader)]));
+ const header = getCoverageUpdateHeader();
return header.n_runs;
}
export fn uniqueRuns() u64 {
- const header: *abi.CoverageUpdateHeader = @alignCast(@ptrCast(recent_coverage_update.items[0..@sizeOf(abi.CoverageUpdateHeader)]));
+ const header = getCoverageUpdateHeader();
return header.unique_runs;
}
+export fn totalRunsPerSecond() f64 {
+ @setFloatMode(.optimized);
+ const header = getCoverageUpdateHeader();
+ const ns_elapsed: f64 = @floatFromInt(nsSince(start_fuzzing_timestamp));
+ const n_runs: f64 = @floatFromInt(header.n_runs);
+ return n_runs / (ns_elapsed / std.time.ns_per_s);
+}
+
const String = Slice(u8);
fn Slice(T: type) type {
@@ -196,6 +210,18 @@ fn fatal(comptime format: []const u8, args: anytype) noreturn {
js.panic(line.ptr, line.len);
}
+fn currentTimeMessage(msg_bytes: []u8) void {
+ client_base_timestamp = js.timestamp();
+ server_base_timestamp = @bitCast(msg_bytes[1..][0..8].*);
+}
+
+/// Nanoseconds passed since a server timestamp.
+fn nsSince(server_timestamp: i64) i64 {
+ const ms_passed = js.timestamp() - client_base_timestamp;
+ const ns_passed = server_base_timestamp - server_timestamp;
+ return ns_passed + ms_passed * std.time.ns_per_ms;
+}
+
fn sourceIndexMessage(msg_bytes: []u8) error{OutOfMemory}!void {
const Header = abi.SourceIndexHeader;
const header: Header = @bitCast(msg_bytes[0..@sizeOf(Header)].*);
@@ -212,6 +238,7 @@ fn sourceIndexMessage(msg_bytes: []u8) error{OutOfMemory}!void {
const files: []const Coverage.File = @alignCast(std.mem.bytesAsSlice(Coverage.File, msg_bytes[files_start..files_end]));
const source_locations: []const Coverage.SourceLocation = @alignCast(std.mem.bytesAsSlice(Coverage.SourceLocation, msg_bytes[source_locations_start..source_locations_end]));
+ start_fuzzing_timestamp = header.start_timestamp;
try updateCoverage(directories, files, source_locations, string_bytes);
js.emitSourceIndexChange();
}
@@ -222,7 +249,7 @@ fn coverageUpdateMessage(msg_bytes: []u8) error{OutOfMemory}!void {
js.emitCoverageUpdate();
}
-var entry_points: std.ArrayListUnmanaged(u32) = .{};
+var entry_points: std.ArrayListUnmanaged(u32) = .empty;
fn entryPointsMessage(msg_bytes: []u8) error{OutOfMemory}!void {
const header: abi.EntryPointHeader = @bitCast(msg_bytes[0..@sizeOf(abi.EntryPointHeader)].*);
@@ -268,7 +295,7 @@ const SourceLocationIndex = enum(u32) {
}
fn toWalkFile(sli: SourceLocationIndex) ?Walk.File.Index {
- var buf: std.ArrayListUnmanaged(u8) = .{};
+ var buf: std.ArrayListUnmanaged(u8) = .empty;
defer buf.deinit(gpa);
sli.appendPath(&buf) catch @panic("OOM");
return @enumFromInt(Walk.files.getIndex(buf.items) orelse return null);
@@ -280,7 +307,7 @@ const SourceLocationIndex = enum(u32) {
) error{ OutOfMemory, SourceUnavailable }!void {
const walk_file_index = sli.toWalkFile() orelse return error.SourceUnavailable;
const root_node = walk_file_index.findRootDecl().get().ast_node;
- var annotations: std.ArrayListUnmanaged(html_render.Annotation) = .{};
+ var annotations: std.ArrayListUnmanaged(html_render.Annotation) = .empty;
defer annotations.deinit(gpa);
try computeSourceAnnotations(sli.ptr().file, walk_file_index, &annotations, coverage_source_locations.items);
html_render.fileSourceHtml(walk_file_index, out, root_node, .{
@@ -300,7 +327,7 @@ fn computeSourceAnnotations(
// Collect all the source locations from only this file into this array
// first, then sort by line, col, so that we can collect annotations with
// O(N) time complexity.
- var locs: std.ArrayListUnmanaged(SourceLocationIndex) = .{};
+ var locs: std.ArrayListUnmanaged(SourceLocationIndex) = .empty;
defer locs.deinit(gpa);
for (source_locations, 0..) |sl, sli_usize| {
@@ -347,9 +374,9 @@ fn computeSourceAnnotations(
var coverage = Coverage.init;
/// Index of type `SourceLocationIndex`.
-var coverage_source_locations: std.ArrayListUnmanaged(Coverage.SourceLocation) = .{};
+var coverage_source_locations: std.ArrayListUnmanaged(Coverage.SourceLocation) = .empty;
/// Contains the most recent coverage update message, unmodified.
-var recent_coverage_update: std.ArrayListAlignedUnmanaged(u8, @alignOf(u64)) = .{};
+var recent_coverage_update: std.ArrayListAlignedUnmanaged(u8, @alignOf(u64)) = .empty;
fn updateCoverage(
directories: []const Coverage.String,
@@ -398,7 +425,7 @@ export fn sourceLocationFileHtml(sli: SourceLocationIndex) String {
export fn sourceLocationFileCoveredList(sli_file: SourceLocationIndex) Slice(SourceLocationIndex) {
const global = struct {
- var result: std.ArrayListUnmanaged(SourceLocationIndex) = .{};
+ var result: std.ArrayListUnmanaged(SourceLocationIndex) = .empty;
fn add(i: u32, want_file: Coverage.File.Index) void {
const src_loc_index: SourceLocationIndex = @enumFromInt(i);
if (src_loc_index.ptr().file == want_file) result.appendAssumeCapacity(src_loc_index);
diff --git a/lib/include/__clang_cuda_intrinsics.h b/lib/include/__clang_cuda_intrinsics.h
index 3c3948863c1d..a04e8b6de44d 100644
--- a/lib/include/__clang_cuda_intrinsics.h
+++ b/lib/include/__clang_cuda_intrinsics.h
@@ -215,9 +215,7 @@ inline __device__ unsigned int __activemask() {
#if CUDA_VERSION < 9020
return __nvvm_vote_ballot(1);
#else
- unsigned int mask;
- asm volatile("activemask.b32 %0;" : "=r"(mask));
- return mask;
+ return __nvvm_activemask();
#endif
}
diff --git a/lib/include/__stdarg_header_macro.h b/lib/include/__stdarg_header_macro.h
new file mode 100644
index 000000000000..beb92ee02526
--- /dev/null
+++ b/lib/include/__stdarg_header_macro.h
@@ -0,0 +1,12 @@
+/*===---- __stdarg_header_macro.h ------------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __STDARG_H
+#define __STDARG_H
+#endif
diff --git a/lib/include/__stddef_header_macro.h b/lib/include/__stddef_header_macro.h
new file mode 100644
index 000000000000..db5fb3c0abc1
--- /dev/null
+++ b/lib/include/__stddef_header_macro.h
@@ -0,0 +1,12 @@
+/*===---- __stddef_header_macro.h ------------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __STDDEF_H
+#define __STDDEF_H
+#endif
diff --git a/lib/include/arm_acle.h b/lib/include/arm_acle.h
index 9cd34948e3c5..1518b0c4c842 100644
--- a/lib/include/arm_acle.h
+++ b/lib/include/arm_acle.h
@@ -75,6 +75,14 @@ static __inline__ void __attribute__((__always_inline__, __nodebug__)) __yield(v
#define __dbg(t) __builtin_arm_dbg(t)
#endif
+#if defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE
+#define _CHKFEAT_GCS 1
+static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__))
+__chkfeat(uint64_t __features) {
+ return __builtin_arm_chkfeat(__features) ^ __features;
+}
+#endif
+
/* 7.5 Swap */
static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
__swp(uint32_t __x, volatile uint32_t *__p) {
@@ -109,7 +117,7 @@ __swp(uint32_t __x, volatile uint32_t *__p) {
#endif
/* 7.7 NOP */
-#if !defined(_MSC_VER) || !defined(__aarch64__)
+#if !defined(_MSC_VER) || (!defined(__aarch64__) && !defined(__arm64ec__))
static __inline__ void __attribute__((__always_inline__, __nodebug__)) __nop(void) {
__builtin_arm_nop();
}
@@ -313,7 +321,7 @@ __qdbl(int32_t __t) {
}
#endif
-/* 8.4.3 Accumultating multiplications */
+/* 8.4.3 Accumulating multiplications */
#if defined(__ARM_FEATURE_DSP) && __ARM_FEATURE_DSP
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
__smlabb(int32_t __a, int32_t __b, int32_t __c) {
@@ -545,7 +553,7 @@ __usub16(uint16x2_t __a, uint16x2_t __b) {
}
#endif
-/* 8.5.10 Parallel 16-bit multiplications */
+/* 8.5.10 Parallel 16-bit multiplication */
#if defined(__ARM_FEATURE_SIMD32) && __ARM_FEATURE_SIMD32
static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
__smlad(int16x2_t __a, int16x2_t __b, int32_t __c) {
@@ -748,7 +756,7 @@ __arm_st64bv0(void *__addr, data512_t __value) {
#define __arm_wsrf(sysreg, v) __arm_wsr(sysreg, __builtin_bit_cast(uint32_t, v))
#define __arm_wsrf64(sysreg, v) __arm_wsr64(sysreg, __builtin_bit_cast(uint64_t, v))
-/* 10.3 Memory Tagging Extensions (MTE) Intrinsics */
+/* 10.3 MTE intrinsics */
#if defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE
#define __arm_mte_create_random_tag(__ptr, __mask) __builtin_arm_irg(__ptr, __mask)
#define __arm_mte_increment_tag(__ptr, __tag_offset) __builtin_arm_addg(__ptr, __tag_offset)
@@ -757,7 +765,7 @@ __arm_st64bv0(void *__addr, data512_t __value) {
#define __arm_mte_set_tag(__ptr) __builtin_arm_stg(__ptr)
#define __arm_mte_ptrdiff(__ptra, __ptrb) __builtin_arm_subp(__ptra, __ptrb)
-/* 18 Memory Operations Intrinsics */
+/* 18 memcpy family of operations intrinsics - MOPS */
#define __arm_mops_memset_tag(__tagged_address, __value, __size) \
__builtin_arm_mops_memset_tag(__tagged_address, __value, __size)
#endif
@@ -855,6 +863,24 @@ __rndrrs(uint64_t *__p) {
}
#endif
+/* 11.2 Guarded Control Stack intrinsics */
+#if defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE
+static __inline__ void * __attribute__((__always_inline__, __nodebug__))
+__gcspr() {
+ return (void *)__builtin_arm_rsr64("gcspr_el0");
+}
+
+static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__, target("gcs")))
+__gcspopm() {
+ return __builtin_arm_gcspopm(0);
+}
+
+static __inline__ const void * __attribute__((__always_inline__, __nodebug__, target("gcs")))
+__gcsss(const void *__stack) {
+ return __builtin_arm_gcsss(__stack);
+}
+#endif
+
#if defined(__cplusplus)
}
#endif
diff --git a/lib/include/arm_fp16.h b/lib/include/arm_fp16.h
index f114c6997b76..2dd0653ab038 100644
--- a/lib/include/arm_fp16.h
+++ b/lib/include/arm_fp16.h
@@ -29,7 +29,7 @@
typedef __fp16 float16_t;
#define __ai static __inline__ __attribute__((__always_inline__, __nodebug__))
-#if defined(__aarch64__)
+#if defined(__aarch64__) || defined(__arm64ec__)
#define vabdh_f16(__p0, __p1) __extension__ ({ \
float16_t __ret; \
float16_t __s0 = __p0; \
diff --git a/lib/include/arm_neon.h b/lib/include/arm_neon.h
index 97431fccab5d..b67616134b88 100644
--- a/lib/include/arm_neon.h
+++ b/lib/include/arm_neon.h
@@ -28,15 +28,11 @@
#error "NEON intrinsics not available with the soft-float ABI. Please use -mfloat-abi=softfp or -mfloat-abi=hard"
#else
-#if !defined(__ARM_NEON)
-#error "NEON support not enabled"
-#else
-
#include
#include
#include
-#ifdef __aarch64__
+#if defined(__aarch64__) || defined(__arm64ec__)
typedef uint8_t poly8_t;
typedef uint16_t poly16_t;
typedef uint64_t poly64_t;
@@ -128,13147 +124,13213 @@ typedef struct poly64x2x4_t {
#define __ai static __inline__ __attribute__((__always_inline__, __nodebug__))
#ifdef __LITTLE_ENDIAN__
-#define splat_lane_p8(__p0, __p1) __extension__ ({ \
- poly8x8_t __ret; \
- poly8x8_t __s0 = __p0; \
- __ret = (poly8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 4); \
+#define splatq_lane_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x8_t __ret; \
+ bfloat16x4_t __s0 = __p0; \
+ __ret = (bfloat16x8_t) __builtin_neon_splatq_lane_bf16((int8x8_t)__s0, __p1, 11); \
__ret; \
})
#else
-#define splat_lane_p8(__p0, __p1) __extension__ ({ \
- poly8x8_t __ret; \
- poly8x8_t __s0 = __p0; \
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 4); \
+#define splatq_lane_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x8_t __ret; \
+ bfloat16x4_t __s0 = __p0; \
+ bfloat16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (bfloat16x8_t) __builtin_neon_splatq_lane_bf16((int8x8_t)__rev0, __p1, 11); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
-#define __noswap_splat_lane_p8(__p0, __p1) __extension__ ({ \
- poly8x8_t __ret; \
- poly8x8_t __s0 = __p0; \
- __ret = (poly8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 4); \
+#define __noswap_splatq_lane_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x8_t __ret; \
+ bfloat16x4_t __s0 = __p0; \
+ __ret = (bfloat16x8_t) __builtin_neon_splatq_lane_bf16((int8x8_t)__s0, __p1, 11); \
__ret; \
})
#endif
-#define splat_lane_p64(__p0, __p1) __extension__ ({ \
- poly64x1_t __ret; \
- poly64x1_t __s0 = __p0; \
- __ret = (poly64x1_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 6); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define splat_lane_p16(__p0, __p1) __extension__ ({ \
- poly16x4_t __ret; \
- poly16x4_t __s0 = __p0; \
- __ret = (poly16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 5); \
+#define splat_lane_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x4_t __ret; \
+ bfloat16x4_t __s0 = __p0; \
+ __ret = (bfloat16x4_t) __builtin_neon_splat_lane_bf16((int8x8_t)__s0, __p1, 11); \
__ret; \
})
#else
-#define splat_lane_p16(__p0, __p1) __extension__ ({ \
- poly16x4_t __ret; \
- poly16x4_t __s0 = __p0; \
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (poly16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 5); \
+#define splat_lane_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x4_t __ret; \
+ bfloat16x4_t __s0 = __p0; \
+ bfloat16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (bfloat16x4_t) __builtin_neon_splat_lane_bf16((int8x8_t)__rev0, __p1, 11); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
-#define __noswap_splat_lane_p16(__p0, __p1) __extension__ ({ \
- poly16x4_t __ret; \
- poly16x4_t __s0 = __p0; \
- __ret = (poly16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 5); \
+#define __noswap_splat_lane_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x4_t __ret; \
+ bfloat16x4_t __s0 = __p0; \
+ __ret = (bfloat16x4_t) __builtin_neon_splat_lane_bf16((int8x8_t)__s0, __p1, 11); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_lane_p8(__p0, __p1) __extension__ ({ \
- poly8x16_t __ret; \
- poly8x8_t __s0 = __p0; \
- __ret = (poly8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 4); \
+#define splatq_laneq_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x8_t __ret; \
+ bfloat16x8_t __s0 = __p0; \
+ __ret = (bfloat16x8_t) __builtin_neon_splatq_laneq_bf16((int8x16_t)__s0, __p1, 43); \
__ret; \
})
#else
-#define splatq_lane_p8(__p0, __p1) __extension__ ({ \
- poly8x16_t __ret; \
- poly8x8_t __s0 = __p0; \
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 4); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define splatq_laneq_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x8_t __ret; \
+ bfloat16x8_t __s0 = __p0; \
+ bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (bfloat16x8_t) __builtin_neon_splatq_laneq_bf16((int8x16_t)__rev0, __p1, 43); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
-#define __noswap_splatq_lane_p8(__p0, __p1) __extension__ ({ \
- poly8x16_t __ret; \
- poly8x8_t __s0 = __p0; \
- __ret = (poly8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 4); \
+#define __noswap_splatq_laneq_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x8_t __ret; \
+ bfloat16x8_t __s0 = __p0; \
+ __ret = (bfloat16x8_t) __builtin_neon_splatq_laneq_bf16((int8x16_t)__s0, __p1, 43); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_lane_p64(__p0, __p1) __extension__ ({ \
- poly64x2_t __ret; \
- poly64x1_t __s0 = __p0; \
- __ret = (poly64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 6); \
+#define splat_laneq_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x4_t __ret; \
+ bfloat16x8_t __s0 = __p0; \
+ __ret = (bfloat16x4_t) __builtin_neon_splat_laneq_bf16((int8x16_t)__s0, __p1, 43); \
__ret; \
})
#else
-#define splatq_lane_p64(__p0, __p1) __extension__ ({ \
- poly64x2_t __ret; \
- poly64x1_t __s0 = __p0; \
- __ret = (poly64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 6); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+#define splat_laneq_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x4_t __ret; \
+ bfloat16x8_t __s0 = __p0; \
+ bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (bfloat16x4_t) __builtin_neon_splat_laneq_bf16((int8x16_t)__rev0, __p1, 43); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
-#define __noswap_splatq_lane_p64(__p0, __p1) __extension__ ({ \
- poly64x2_t __ret; \
- poly64x1_t __s0 = __p0; \
- __ret = (poly64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 6); \
+#define __noswap_splat_laneq_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x4_t __ret; \
+ bfloat16x8_t __s0 = __p0; \
+ __ret = (bfloat16x4_t) __builtin_neon_splat_laneq_bf16((int8x16_t)__s0, __p1, 43); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_lane_p16(__p0, __p1) __extension__ ({ \
- poly16x8_t __ret; \
- poly16x4_t __s0 = __p0; \
- __ret = (poly16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 5); \
+__ai __attribute__((target("bf16,neon"))) float32x4_t vbfdotq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vbfdotq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+ return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) float32x4_t vbfdotq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ bfloat16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ bfloat16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vbfdotq_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) float32x4_t __noswap_vbfdotq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vbfdotq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) float32x2_t vbfdot_f32(float32x2_t __p0, bfloat16x4_t __p1, bfloat16x4_t __p2) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vbfdot_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+ return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) float32x2_t vbfdot_f32(float32x2_t __p0, bfloat16x4_t __p1, bfloat16x4_t __p2) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ bfloat16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ bfloat16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vbfdot_f32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) float32x2_t __noswap_vbfdot_f32(float32x2_t __p0, bfloat16x4_t __p1, bfloat16x4_t __p2) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vbfdot_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) float32x4_t vbfmlalbq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vbfmlalbq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+ return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) float32x4_t vbfmlalbq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ bfloat16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ bfloat16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vbfmlalbq_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) float32x4_t __noswap_vbfmlalbq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vbfmlalbq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) float32x4_t vbfmlaltq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vbfmlaltq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+ return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) float32x4_t vbfmlaltq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ bfloat16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ bfloat16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vbfmlaltq_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) float32x4_t __noswap_vbfmlaltq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vbfmlaltq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) float32x4_t vbfmmlaq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vbfmmlaq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+ return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) float32x4_t vbfmmlaq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ bfloat16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ bfloat16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vbfmmlaq_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcombine_bf16(bfloat16x4_t __p0, bfloat16x4_t __p1) {
+ bfloat16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+ return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcombine_bf16(bfloat16x4_t __p0, bfloat16x4_t __p1) {
+ bfloat16x8_t __ret;
+ bfloat16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ bfloat16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t __noswap_vcombine_bf16(bfloat16x4_t __p0, bfloat16x4_t __p1) {
+ bfloat16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+ return __ret;
+}
+#endif
+
+#define vcreate_bf16(__p0) __extension__ ({ \
+ bfloat16x4_t __ret; \
+ uint64_t __promote = __p0; \
+ __ret = (bfloat16x4_t)(__promote); \
__ret; \
})
-#else
-#define splatq_lane_p16(__p0, __p1) __extension__ ({ \
- poly16x8_t __ret; \
- poly16x4_t __s0 = __p0; \
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (poly16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 5); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+__ai __attribute__((target("bf16,neon"))) float32_t vcvtah_f32_bf16(bfloat16_t __p0) {
+ float32_t __ret;
+bfloat16_t __reint = __p0;
+int32_t __reint1 = (int32_t)(*(int16_t *) &__reint) << 16;
+ __ret = *(float32_t *) &__reint1;
+ return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16_t vcvth_bf16_f32(float32_t __p0) {
+ bfloat16_t __ret;
+ __ret = (bfloat16_t) __builtin_neon_vcvth_bf16_f32(__p0);
+ return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+#define vduph_lane_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16_t __ret; \
+ bfloat16x4_t __s0 = __p0; \
+ __ret = (bfloat16_t) __builtin_neon_vduph_lane_bf16((bfloat16x4_t)__s0, __p1); \
__ret; \
})
-#define __noswap_splatq_lane_p16(__p0, __p1) __extension__ ({ \
- poly16x8_t __ret; \
- poly16x4_t __s0 = __p0; \
- __ret = (poly16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 5); \
+#else
+#define vduph_lane_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16_t __ret; \
+ bfloat16x4_t __s0 = __p0; \
+ bfloat16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (bfloat16_t) __builtin_neon_vduph_lane_bf16((bfloat16x4_t)__rev0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_lane_u8(__p0, __p1) __extension__ ({ \
- uint8x16_t __ret; \
- uint8x8_t __s0 = __p0; \
- __ret = (uint8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 16); \
- __ret; \
+#define vdupq_lane_bf16(__p0_0, __p1_0) __extension__ ({ \
+ bfloat16x8_t __ret_0; \
+ bfloat16x4_t __s0_0 = __p0_0; \
+ __ret_0 = splatq_lane_bf16(__s0_0, __p1_0); \
+ __ret_0; \
})
#else
-#define splatq_lane_u8(__p0, __p1) __extension__ ({ \
- uint8x16_t __ret; \
- uint8x8_t __s0 = __p0; \
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 16); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splatq_lane_u8(__p0, __p1) __extension__ ({ \
- uint8x16_t __ret; \
- uint8x8_t __s0 = __p0; \
- __ret = (uint8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 16); \
- __ret; \
+#define vdupq_lane_bf16(__p0_1, __p1_1) __extension__ ({ \
+ bfloat16x8_t __ret_1; \
+ bfloat16x4_t __s0_1 = __p0_1; \
+ bfloat16x4_t __rev0_1; __rev0_1 = __builtin_shufflevector(__s0_1, __s0_1, 3, 2, 1, 0); \
+ __ret_1 = __noswap_splatq_lane_bf16(__rev0_1, __p1_1); \
+ __ret_1 = __builtin_shufflevector(__ret_1, __ret_1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_1; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_lane_u32(__p0, __p1) __extension__ ({ \
- uint32x4_t __ret; \
- uint32x2_t __s0 = __p0; \
- __ret = (uint32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 18); \
- __ret; \
+#define vdup_lane_bf16(__p0_2, __p1_2) __extension__ ({ \
+ bfloat16x4_t __ret_2; \
+ bfloat16x4_t __s0_2 = __p0_2; \
+ __ret_2 = splat_lane_bf16(__s0_2, __p1_2); \
+ __ret_2; \
})
#else
-#define splatq_lane_u32(__p0, __p1) __extension__ ({ \
- uint32x4_t __ret; \
- uint32x2_t __s0 = __p0; \
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 18); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+#define vdup_lane_bf16(__p0_3, __p1_3) __extension__ ({ \
+ bfloat16x4_t __ret_3; \
+ bfloat16x4_t __s0_3 = __p0_3; \
+ bfloat16x4_t __rev0_3; __rev0_3 = __builtin_shufflevector(__s0_3, __s0_3, 3, 2, 1, 0); \
+ __ret_3 = __noswap_splat_lane_bf16(__rev0_3, __p1_3); \
+ __ret_3 = __builtin_shufflevector(__ret_3, __ret_3, 3, 2, 1, 0); \
+ __ret_3; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vduph_laneq_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16_t __ret; \
+ bfloat16x8_t __s0 = __p0; \
+ __ret = (bfloat16_t) __builtin_neon_vduph_laneq_bf16((bfloat16x8_t)__s0, __p1); \
__ret; \
})
-#define __noswap_splatq_lane_u32(__p0, __p1) __extension__ ({ \
- uint32x4_t __ret; \
- uint32x2_t __s0 = __p0; \
- __ret = (uint32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 18); \
+#else
+#define vduph_laneq_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16_t __ret; \
+ bfloat16x8_t __s0 = __p0; \
+ bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (bfloat16_t) __builtin_neon_vduph_laneq_bf16((bfloat16x8_t)__rev0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_lane_u64(__p0, __p1) __extension__ ({ \
- uint64x2_t __ret; \
- uint64x1_t __s0 = __p0; \
- __ret = (uint64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 19); \
- __ret; \
+#define vdupq_laneq_bf16(__p0_4, __p1_4) __extension__ ({ \
+ bfloat16x8_t __ret_4; \
+ bfloat16x8_t __s0_4 = __p0_4; \
+ __ret_4 = splatq_laneq_bf16(__s0_4, __p1_4); \
+ __ret_4; \
})
#else
-#define splatq_lane_u64(__p0, __p1) __extension__ ({ \
- uint64x2_t __ret; \
- uint64x1_t __s0 = __p0; \
- __ret = (uint64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 19); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
+#define vdupq_laneq_bf16(__p0_5, __p1_5) __extension__ ({ \
+ bfloat16x8_t __ret_5; \
+ bfloat16x8_t __s0_5 = __p0_5; \
+ bfloat16x8_t __rev0_5; __rev0_5 = __builtin_shufflevector(__s0_5, __s0_5, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_5 = __noswap_splatq_laneq_bf16(__rev0_5, __p1_5); \
+ __ret_5 = __builtin_shufflevector(__ret_5, __ret_5, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_5; \
})
-#define __noswap_splatq_lane_u64(__p0, __p1) __extension__ ({ \
- uint64x2_t __ret; \
- uint64x1_t __s0 = __p0; \
- __ret = (uint64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 19); \
- __ret; \
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_bf16(__p0_6, __p1_6) __extension__ ({ \
+ bfloat16x4_t __ret_6; \
+ bfloat16x8_t __s0_6 = __p0_6; \
+ __ret_6 = splat_laneq_bf16(__s0_6, __p1_6); \
+ __ret_6; \
+})
+#else
+#define vdup_laneq_bf16(__p0_7, __p1_7) __extension__ ({ \
+ bfloat16x4_t __ret_7; \
+ bfloat16x8_t __s0_7 = __p0_7; \
+ bfloat16x8_t __rev0_7; __rev0_7 = __builtin_shufflevector(__s0_7, __s0_7, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_7 = __noswap_splat_laneq_bf16(__rev0_7, __p1_7); \
+ __ret_7 = __builtin_shufflevector(__ret_7, __ret_7, 3, 2, 1, 0); \
+ __ret_7; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_lane_u16(__p0, __p1) __extension__ ({ \
- uint16x8_t __ret; \
- uint16x4_t __s0 = __p0; \
- __ret = (uint16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 17); \
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vdupq_n_bf16(bfloat16_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vdupq_n_bf16(bfloat16_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vdup_n_bf16(bfloat16_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t) {__p0, __p0, __p0, __p0};
+ return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vdup_n_bf16(bfloat16_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t) {__p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vget_high_bf16(bfloat16x8_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+ return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vget_high_bf16(bfloat16x8_t __p0) {
+ bfloat16x4_t __ret;
+ bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 4, 5, 6, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t __noswap_vget_high_bf16(bfloat16x8_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vgetq_lane_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16_t __ret; \
+ bfloat16x8_t __s0 = __p0; \
+ __ret = (bfloat16_t) __builtin_neon_vgetq_lane_bf16((bfloat16x8_t)__s0, __p1); \
__ret; \
})
#else
-#define splatq_lane_u16(__p0, __p1) __extension__ ({ \
- uint16x8_t __ret; \
- uint16x4_t __s0 = __p0; \
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 17); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vgetq_lane_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16_t __ret; \
+ bfloat16x8_t __s0 = __p0; \
+ bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (bfloat16_t) __builtin_neon_vgetq_lane_bf16((bfloat16x8_t)__rev0, __p1); \
__ret; \
})
-#define __noswap_splatq_lane_u16(__p0, __p1) __extension__ ({ \
- uint16x8_t __ret; \
- uint16x4_t __s0 = __p0; \
- __ret = (uint16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 17); \
+#define __noswap_vgetq_lane_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16_t __ret; \
+ bfloat16x8_t __s0 = __p0; \
+ __ret = (bfloat16_t) __builtin_neon_vgetq_lane_bf16((bfloat16x8_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_lane_s8(__p0, __p1) __extension__ ({ \
- int8x16_t __ret; \
- int8x8_t __s0 = __p0; \
- __ret = (int8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 0); \
+#define vget_lane_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16_t __ret; \
+ bfloat16x4_t __s0 = __p0; \
+ __ret = (bfloat16_t) __builtin_neon_vget_lane_bf16((bfloat16x4_t)__s0, __p1); \
__ret; \
})
#else
-#define splatq_lane_s8(__p0, __p1) __extension__ ({ \
- int8x16_t __ret; \
- int8x8_t __s0 = __p0; \
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 0); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vget_lane_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16_t __ret; \
+ bfloat16x4_t __s0 = __p0; \
+ bfloat16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (bfloat16_t) __builtin_neon_vget_lane_bf16((bfloat16x4_t)__rev0, __p1); \
__ret; \
})
-#define __noswap_splatq_lane_s8(__p0, __p1) __extension__ ({ \
- int8x16_t __ret; \
- int8x8_t __s0 = __p0; \
- __ret = (int8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 0); \
+#define __noswap_vget_lane_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16_t __ret; \
+ bfloat16x4_t __s0 = __p0; \
+ __ret = (bfloat16_t) __builtin_neon_vget_lane_bf16((bfloat16x4_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_lane_f64(__p0, __p1) __extension__ ({ \
- float64x2_t __ret; \
- float64x1_t __s0 = __p0; \
- __ret = (float64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 10); \
- __ret; \
-})
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vget_low_bf16(bfloat16x8_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3);
+ return __ret;
+}
#else
-#define splatq_lane_f64(__p0, __p1) __extension__ ({ \
- float64x2_t __ret; \
- float64x1_t __s0 = __p0; \
- __ret = (float64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 10); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vget_low_bf16(bfloat16x8_t __p0) {
+ bfloat16x4_t __ret;
+ bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t __noswap_vget_low_bf16(bfloat16x8_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_bf16(__p0) __extension__ ({ \
+ bfloat16x8_t __ret; \
+ __ret = (bfloat16x8_t) __builtin_neon_vld1q_bf16(__p0, 43); \
__ret; \
})
-#define __noswap_splatq_lane_f64(__p0, __p1) __extension__ ({ \
- float64x2_t __ret; \
- float64x1_t __s0 = __p0; \
- __ret = (float64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 10); \
+#else
+#define vld1q_bf16(__p0) __extension__ ({ \
+ bfloat16x8_t __ret; \
+ __ret = (bfloat16x8_t) __builtin_neon_vld1q_bf16(__p0, 43); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_lane_f32(__p0, __p1) __extension__ ({ \
- float32x4_t __ret; \
- float32x2_t __s0 = __p0; \
- __ret = (float32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 9); \
+#define vld1_bf16(__p0) __extension__ ({ \
+ bfloat16x4_t __ret; \
+ __ret = (bfloat16x4_t) __builtin_neon_vld1_bf16(__p0, 11); \
__ret; \
})
#else
-#define splatq_lane_f32(__p0, __p1) __extension__ ({ \
- float32x4_t __ret; \
- float32x2_t __s0 = __p0; \
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (float32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 9); \
+#define vld1_bf16(__p0) __extension__ ({ \
+ bfloat16x4_t __ret; \
+ __ret = (bfloat16x4_t) __builtin_neon_vld1_bf16(__p0, 11); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
-#define __noswap_splatq_lane_f32(__p0, __p1) __extension__ ({ \
- float32x4_t __ret; \
- float32x2_t __s0 = __p0; \
- __ret = (float32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 9); \
- __ret; \
-})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_lane_f16(__p0, __p1) __extension__ ({ \
- float16x8_t __ret; \
- float16x4_t __s0 = __p0; \
- __ret = (float16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 8); \
+#define vld1q_dup_bf16(__p0) __extension__ ({ \
+ bfloat16x8_t __ret; \
+ __ret = (bfloat16x8_t) __builtin_neon_vld1q_dup_bf16(__p0, 43); \
__ret; \
})
#else
-#define splatq_lane_f16(__p0, __p1) __extension__ ({ \
- float16x8_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (float16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 8); \
+#define vld1q_dup_bf16(__p0) __extension__ ({ \
+ bfloat16x8_t __ret; \
+ __ret = (bfloat16x8_t) __builtin_neon_vld1q_dup_bf16(__p0, 43); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
-#define __noswap_splatq_lane_f16(__p0, __p1) __extension__ ({ \
- float16x8_t __ret; \
- float16x4_t __s0 = __p0; \
- __ret = (float16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 8); \
- __ret; \
-})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_lane_s32(__p0, __p1) __extension__ ({ \
- int32x4_t __ret; \
- int32x2_t __s0 = __p0; \
- __ret = (int32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 2); \
+#define vld1_dup_bf16(__p0) __extension__ ({ \
+ bfloat16x4_t __ret; \
+ __ret = (bfloat16x4_t) __builtin_neon_vld1_dup_bf16(__p0, 11); \
__ret; \
})
#else
-#define splatq_lane_s32(__p0, __p1) __extension__ ({ \
- int32x4_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 2); \
+#define vld1_dup_bf16(__p0) __extension__ ({ \
+ bfloat16x4_t __ret; \
+ __ret = (bfloat16x4_t) __builtin_neon_vld1_dup_bf16(__p0, 11); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
-#define __noswap_splatq_lane_s32(__p0, __p1) __extension__ ({ \
- int32x4_t __ret; \
- int32x2_t __s0 = __p0; \
- __ret = (int32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 2); \
- __ret; \
-})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_lane_s64(__p0, __p1) __extension__ ({ \
- int64x2_t __ret; \
- int64x1_t __s0 = __p0; \
- __ret = (int64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 3); \
+#define vld1q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8_t __ret; \
+ bfloat16x8_t __s1 = __p1; \
+ __ret = (bfloat16x8_t) __builtin_neon_vld1q_lane_bf16(__p0, (int8x16_t)__s1, __p2, 43); \
__ret; \
})
#else
-#define splatq_lane_s64(__p0, __p1) __extension__ ({ \
- int64x2_t __ret; \
- int64x1_t __s0 = __p0; \
- __ret = (int64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 3); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_splatq_lane_s64(__p0, __p1) __extension__ ({ \
- int64x2_t __ret; \
- int64x1_t __s0 = __p0; \
- __ret = (int64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 3); \
+#define vld1q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8_t __ret; \
+ bfloat16x8_t __s1 = __p1; \
+ bfloat16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (bfloat16x8_t) __builtin_neon_vld1q_lane_bf16(__p0, (int8x16_t)__rev1, __p2, 43); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_lane_s16(__p0, __p1) __extension__ ({ \
- int16x8_t __ret; \
- int16x4_t __s0 = __p0; \
- __ret = (int16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 1); \
+#define vld1_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4_t __ret; \
+ bfloat16x4_t __s1 = __p1; \
+ __ret = (bfloat16x4_t) __builtin_neon_vld1_lane_bf16(__p0, (int8x8_t)__s1, __p2, 11); \
__ret; \
})
#else
-#define splatq_lane_s16(__p0, __p1) __extension__ ({ \
- int16x8_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splatq_lane_s16(__p0, __p1) __extension__ ({ \
- int16x8_t __ret; \
- int16x4_t __s0 = __p0; \
- __ret = (int16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 1); \
+#define vld1_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4_t __ret; \
+ bfloat16x4_t __s1 = __p1; \
+ bfloat16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (bfloat16x4_t) __builtin_neon_vld1_lane_bf16(__p0, (int8x8_t)__rev1, __p2, 11); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_lane_u8(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- uint8x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 16); \
+#define vld1q_bf16_x2(__p0) __extension__ ({ \
+ bfloat16x8x2_t __ret; \
+ __builtin_neon_vld1q_bf16_x2(&__ret, __p0, 43); \
__ret; \
})
#else
-#define splat_lane_u8(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- uint8x8_t __s0 = __p0; \
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 16); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splat_lane_u8(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- uint8x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 16); \
+#define vld1q_bf16_x2(__p0) __extension__ ({ \
+ bfloat16x8x2_t __ret; \
+ __builtin_neon_vld1q_bf16_x2(&__ret, __p0, 43); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_lane_u32(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- uint32x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 18); \
+#define vld1_bf16_x2(__p0) __extension__ ({ \
+ bfloat16x4x2_t __ret; \
+ __builtin_neon_vld1_bf16_x2(&__ret, __p0, 11); \
__ret; \
})
#else
-#define splat_lane_u32(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- uint32x2_t __s0 = __p0; \
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 18); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_splat_lane_u32(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- uint32x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 18); \
+#define vld1_bf16_x2(__p0) __extension__ ({ \
+ bfloat16x4x2_t __ret; \
+ __builtin_neon_vld1_bf16_x2(&__ret, __p0, 11); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
__ret; \
})
#endif
-#define splat_lane_u64(__p0, __p1) __extension__ ({ \
- uint64x1_t __ret; \
- uint64x1_t __s0 = __p0; \
- __ret = (uint64x1_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 19); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define splat_lane_u16(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- uint16x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 17); \
+#define vld1q_bf16_x3(__p0) __extension__ ({ \
+ bfloat16x8x3_t __ret; \
+ __builtin_neon_vld1q_bf16_x3(&__ret, __p0, 43); \
__ret; \
})
#else
-#define splat_lane_u16(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- uint16x4_t __s0 = __p0; \
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 17); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splat_lane_u16(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- uint16x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 17); \
+#define vld1q_bf16_x3(__p0) __extension__ ({ \
+ bfloat16x8x3_t __ret; \
+ __builtin_neon_vld1q_bf16_x3(&__ret, __p0, 43); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_lane_s8(__p0, __p1) __extension__ ({ \
- int8x8_t __ret; \
- int8x8_t __s0 = __p0; \
- __ret = (int8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 0); \
+#define vld1_bf16_x3(__p0) __extension__ ({ \
+ bfloat16x4x3_t __ret; \
+ __builtin_neon_vld1_bf16_x3(&__ret, __p0, 11); \
__ret; \
})
#else
-#define splat_lane_s8(__p0, __p1) __extension__ ({ \
- int8x8_t __ret; \
- int8x8_t __s0 = __p0; \
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 0); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splat_lane_s8(__p0, __p1) __extension__ ({ \
- int8x8_t __ret; \
- int8x8_t __s0 = __p0; \
- __ret = (int8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 0); \
+#define vld1_bf16_x3(__p0) __extension__ ({ \
+ bfloat16x4x3_t __ret; \
+ __builtin_neon_vld1_bf16_x3(&__ret, __p0, 11); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
__ret; \
})
#endif
-#define splat_lane_f64(__p0, __p1) __extension__ ({ \
- float64x1_t __ret; \
- float64x1_t __s0 = __p0; \
- __ret = (float64x1_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 10); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define splat_lane_f32(__p0, __p1) __extension__ ({ \
- float32x2_t __ret; \
- float32x2_t __s0 = __p0; \
- __ret = (float32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 9); \
+#define vld1q_bf16_x4(__p0) __extension__ ({ \
+ bfloat16x8x4_t __ret; \
+ __builtin_neon_vld1q_bf16_x4(&__ret, __p0, 43); \
__ret; \
})
#else
-#define splat_lane_f32(__p0, __p1) __extension__ ({ \
- float32x2_t __ret; \
- float32x2_t __s0 = __p0; \
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (float32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 9); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_splat_lane_f32(__p0, __p1) __extension__ ({ \
- float32x2_t __ret; \
- float32x2_t __s0 = __p0; \
- __ret = (float32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 9); \
+#define vld1q_bf16_x4(__p0) __extension__ ({ \
+ bfloat16x8x4_t __ret; \
+ __builtin_neon_vld1q_bf16_x4(&__ret, __p0, 43); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_lane_f16(__p0, __p1) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- __ret = (float16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 8); \
+#define vld1_bf16_x4(__p0) __extension__ ({ \
+ bfloat16x4x4_t __ret; \
+ __builtin_neon_vld1_bf16_x4(&__ret, __p0, 11); \
__ret; \
})
#else
-#define splat_lane_f16(__p0, __p1) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (float16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 8); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splat_lane_f16(__p0, __p1) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- __ret = (float16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 8); \
+#define vld1_bf16_x4(__p0) __extension__ ({ \
+ bfloat16x4x4_t __ret; \
+ __builtin_neon_vld1_bf16_x4(&__ret, __p0, 11); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_lane_s32(__p0, __p1) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- __ret = (int32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 2); \
+#define vld2q_bf16(__p0) __extension__ ({ \
+ bfloat16x8x2_t __ret; \
+ __builtin_neon_vld2q_bf16(&__ret, __p0, 43); \
__ret; \
})
#else
-#define splat_lane_s32(__p0, __p1) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_splat_lane_s32(__p0, __p1) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- __ret = (int32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 2); \
+#define vld2q_bf16(__p0) __extension__ ({ \
+ bfloat16x8x2_t __ret; \
+ __builtin_neon_vld2q_bf16(&__ret, __p0, 43); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
-#define splat_lane_s64(__p0, __p1) __extension__ ({ \
- int64x1_t __ret; \
- int64x1_t __s0 = __p0; \
- __ret = (int64x1_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 3); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define splat_lane_s16(__p0, __p1) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- __ret = (int16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 1); \
+#define vld2_bf16(__p0) __extension__ ({ \
+ bfloat16x4x2_t __ret; \
+ __builtin_neon_vld2_bf16(&__ret, __p0, 11); \
__ret; \
})
#else
-#define splat_lane_s16(__p0, __p1) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splat_lane_s16(__p0, __p1) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- __ret = (int16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 1); \
+#define vld2_bf16(__p0) __extension__ ({ \
+ bfloat16x4x2_t __ret; \
+ __builtin_neon_vld2_bf16(&__ret, __p0, 11); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_laneq_p8(__p0, __p1) __extension__ ({ \
- poly8x8_t __ret; \
- poly8x16_t __s0 = __p0; \
- __ret = (poly8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 36); \
+#define vld2q_dup_bf16(__p0) __extension__ ({ \
+ bfloat16x8x2_t __ret; \
+ __builtin_neon_vld2q_dup_bf16(&__ret, __p0, 43); \
__ret; \
})
#else
-#define splat_laneq_p8(__p0, __p1) __extension__ ({ \
- poly8x8_t __ret; \
- poly8x16_t __s0 = __p0; \
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 36); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splat_laneq_p8(__p0, __p1) __extension__ ({ \
- poly8x8_t __ret; \
- poly8x16_t __s0 = __p0; \
- __ret = (poly8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 36); \
+#define vld2q_dup_bf16(__p0) __extension__ ({ \
+ bfloat16x8x2_t __ret; \
+ __builtin_neon_vld2q_dup_bf16(&__ret, __p0, 43); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_laneq_p64(__p0, __p1) __extension__ ({ \
- poly64x1_t __ret; \
- poly64x2_t __s0 = __p0; \
- __ret = (poly64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 38); \
+#define vld2_dup_bf16(__p0) __extension__ ({ \
+ bfloat16x4x2_t __ret; \
+ __builtin_neon_vld2_dup_bf16(&__ret, __p0, 11); \
__ret; \
})
#else
-#define splat_laneq_p64(__p0, __p1) __extension__ ({ \
- poly64x1_t __ret; \
- poly64x2_t __s0 = __p0; \
- poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (poly64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 38); \
- __ret; \
-})
-#define __noswap_splat_laneq_p64(__p0, __p1) __extension__ ({ \
- poly64x1_t __ret; \
- poly64x2_t __s0 = __p0; \
- __ret = (poly64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 38); \
+#define vld2_dup_bf16(__p0) __extension__ ({ \
+ bfloat16x4x2_t __ret; \
+ __builtin_neon_vld2_dup_bf16(&__ret, __p0, 11); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_laneq_p16(__p0, __p1) __extension__ ({ \
- poly16x4_t __ret; \
- poly16x8_t __s0 = __p0; \
- __ret = (poly16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 37); \
+#define vld2q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8x2_t __ret; \
+ bfloat16x8x2_t __s1 = __p1; \
+ __builtin_neon_vld2q_lane_bf16(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 43); \
__ret; \
})
#else
-#define splat_laneq_p16(__p0, __p1) __extension__ ({ \
- poly16x4_t __ret; \
- poly16x8_t __s0 = __p0; \
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 37); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splat_laneq_p16(__p0, __p1) __extension__ ({ \
- poly16x4_t __ret; \
- poly16x8_t __s0 = __p0; \
- __ret = (poly16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 37); \
+#define vld2q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8x2_t __ret; \
+ bfloat16x8x2_t __s1 = __p1; \
+ bfloat16x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld2q_lane_bf16(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 43); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_laneq_p8(__p0, __p1) __extension__ ({ \
- poly8x16_t __ret; \
- poly8x16_t __s0 = __p0; \
- __ret = (poly8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 36); \
+#define vld2_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4x2_t __ret; \
+ bfloat16x4x2_t __s1 = __p1; \
+ __builtin_neon_vld2_lane_bf16(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 11); \
__ret; \
})
#else
-#define splatq_laneq_p8(__p0, __p1) __extension__ ({ \
- poly8x16_t __ret; \
- poly8x16_t __s0 = __p0; \
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 36); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splatq_laneq_p8(__p0, __p1) __extension__ ({ \
- poly8x16_t __ret; \
- poly8x16_t __s0 = __p0; \
- __ret = (poly8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 36); \
+#define vld2_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4x2_t __ret; \
+ bfloat16x4x2_t __s1 = __p1; \
+ bfloat16x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vld2_lane_bf16(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 11); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_laneq_p64(__p0, __p1) __extension__ ({ \
- poly64x2_t __ret; \
- poly64x2_t __s0 = __p0; \
- __ret = (poly64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 38); \
+#define vld3q_bf16(__p0) __extension__ ({ \
+ bfloat16x8x3_t __ret; \
+ __builtin_neon_vld3q_bf16(&__ret, __p0, 43); \
__ret; \
})
#else
-#define splatq_laneq_p64(__p0, __p1) __extension__ ({ \
- poly64x2_t __ret; \
- poly64x2_t __s0 = __p0; \
- poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (poly64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 38); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_splatq_laneq_p64(__p0, __p1) __extension__ ({ \
- poly64x2_t __ret; \
- poly64x2_t __s0 = __p0; \
- __ret = (poly64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 38); \
+#define vld3q_bf16(__p0) __extension__ ({ \
+ bfloat16x8x3_t __ret; \
+ __builtin_neon_vld3q_bf16(&__ret, __p0, 43); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_laneq_p16(__p0, __p1) __extension__ ({ \
- poly16x8_t __ret; \
- poly16x8_t __s0 = __p0; \
- __ret = (poly16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 37); \
+#define vld3_bf16(__p0) __extension__ ({ \
+ bfloat16x4x3_t __ret; \
+ __builtin_neon_vld3_bf16(&__ret, __p0, 11); \
__ret; \
})
#else
-#define splatq_laneq_p16(__p0, __p1) __extension__ ({ \
- poly16x8_t __ret; \
- poly16x8_t __s0 = __p0; \
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 37); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splatq_laneq_p16(__p0, __p1) __extension__ ({ \
- poly16x8_t __ret; \
- poly16x8_t __s0 = __p0; \
- __ret = (poly16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 37); \
+#define vld3_bf16(__p0) __extension__ ({ \
+ bfloat16x4x3_t __ret; \
+ __builtin_neon_vld3_bf16(&__ret, __p0, 11); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_laneq_u8(__p0, __p1) __extension__ ({ \
- uint8x16_t __ret; \
- uint8x16_t __s0 = __p0; \
- __ret = (uint8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 48); \
+#define vld3q_dup_bf16(__p0) __extension__ ({ \
+ bfloat16x8x3_t __ret; \
+ __builtin_neon_vld3q_dup_bf16(&__ret, __p0, 43); \
__ret; \
})
#else
-#define splatq_laneq_u8(__p0, __p1) __extension__ ({ \
- uint8x16_t __ret; \
- uint8x16_t __s0 = __p0; \
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 48); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splatq_laneq_u8(__p0, __p1) __extension__ ({ \
- uint8x16_t __ret; \
- uint8x16_t __s0 = __p0; \
- __ret = (uint8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 48); \
+#define vld3q_dup_bf16(__p0) __extension__ ({ \
+ bfloat16x8x3_t __ret; \
+ __builtin_neon_vld3q_dup_bf16(&__ret, __p0, 43); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_laneq_u32(__p0, __p1) __extension__ ({ \
- uint32x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- __ret = (uint32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 50); \
+#define vld3_dup_bf16(__p0) __extension__ ({ \
+ bfloat16x4x3_t __ret; \
+ __builtin_neon_vld3_dup_bf16(&__ret, __p0, 11); \
__ret; \
})
#else
-#define splatq_laneq_u32(__p0, __p1) __extension__ ({ \
- uint32x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 50); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splatq_laneq_u32(__p0, __p1) __extension__ ({ \
- uint32x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- __ret = (uint32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 50); \
+#define vld3_dup_bf16(__p0) __extension__ ({ \
+ bfloat16x4x3_t __ret; \
+ __builtin_neon_vld3_dup_bf16(&__ret, __p0, 11); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_laneq_u64(__p0, __p1) __extension__ ({ \
- uint64x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- __ret = (uint64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 51); \
+#define vld3q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8x3_t __ret; \
+ bfloat16x8x3_t __s1 = __p1; \
+ __builtin_neon_vld3q_lane_bf16(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 43); \
__ret; \
})
#else
-#define splatq_laneq_u64(__p0, __p1) __extension__ ({ \
- uint64x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 51); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_splatq_laneq_u64(__p0, __p1) __extension__ ({ \
- uint64x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- __ret = (uint64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 51); \
+#define vld3q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8x3_t __ret; \
+ bfloat16x8x3_t __s1 = __p1; \
+ bfloat16x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld3q_lane_bf16(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 43); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_laneq_u16(__p0, __p1) __extension__ ({ \
- uint16x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- __ret = (uint16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 49); \
+#define vld3_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4x3_t __ret; \
+ bfloat16x4x3_t __s1 = __p1; \
+ __builtin_neon_vld3_lane_bf16(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 11); \
__ret; \
})
#else
-#define splatq_laneq_u16(__p0, __p1) __extension__ ({ \
- uint16x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 49); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splatq_laneq_u16(__p0, __p1) __extension__ ({ \
- uint16x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- __ret = (uint16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 49); \
+#define vld3_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4x3_t __ret; \
+ bfloat16x4x3_t __s1 = __p1; \
+ bfloat16x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vld3_lane_bf16(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 11); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_laneq_s8(__p0, __p1) __extension__ ({ \
- int8x16_t __ret; \
- int8x16_t __s0 = __p0; \
- __ret = (int8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 32); \
+#define vld4q_bf16(__p0) __extension__ ({ \
+ bfloat16x8x4_t __ret; \
+ __builtin_neon_vld4q_bf16(&__ret, __p0, 43); \
__ret; \
})
#else
-#define splatq_laneq_s8(__p0, __p1) __extension__ ({ \
- int8x16_t __ret; \
- int8x16_t __s0 = __p0; \
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 32); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splatq_laneq_s8(__p0, __p1) __extension__ ({ \
- int8x16_t __ret; \
- int8x16_t __s0 = __p0; \
- __ret = (int8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 32); \
+#define vld4q_bf16(__p0) __extension__ ({ \
+ bfloat16x8x4_t __ret; \
+ __builtin_neon_vld4q_bf16(&__ret, __p0, 43); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_laneq_f64(__p0, __p1) __extension__ ({ \
- float64x2_t __ret; \
- float64x2_t __s0 = __p0; \
- __ret = (float64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 42); \
+#define vld4_bf16(__p0) __extension__ ({ \
+ bfloat16x4x4_t __ret; \
+ __builtin_neon_vld4_bf16(&__ret, __p0, 11); \
__ret; \
})
#else
-#define splatq_laneq_f64(__p0, __p1) __extension__ ({ \
- float64x2_t __ret; \
- float64x2_t __s0 = __p0; \
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (float64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 42); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_splatq_laneq_f64(__p0, __p1) __extension__ ({ \
- float64x2_t __ret; \
- float64x2_t __s0 = __p0; \
- __ret = (float64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 42); \
+#define vld4_bf16(__p0) __extension__ ({ \
+ bfloat16x4x4_t __ret; \
+ __builtin_neon_vld4_bf16(&__ret, __p0, 11); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_laneq_f32(__p0, __p1) __extension__ ({ \
- float32x4_t __ret; \
- float32x4_t __s0 = __p0; \
- __ret = (float32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 41); \
+#define vld4q_dup_bf16(__p0) __extension__ ({ \
+ bfloat16x8x4_t __ret; \
+ __builtin_neon_vld4q_dup_bf16(&__ret, __p0, 43); \
__ret; \
})
#else
-#define splatq_laneq_f32(__p0, __p1) __extension__ ({ \
- float32x4_t __ret; \
- float32x4_t __s0 = __p0; \
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (float32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 41); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splatq_laneq_f32(__p0, __p1) __extension__ ({ \
- float32x4_t __ret; \
- float32x4_t __s0 = __p0; \
- __ret = (float32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 41); \
+#define vld4q_dup_bf16(__p0) __extension__ ({ \
+ bfloat16x8x4_t __ret; \
+ __builtin_neon_vld4q_dup_bf16(&__ret, __p0, 43); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_laneq_f16(__p0, __p1) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- __ret = (float16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 40); \
+#define vld4_dup_bf16(__p0) __extension__ ({ \
+ bfloat16x4x4_t __ret; \
+ __builtin_neon_vld4_dup_bf16(&__ret, __p0, 11); \
__ret; \
})
#else
-#define splatq_laneq_f16(__p0, __p1) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (float16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 40); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splatq_laneq_f16(__p0, __p1) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- __ret = (float16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 40); \
+#define vld4_dup_bf16(__p0) __extension__ ({ \
+ bfloat16x4x4_t __ret; \
+ __builtin_neon_vld4_dup_bf16(&__ret, __p0, 11); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_laneq_s32(__p0, __p1) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (int32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 34); \
+#define vld4q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8x4_t __ret; \
+ bfloat16x8x4_t __s1 = __p1; \
+ __builtin_neon_vld4q_lane_bf16(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 43); \
__ret; \
})
#else
-#define splatq_laneq_s32(__p0, __p1) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 34); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splatq_laneq_s32(__p0, __p1) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (int32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 34); \
+#define vld4q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8x4_t __ret; \
+ bfloat16x8x4_t __s1 = __p1; \
+ bfloat16x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld4q_lane_bf16(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 43); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_laneq_s64(__p0, __p1) __extension__ ({ \
- int64x2_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (int64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 35); \
+#define vld4_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4x4_t __ret; \
+ bfloat16x4x4_t __s1 = __p1; \
+ __builtin_neon_vld4_lane_bf16(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 11); \
__ret; \
})
#else
-#define splatq_laneq_s64(__p0, __p1) __extension__ ({ \
- int64x2_t __ret; \
- int64x2_t __s0 = __p0; \
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 35); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_splatq_laneq_s64(__p0, __p1) __extension__ ({ \
- int64x2_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (int64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 35); \
+#define vld4_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4x4_t __ret; \
+ bfloat16x4x4_t __s1 = __p1; \
+ bfloat16x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vld4_lane_bf16(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 11); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_laneq_s16(__p0, __p1) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (int16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 33); \
+#define vsetq_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8_t __ret; \
+ bfloat16_t __s0 = __p0; \
+ bfloat16x8_t __s1 = __p1; \
+ __ret = (bfloat16x8_t) __builtin_neon_vsetq_lane_bf16(__s0, (bfloat16x8_t)__s1, __p2); \
__ret; \
})
#else
-#define splatq_laneq_s16(__p0, __p1) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 33); \
+#define vsetq_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8_t __ret; \
+ bfloat16_t __s0 = __p0; \
+ bfloat16x8_t __s1 = __p1; \
+ bfloat16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (bfloat16x8_t) __builtin_neon_vsetq_lane_bf16(__s0, (bfloat16x8_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
-#define __noswap_splatq_laneq_s16(__p0, __p1) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (int16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 33); \
+#define __noswap_vsetq_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8_t __ret; \
+ bfloat16_t __s0 = __p0; \
+ bfloat16x8_t __s1 = __p1; \
+ __ret = (bfloat16x8_t) __builtin_neon_vsetq_lane_bf16(__s0, (bfloat16x8_t)__s1, __p2); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_laneq_u8(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- uint8x16_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 48); \
+#define vset_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4_t __ret; \
+ bfloat16_t __s0 = __p0; \
+ bfloat16x4_t __s1 = __p1; \
+ __ret = (bfloat16x4_t) __builtin_neon_vset_lane_bf16(__s0, (bfloat16x4_t)__s1, __p2); \
__ret; \
})
#else
-#define splat_laneq_u8(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- uint8x16_t __s0 = __p0; \
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 48); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vset_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4_t __ret; \
+ bfloat16_t __s0 = __p0; \
+ bfloat16x4_t __s1 = __p1; \
+ bfloat16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (bfloat16x4_t) __builtin_neon_vset_lane_bf16(__s0, (bfloat16x4_t)__rev1, __p2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
-#define __noswap_splat_laneq_u8(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- uint8x16_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 48); \
+#define __noswap_vset_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4_t __ret; \
+ bfloat16_t __s0 = __p0; \
+ bfloat16x4_t __s1 = __p1; \
+ __ret = (bfloat16x4_t) __builtin_neon_vset_lane_bf16(__s0, (bfloat16x4_t)__s1, __p2); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_laneq_u32(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- uint32x4_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 50); \
- __ret; \
+#define vst1q_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x8_t __s1 = __p1; \
+ __builtin_neon_vst1q_bf16(__p0, (int8x16_t)__s1, 43); \
})
#else
-#define splat_laneq_u32(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- uint32x4_t __s0 = __p0; \
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 50); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_splat_laneq_u32(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- uint32x4_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 50); \
- __ret; \
+#define vst1q_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x8_t __s1 = __p1; \
+ bfloat16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_bf16(__p0, (int8x16_t)__rev1, 43); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_laneq_u64(__p0, __p1) __extension__ ({ \
- uint64x1_t __ret; \
- uint64x2_t __s0 = __p0; \
- __ret = (uint64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 51); \
- __ret; \
+#define vst1_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x4_t __s1 = __p1; \
+ __builtin_neon_vst1_bf16(__p0, (int8x8_t)__s1, 11); \
})
#else
-#define splat_laneq_u64(__p0, __p1) __extension__ ({ \
- uint64x1_t __ret; \
- uint64x2_t __s0 = __p0; \
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 51); \
- __ret; \
-})
-#define __noswap_splat_laneq_u64(__p0, __p1) __extension__ ({ \
- uint64x1_t __ret; \
- uint64x2_t __s0 = __p0; \
- __ret = (uint64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 51); \
- __ret; \
+#define vst1_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x4_t __s1 = __p1; \
+ bfloat16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __builtin_neon_vst1_bf16(__p0, (int8x8_t)__rev1, 11); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_laneq_u16(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- uint16x8_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 49); \
- __ret; \
+#define vst1q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8_t __s1 = __p1; \
+ __builtin_neon_vst1q_lane_bf16(__p0, (int8x16_t)__s1, __p2, 43); \
})
#else
-#define splat_laneq_u16(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- uint16x8_t __s0 = __p0; \
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 49); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splat_laneq_u16(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- uint16x8_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 49); \
- __ret; \
+#define vst1q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8_t __s1 = __p1; \
+ bfloat16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_lane_bf16(__p0, (int8x16_t)__rev1, __p2, 43); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_laneq_s8(__p0, __p1) __extension__ ({ \
- int8x8_t __ret; \
- int8x16_t __s0 = __p0; \
- __ret = (int8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 32); \
- __ret; \
+#define vst1_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4_t __s1 = __p1; \
+ __builtin_neon_vst1_lane_bf16(__p0, (int8x8_t)__s1, __p2, 11); \
})
#else
-#define splat_laneq_s8(__p0, __p1) __extension__ ({ \
- int8x8_t __ret; \
- int8x16_t __s0 = __p0; \
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 32); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splat_laneq_s8(__p0, __p1) __extension__ ({ \
- int8x8_t __ret; \
- int8x16_t __s0 = __p0; \
- __ret = (int8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 32); \
- __ret; \
+#define vst1_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4_t __s1 = __p1; \
+ bfloat16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __builtin_neon_vst1_lane_bf16(__p0, (int8x8_t)__rev1, __p2, 11); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_laneq_f64(__p0, __p1) __extension__ ({ \
- float64x1_t __ret; \
- float64x2_t __s0 = __p0; \
- __ret = (float64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 42); \
- __ret; \
+#define vst1q_bf16_x2(__p0, __p1) __extension__ ({ \
+ bfloat16x8x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_bf16_x2(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 43); \
})
#else
-#define splat_laneq_f64(__p0, __p1) __extension__ ({ \
- float64x1_t __ret; \
- float64x2_t __s0 = __p0; \
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (float64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 42); \
- __ret; \
-})
-#define __noswap_splat_laneq_f64(__p0, __p1) __extension__ ({ \
- float64x1_t __ret; \
- float64x2_t __s0 = __p0; \
- __ret = (float64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 42); \
- __ret; \
+#define vst1q_bf16_x2(__p0, __p1) __extension__ ({ \
+ bfloat16x8x2_t __s1 = __p1; \
+ bfloat16x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_bf16_x2(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 43); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_laneq_f32(__p0, __p1) __extension__ ({ \
- float32x2_t __ret; \
- float32x4_t __s0 = __p0; \
- __ret = (float32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 41); \
- __ret; \
+#define vst1_bf16_x2(__p0, __p1) __extension__ ({ \
+ bfloat16x4x2_t __s1 = __p1; \
+ __builtin_neon_vst1_bf16_x2(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 11); \
})
#else
-#define splat_laneq_f32(__p0, __p1) __extension__ ({ \
- float32x2_t __ret; \
- float32x4_t __s0 = __p0; \
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (float32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 41); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_splat_laneq_f32(__p0, __p1) __extension__ ({ \
- float32x2_t __ret; \
- float32x4_t __s0 = __p0; \
- __ret = (float32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 41); \
- __ret; \
+#define vst1_bf16_x2(__p0, __p1) __extension__ ({ \
+ bfloat16x4x2_t __s1 = __p1; \
+ bfloat16x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vst1_bf16_x2(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 11); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_laneq_f16(__p0, __p1) __extension__ ({ \
- float16x4_t __ret; \
- float16x8_t __s0 = __p0; \
- __ret = (float16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 40); \
- __ret; \
+#define vst1q_bf16_x3(__p0, __p1) __extension__ ({ \
+ bfloat16x8x3_t __s1 = __p1; \
+ __builtin_neon_vst1q_bf16_x3(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 43); \
})
#else
-#define splat_laneq_f16(__p0, __p1) __extension__ ({ \
- float16x4_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (float16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 40); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splat_laneq_f16(__p0, __p1) __extension__ ({ \
- float16x4_t __ret; \
- float16x8_t __s0 = __p0; \
- __ret = (float16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 40); \
- __ret; \
+#define vst1q_bf16_x3(__p0, __p1) __extension__ ({ \
+ bfloat16x8x3_t __s1 = __p1; \
+ bfloat16x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_bf16_x3(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 43); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_laneq_s32(__p0, __p1) __extension__ ({ \
- int32x2_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (int32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 34); \
- __ret; \
+#define vst1_bf16_x3(__p0, __p1) __extension__ ({ \
+ bfloat16x4x3_t __s1 = __p1; \
+ __builtin_neon_vst1_bf16_x3(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 11); \
})
#else
-#define splat_laneq_s32(__p0, __p1) __extension__ ({ \
- int32x2_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 34); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_splat_laneq_s32(__p0, __p1) __extension__ ({ \
- int32x2_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (int32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 34); \
- __ret; \
+#define vst1_bf16_x3(__p0, __p1) __extension__ ({ \
+ bfloat16x4x3_t __s1 = __p1; \
+ bfloat16x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vst1_bf16_x3(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 11); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_laneq_s64(__p0, __p1) __extension__ ({ \
- int64x1_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (int64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 35); \
- __ret; \
+#define vst1q_bf16_x4(__p0, __p1) __extension__ ({ \
+ bfloat16x8x4_t __s1 = __p1; \
+ __builtin_neon_vst1q_bf16_x4(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 43); \
})
#else
-#define splat_laneq_s64(__p0, __p1) __extension__ ({ \
- int64x1_t __ret; \
- int64x2_t __s0 = __p0; \
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 35); \
- __ret; \
+#define vst1q_bf16_x4(__p0, __p1) __extension__ ({ \
+ bfloat16x8x4_t __s1 = __p1; \
+ bfloat16x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_bf16_x4(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 43); \
})
-#define __noswap_splat_laneq_s64(__p0, __p1) __extension__ ({ \
- int64x1_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (int64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 35); \
- __ret; \
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_bf16_x4(__p0, __p1) __extension__ ({ \
+ bfloat16x4x4_t __s1 = __p1; \
+ __builtin_neon_vst1_bf16_x4(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 11); \
+})
+#else
+#define vst1_bf16_x4(__p0, __p1) __extension__ ({ \
+ bfloat16x4x4_t __s1 = __p1; \
+ bfloat16x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vst1_bf16_x4(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 11); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_laneq_s16(__p0, __p1) __extension__ ({ \
- int16x4_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (int16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 33); \
- __ret; \
+#define vst2q_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x8x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_bf16(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 43); \
})
#else
-#define splat_laneq_s16(__p0, __p1) __extension__ ({ \
- int16x4_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 33); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
+#define vst2q_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x8x2_t __s1 = __p1; \
+ bfloat16x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2q_bf16(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 43); \
})
-#define __noswap_splat_laneq_s16(__p0, __p1) __extension__ ({ \
- int16x4_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (int16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 33); \
- __ret; \
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x4x2_t __s1 = __p1; \
+ __builtin_neon_vst2_bf16(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 11); \
+})
+#else
+#define vst2_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x4x2_t __s1 = __p1; \
+ bfloat16x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vst2_bf16(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 11); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vabdq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
- return __ret;
-}
+#define vst2q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_lane_bf16(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 43); \
+})
#else
-__ai uint8x16_t vabdq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-__ai uint8x16_t __noswap_vabdq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
- return __ret;
-}
+#define vst2q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8x2_t __s1 = __p1; \
+ bfloat16x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2q_lane_bf16(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 43); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vabdq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
- return __ret;
-}
+#define vst2_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4x2_t __s1 = __p1; \
+ __builtin_neon_vst2_lane_bf16(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 11); \
+})
#else
-__ai uint32x4_t vabdq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai uint32x4_t __noswap_vabdq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
- return __ret;
-}
+#define vst2_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4x2_t __s1 = __p1; \
+ bfloat16x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vst2_lane_bf16(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 11); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vabdq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
- return __ret;
-}
+#define vst3q_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x8x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_bf16(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 43); \
+})
#else
-__ai uint16x8_t vabdq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-__ai uint16x8_t __noswap_vabdq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
- return __ret;
-}
+#define vst3q_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x8x3_t __s1 = __p1; \
+ bfloat16x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3q_bf16(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 43); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vabdq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
- return __ret;
-}
+#define vst3_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x4x3_t __s1 = __p1; \
+ __builtin_neon_vst3_bf16(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 11); \
+})
#else
-__ai int8x16_t vabdq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-__ai int8x16_t __noswap_vabdq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
- return __ret;
-}
+#define vst3_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x4x3_t __s1 = __p1; \
+ bfloat16x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vst3_bf16(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 11); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vabdq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
- return __ret;
-}
+#define vst3q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_lane_bf16(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 43); \
+})
#else
-__ai float32x4_t vabdq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8x3_t __s1 = __p1; \
+ bfloat16x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3q_lane_bf16(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 43); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vabdq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
- return __ret;
-}
+#define vst3_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4x3_t __s1 = __p1; \
+ __builtin_neon_vst3_lane_bf16(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 11); \
+})
#else
-__ai int32x4_t vabdq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai int32x4_t __noswap_vabdq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
- return __ret;
-}
+#define vst3_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4x3_t __s1 = __p1; \
+ bfloat16x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vst3_lane_bf16(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 11); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vabdq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+#define vst4q_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x8x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_bf16(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 43); \
+})
+#else
+#define vst4q_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x8x4_t __s1 = __p1; \
+ bfloat16x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4q_bf16(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 43); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x4x4_t __s1 = __p1; \
+ __builtin_neon_vst4_bf16(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 11); \
+})
+#else
+#define vst4_bf16(__p0, __p1) __extension__ ({ \
+ bfloat16x4x4_t __s1 = __p1; \
+ bfloat16x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vst4_bf16(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 11); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_lane_bf16(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 43); \
+})
+#else
+#define vst4q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x8x4_t __s1 = __p1; \
+ bfloat16x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4q_lane_bf16(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 43); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4x4_t __s1 = __p1; \
+ __builtin_neon_vst4_lane_bf16(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 11); \
+})
+#else
+#define vst4_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+ bfloat16x4x4_t __s1 = __p1; \
+ bfloat16x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vst4_lane_bf16(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 11); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("dotprod,neon"))) uint32x4_t vdotq_u32(uint32x4_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vdotq_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
return __ret;
}
#else
-__ai int16x8_t vabdq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("dotprod,neon"))) uint32x4_t vdotq_u32(uint32x4_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vdotq_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int16x8_t __noswap_vabdq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+__ai __attribute__((target("dotprod,neon"))) uint32x4_t __noswap_vdotq_u32(uint32x4_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vdotq_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vabd_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+__ai __attribute__((target("dotprod,neon"))) int32x4_t vdotq_s32(int32x4_t __p0, int8x16_t __p1, int8x16_t __p2) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vdotq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
return __ret;
}
#else
-__ai uint8x8_t vabd_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("dotprod,neon"))) int32x4_t vdotq_s32(int32x4_t __p0, int8x16_t __p1, int8x16_t __p2) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vdotq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai uint8x8_t __noswap_vabd_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+__ai __attribute__((target("dotprod,neon"))) int32x4_t __noswap_vdotq_s32(int32x4_t __p0, int8x16_t __p1, int8x16_t __p2) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vdotq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vabd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("dotprod,neon"))) uint32x2_t vdot_u32(uint32x2_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ __ret = (uint32x2_t) __builtin_neon_vdot_u32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 18);
return __ret;
}
#else
-__ai uint32x2_t vabd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("dotprod,neon"))) uint32x2_t vdot_u32(uint32x2_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vdot_u32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 18);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai uint32x2_t __noswap_vabd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("dotprod,neon"))) uint32x2_t __noswap_vdot_u32(uint32x2_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ __ret = (uint32x2_t) __builtin_neon_vdot_u32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 18);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vabd_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+__ai __attribute__((target("dotprod,neon"))) int32x2_t vdot_s32(int32x2_t __p0, int8x8_t __p1, int8x8_t __p2) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vdot_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
return __ret;
}
#else
-__ai uint16x4_t vabd_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("dotprod,neon"))) int32x2_t vdot_s32(int32x2_t __p0, int8x8_t __p1, int8x8_t __p2) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vdot_s32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai uint16x4_t __noswap_vabd_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+__ai __attribute__((target("dotprod,neon"))) int32x2_t __noswap_vdot_s32(int32x2_t __p0, int8x8_t __p1, int8x8_t __p2) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vdot_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vabd_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vabdq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vabdq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
return __ret;
}
#else
-__ai int8x8_t vabd_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vabdq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vabdq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai int8x8_t __noswap_vabd_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vabd_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vabd_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vabd_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
return __ret;
}
#else
-__ai float32x2_t vabd_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vabd_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vabd_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vabd_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vabsq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vabsq_f16((int8x16_t)__p0, 40);
return __ret;
}
#else
-__ai int32x2_t vabd_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai int32x2_t __noswap_vabd_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vabsq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vabsq_f16((int8x16_t)__rev0, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vabd_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vabs_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vabs_f16((int8x8_t)__p0, 8);
return __ret;
}
#else
-__ai int16x4_t vabd_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vabs_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vabs_f16((int8x8_t)__rev0, 8);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int16x4_t __noswap_vabd_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vabsq_s8(int8x16_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vabsq_v((int8x16_t)__p0, 32);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vaddq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = __p0 + __p1;
return __ret;
}
#else
-__ai int8x16_t vabsq_s8(int8x16_t __p0) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vabsq_v((int8x16_t)__rev0, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vaddq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vabsq_f32(float32x4_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vabsq_v((int8x16_t)__p0, 41);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vadd_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = __p0 + __p1;
return __ret;
}
#else
-__ai float32x4_t vabsq_f32(float32x4_t __p0) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vabsq_v((int8x16_t)__rev0, 41);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vadd_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vabsq_s32(int32x4_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vabsq_v((int8x16_t)__p0, 34);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcageq_f16(float16x8_t __p0, float16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vcageq_f16((int8x16_t)__p0, (int8x16_t)__p1, 49);
return __ret;
}
#else
-__ai int32x4_t vabsq_s32(int32x4_t __p0) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vabsq_v((int8x16_t)__rev0, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcageq_f16(float16x8_t __p0, float16x8_t __p1) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vcageq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vabsq_s16(int16x8_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vabsq_v((int8x16_t)__p0, 33);
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcage_f16(float16x4_t __p0, float16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vcage_f16((int8x8_t)__p0, (int8x8_t)__p1, 17);
return __ret;
}
#else
-__ai int16x8_t vabsq_s16(int16x8_t __p0) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vabsq_v((int8x16_t)__rev0, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcage_f16(float16x4_t __p0, float16x4_t __p1) {
+ uint16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vcage_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vabs_s8(int8x8_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vabs_v((int8x8_t)__p0, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcagtq_f16(float16x8_t __p0, float16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vcagtq_f16((int8x16_t)__p0, (int8x16_t)__p1, 49);
return __ret;
}
#else
-__ai int8x8_t vabs_s8(int8x8_t __p0) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vabs_v((int8x8_t)__rev0, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcagtq_f16(float16x8_t __p0, float16x8_t __p1) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vcagtq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vabs_f32(float32x2_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vabs_v((int8x8_t)__p0, 9);
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcagt_f16(float16x4_t __p0, float16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vcagt_f16((int8x8_t)__p0, (int8x8_t)__p1, 17);
return __ret;
}
#else
-__ai float32x2_t vabs_f32(float32x2_t __p0) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vabs_v((int8x8_t)__rev0, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcagt_f16(float16x4_t __p0, float16x4_t __p1) {
+ uint16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vcagt_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vabs_s32(int32x2_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vabs_v((int8x8_t)__p0, 2);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcaleq_f16(float16x8_t __p0, float16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vcaleq_f16((int8x16_t)__p0, (int8x16_t)__p1, 49);
return __ret;
}
#else
-__ai int32x2_t vabs_s32(int32x2_t __p0) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vabs_v((int8x8_t)__rev0, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcaleq_f16(float16x8_t __p0, float16x8_t __p1) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vcaleq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vabs_s16(int16x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vabs_v((int8x8_t)__p0, 1);
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcale_f16(float16x4_t __p0, float16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vcale_f16((int8x8_t)__p0, (int8x8_t)__p1, 17);
return __ret;
}
#else
-__ai int16x4_t vabs_s16(int16x4_t __p0) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vabs_v((int8x8_t)__rev0, 1);
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcale_f16(float16x4_t __p0, float16x4_t __p1) {
+ uint16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vcale_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = __p0 + __p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcaltq_f16(float16x8_t __p0, float16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vcaltq_f16((int8x16_t)__p0, (int8x16_t)__p1, 49);
return __ret;
}
#else
-__ai uint8x16_t vaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 + __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcaltq_f16(float16x8_t __p0, float16x8_t __p1) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vcaltq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = __p0 + __p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcalt_f16(float16x4_t __p0, float16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vcalt_f16((int8x8_t)__p0, (int8x8_t)__p1, 17);
return __ret;
}
#else
-__ai uint32x4_t vaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 + __rev1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcalt_f16(float16x4_t __p0, float16x4_t __p1) {
+ uint16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vcalt_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vaddq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- __ret = __p0 + __p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vceqq_f16(float16x8_t __p0, float16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0 == __p1);
return __ret;
}
#else
-__ai uint64x2_t vaddq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 + __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vceqq_f16(float16x8_t __p0, float16x8_t __p1) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t)(__rev0 == __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = __p0 + __p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vceq_f16(float16x4_t __p0, float16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0 == __p1);
return __ret;
}
#else
-__ai uint16x8_t vaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 + __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vceq_f16(float16x4_t __p0, float16x4_t __p1) {
+ uint16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t)(__rev0 == __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vaddq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = __p0 + __p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vceqzq_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vceqzq_f16((int8x16_t)__p0, 49);
return __ret;
}
#else
-__ai int8x16_t vaddq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 + __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vceqzq_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vceqzq_f16((int8x16_t)__rev0, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vaddq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = __p0 + __p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vceqz_f16(float16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vceqz_f16((int8x8_t)__p0, 17);
return __ret;
}
#else
-__ai float32x4_t vaddq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 + __rev1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vceqz_f16(float16x4_t __p0) {
+ uint16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vceqz_f16((int8x8_t)__rev0, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vaddq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = __p0 + __p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcgeq_f16(float16x8_t __p0, float16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0 >= __p1);
return __ret;
}
#else
-__ai int32x4_t vaddq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 + __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcgeq_f16(float16x8_t __p0, float16x8_t __p1) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vaddq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- __ret = __p0 + __p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcge_f16(float16x4_t __p0, float16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0 >= __p1);
return __ret;
}
#else
-__ai int64x2_t vaddq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 + __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcge_f16(float16x4_t __p0, float16x4_t __p1) {
+ uint16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vaddq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = __p0 + __p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcgezq_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vcgezq_f16((int8x16_t)__p0, 49);
return __ret;
}
#else
-__ai int16x8_t vaddq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 + __rev1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcgezq_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vcgezq_f16((int8x16_t)__rev0, 49);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = __p0 + __p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcgez_f16(float16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vcgez_f16((int8x8_t)__p0, 17);
return __ret;
}
#else
-__ai uint8x8_t vadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 + __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcgez_f16(float16x4_t __p0) {
+ uint16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vcgez_f16((int8x8_t)__rev0, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = __p0 + __p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcgtq_f16(float16x8_t __p0, float16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0 > __p1);
return __ret;
}
#else
-__ai uint32x2_t vadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 + __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcgtq_f16(float16x8_t __p0, float16x8_t __p1) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t)(__rev0 > __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vadd_u64(uint64x1_t __p0, uint64x1_t __p1) {
- uint64x1_t __ret;
- __ret = __p0 + __p1;
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcgt_f16(float16x4_t __p0, float16x4_t __p1) {
uint16x4_t __ret;
- __ret = __p0 + __p1;
+ __ret = (uint16x4_t)(__p0 > __p1);
return __ret;
}
#else
-__ai uint16x4_t vadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcgt_f16(float16x4_t __p0, float16x4_t __p1) {
uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 + __rev1;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t)(__rev0 > __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vadd_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = __p0 + __p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcgtzq_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vcgtzq_f16((int8x16_t)__p0, 49);
return __ret;
}
#else
-__ai int8x8_t vadd_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 + __rev1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcgtzq_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vcgtzq_f16((int8x16_t)__rev0, 49);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vadd_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = __p0 + __p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcgtz_f16(float16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vcgtz_f16((int8x8_t)__p0, 17);
return __ret;
}
#else
-__ai float32x2_t vadd_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 + __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcgtz_f16(float16x4_t __p0) {
+ uint16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vcgtz_f16((int8x8_t)__rev0, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vadd_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = __p0 + __p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcleq_f16(float16x8_t __p0, float16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0 <= __p1);
return __ret;
}
#else
-__ai int32x2_t vadd_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 + __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcleq_f16(float16x8_t __p0, float16x8_t __p1) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t)(__rev0 <= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai int64x1_t vadd_s64(int64x1_t __p0, int64x1_t __p1) {
- int64x1_t __ret;
- __ret = __p0 + __p1;
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vadd_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = __p0 + __p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcle_f16(float16x4_t __p0, float16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0 <= __p1);
return __ret;
}
#else
-__ai int16x4_t vadd_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 + __rev1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcle_f16(float16x4_t __p0, float16x4_t __p1) {
+ uint16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t)(__rev0 <= __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vadd_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vadd_v((int8x8_t)__p0, (int8x8_t)__p1, 4);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vclezq_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vclezq_f16((int8x16_t)__p0, 49);
return __ret;
}
#else
-__ai poly8x8_t vadd_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 4);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vclezq_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vclezq_f16((int8x16_t)__rev0, 49);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai poly64x1_t vadd_p64(poly64x1_t __p0, poly64x1_t __p1) {
- poly64x1_t __ret;
- __ret = (poly64x1_t) __builtin_neon_vadd_v((int8x8_t)__p0, (int8x8_t)__p1, 6);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai poly16x4_t vadd_p16(poly16x4_t __p0, poly16x4_t __p1) {
- poly16x4_t __ret;
- __ret = (poly16x4_t) __builtin_neon_vadd_v((int8x8_t)__p0, (int8x8_t)__p1, 5);
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vclez_f16(float16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vclez_f16((int8x8_t)__p0, 17);
return __ret;
}
#else
-__ai poly16x4_t vadd_p16(poly16x4_t __p0, poly16x4_t __p1) {
- poly16x4_t __ret;
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (poly16x4_t) __builtin_neon_vadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 5);
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vclez_f16(float16x4_t __p0) {
+ uint16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vclez_f16((int8x8_t)__rev0, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vaddq_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly8x16_t __ret;
- __ret = (poly8x16_t) __builtin_neon_vaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 36);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcltq_f16(float16x8_t __p0, float16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0 < __p1);
return __ret;
}
#else
-__ai poly8x16_t vaddq_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x16_t) __builtin_neon_vaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 36);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcltq_f16(float16x8_t __p0, float16x8_t __p1) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t)(__rev0 < __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly64x2_t vaddq_p64(poly64x2_t __p0, poly64x2_t __p1) {
- poly64x2_t __ret;
- __ret = (poly64x2_t) __builtin_neon_vaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 38);
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vclt_f16(float16x4_t __p0, float16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0 < __p1);
return __ret;
}
#else
-__ai poly64x2_t vaddq_p64(poly64x2_t __p0, poly64x2_t __p1) {
- poly64x2_t __ret;
- poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (poly64x2_t) __builtin_neon_vaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 38);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vclt_f16(float16x4_t __p0, float16x4_t __p1) {
+ uint16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t)(__rev0 < __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x8_t vaddq_p16(poly16x8_t __p0, poly16x8_t __p1) {
- poly16x8_t __ret;
- __ret = (poly16x8_t) __builtin_neon_vaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 37);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcltzq_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vcltzq_f16((int8x16_t)__p0, 49);
return __ret;
}
#else
-__ai poly16x8_t vaddq_p16(poly16x8_t __p0, poly16x8_t __p1) {
- poly16x8_t __ret;
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly16x8_t) __builtin_neon_vaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 37);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcltzq_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vcltzq_f16((int8x16_t)__rev0, 49);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vaddhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcltz_f16(float16x4_t __p0) {
uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
+ __ret = (uint16x4_t) __builtin_neon_vcltz_f16((int8x8_t)__p0, 17);
return __ret;
}
#else
-__ai uint16x4_t vaddhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcltz_f16(float16x4_t __p0) {
uint16x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vaddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 17);
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vcltz_f16((int8x8_t)__rev0, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai uint16x4_t __noswap_vaddhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vaddhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vcvtq_f16_u16(uint16x8_t __p0) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vcvtq_f16_u16((int8x16_t)__p0, 49);
return __ret;
}
#else
-__ai uint32x2_t vaddhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint32x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vaddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai uint32x2_t __noswap_vaddhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vcvtq_f16_u16(uint16x8_t __p0) {
+ float16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vcvtq_f16_u16((int8x16_t)__rev0, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vaddhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vcvtq_f16_s16(int16x8_t __p0) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vcvtq_f16_s16((int8x16_t)__p0, 33);
return __ret;
}
#else
-__ai uint8x8_t vaddhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint8x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vaddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 16);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vcvtq_f16_s16(int16x8_t __p0) {
+ float16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vcvtq_f16_s16((int8x16_t)__rev0, 33);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai uint8x8_t __noswap_vaddhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vaddhn_s32(int32x4_t __p0, int32x4_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vcvt_f16_u16(uint16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vcvt_f16_u16((int8x8_t)__p0, 17);
return __ret;
}
#else
-__ai int16x4_t vaddhn_s32(int32x4_t __p0, int32x4_t __p1) {
- int16x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vaddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 1);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vcvt_f16_u16(uint16x4_t __p0) {
+ float16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vcvt_f16_u16((int8x8_t)__rev0, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int16x4_t __noswap_vaddhn_s32(int32x4_t __p0, int32x4_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vaddhn_s64(int64x2_t __p0, int64x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vcvt_f16_s16(int16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vcvt_f16_s16((int8x8_t)__p0, 1);
return __ret;
}
#else
-__ai int32x2_t vaddhn_s64(int64x2_t __p0, int64x2_t __p1) {
- int32x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vaddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai int32x2_t __noswap_vaddhn_s64(int64x2_t __p0, int64x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vcvt_f16_s16(int16x4_t __p0) {
+ float16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vcvt_f16_s16((int8x8_t)__rev0, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vaddhn_s16(int16x8_t __p0, int16x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
- return __ret;
-}
+#define vcvtq_n_f16_u16(__p0, __p1) __extension__ ({ \
+ float16x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ __ret = (float16x8_t) __builtin_neon_vcvtq_n_f16_u16((int8x16_t)__s0, __p1, 49); \
+ __ret; \
+})
#else
-__ai int8x8_t vaddhn_s16(int16x8_t __p0, int16x8_t __p1) {
- int8x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vaddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-__ai int8x8_t __noswap_vaddhn_s16(int16x8_t __p0, int16x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
- return __ret;
-}
+#define vcvtq_n_f16_u16(__p0, __p1) __extension__ ({ \
+ float16x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (float16x8_t) __builtin_neon_vcvtq_n_f16_u16((int8x16_t)__rev0, __p1, 49); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vandq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = __p0 & __p1;
- return __ret;
-}
+#define vcvtq_n_f16_s16(__p0, __p1) __extension__ ({ \
+ float16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (float16x8_t) __builtin_neon_vcvtq_n_f16_s16((int8x16_t)__s0, __p1, 33); \
+ __ret; \
+})
#else
-__ai uint8x16_t vandq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 & __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vcvtq_n_f16_s16(__p0, __p1) __extension__ ({ \
+ float16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (float16x8_t) __builtin_neon_vcvtq_n_f16_s16((int8x16_t)__rev0, __p1, 33); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vandq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = __p0 & __p1;
- return __ret;
-}
+#define vcvt_n_f16_u16(__p0, __p1) __extension__ ({ \
+ float16x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ __ret = (float16x4_t) __builtin_neon_vcvt_n_f16_u16((int8x8_t)__s0, __p1, 17); \
+ __ret; \
+})
#else
-__ai uint32x4_t vandq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 & __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vcvt_n_f16_u16(__p0, __p1) __extension__ ({ \
+ float16x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (float16x4_t) __builtin_neon_vcvt_n_f16_u16((int8x8_t)__rev0, __p1, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vandq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- __ret = __p0 & __p1;
- return __ret;
-}
+#define vcvt_n_f16_s16(__p0, __p1) __extension__ ({ \
+ float16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ __ret = (float16x4_t) __builtin_neon_vcvt_n_f16_s16((int8x8_t)__s0, __p1, 1); \
+ __ret; \
+})
#else
-__ai uint64x2_t vandq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 & __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vcvt_n_f16_s16(__p0, __p1) __extension__ ({ \
+ float16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (float16x4_t) __builtin_neon_vcvt_n_f16_s16((int8x8_t)__rev0, __p1, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vandq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = __p0 & __p1;
- return __ret;
-}
+#define vcvtq_n_s16_f16(__p0, __p1) __extension__ ({ \
+ int16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ __ret = (int16x8_t) __builtin_neon_vcvtq_n_s16_f16((int8x16_t)__s0, __p1, 33); \
+ __ret; \
+})
#else
-__ai uint16x8_t vandq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 & __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vcvtq_n_s16_f16(__p0, __p1) __extension__ ({ \
+ int16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int16x8_t) __builtin_neon_vcvtq_n_s16_f16((int8x16_t)__rev0, __p1, 33); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vandq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = __p0 & __p1;
- return __ret;
-}
+#define vcvt_n_s16_f16(__p0, __p1) __extension__ ({ \
+ int16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ __ret = (int16x4_t) __builtin_neon_vcvt_n_s16_f16((int8x8_t)__s0, __p1, 1); \
+ __ret; \
+})
#else
-__ai int8x16_t vandq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 & __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vcvt_n_s16_f16(__p0, __p1) __extension__ ({ \
+ int16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (int16x4_t) __builtin_neon_vcvt_n_s16_f16((int8x8_t)__rev0, __p1, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vandq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = __p0 & __p1;
- return __ret;
-}
+#define vcvtq_n_u16_f16(__p0, __p1) __extension__ ({ \
+ uint16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ __ret = (uint16x8_t) __builtin_neon_vcvtq_n_u16_f16((int8x16_t)__s0, __p1, 49); \
+ __ret; \
+})
#else
-__ai int32x4_t vandq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 & __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vcvtq_n_u16_f16(__p0, __p1) __extension__ ({ \
+ uint16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint16x8_t) __builtin_neon_vcvtq_n_u16_f16((int8x16_t)__rev0, __p1, 49); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vandq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- __ret = __p0 & __p1;
- return __ret;
-}
+#define vcvt_n_u16_f16(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ __ret = (uint16x4_t) __builtin_neon_vcvt_n_u16_f16((int8x8_t)__s0, __p1, 17); \
+ __ret; \
+})
#else
-__ai int64x2_t vandq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 & __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vcvt_n_u16_f16(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint16x4_t) __builtin_neon_vcvt_n_u16_f16((int8x8_t)__rev0, __p1, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vandq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtq_s16_f16(float16x8_t __p0) {
int16x8_t __ret;
- __ret = __p0 & __p1;
+ __ret = (int16x8_t) __builtin_neon_vcvtq_s16_f16((int8x16_t)__p0, 33);
return __ret;
}
#else
-__ai int16x8_t vandq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtq_s16_f16(float16x8_t __p0) {
int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 & __rev1;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vcvtq_s16_f16((int8x16_t)__rev0, 33);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vand_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = __p0 & __p1;
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvt_s16_f16(float16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vcvt_s16_f16((int8x8_t)__p0, 1);
return __ret;
}
#else
-__ai uint8x8_t vand_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 & __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvt_s16_f16(float16x4_t __p0) {
+ int16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vcvt_s16_f16((int8x8_t)__rev0, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vand_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = __p0 & __p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtq_u16_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vcvtq_u16_f16((int8x16_t)__p0, 49);
return __ret;
}
#else
-__ai uint32x2_t vand_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 & __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtq_u16_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vcvtq_u16_f16((int8x16_t)__rev0, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vand_u64(uint64x1_t __p0, uint64x1_t __p1) {
- uint64x1_t __ret;
- __ret = __p0 & __p1;
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vand_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvt_u16_f16(float16x4_t __p0) {
uint16x4_t __ret;
- __ret = __p0 & __p1;
+ __ret = (uint16x4_t) __builtin_neon_vcvt_u16_f16((int8x8_t)__p0, 17);
return __ret;
}
#else
-__ai uint16x4_t vand_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvt_u16_f16(float16x4_t __p0) {
uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 & __rev1;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vcvt_u16_f16((int8x8_t)__rev0, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vand_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = __p0 & __p1;
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtaq_s16_f16(float16x8_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vcvtaq_s16_f16((int8x16_t)__p0, 33);
return __ret;
}
#else
-__ai int8x8_t vand_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 & __rev1;
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtaq_s16_f16(float16x8_t __p0) {
+ int16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vcvtaq_s16_f16((int8x16_t)__rev0, 33);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vand_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = __p0 & __p1;
- return __ret;
-}
-#else
-__ai int32x2_t vand_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 & __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-__ai int64x1_t vand_s64(int64x1_t __p0, int64x1_t __p1) {
- int64x1_t __ret;
- __ret = __p0 & __p1;
- return __ret;
-}
-#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vand_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvta_s16_f16(float16x4_t __p0) {
int16x4_t __ret;
- __ret = __p0 & __p1;
+ __ret = (int16x4_t) __builtin_neon_vcvta_s16_f16((int8x8_t)__p0, 1);
return __ret;
}
#else
-__ai int16x4_t vand_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvta_s16_f16(float16x4_t __p0) {
int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 & __rev1;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vcvta_s16_f16((int8x8_t)__rev0, 1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vbicq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = __p0 & ~__p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtaq_u16_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vcvtaq_u16_f16((int8x16_t)__p0, 49);
return __ret;
}
#else
-__ai uint8x16_t vbicq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 & ~__rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtaq_u16_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vcvtaq_u16_f16((int8x16_t)__rev0, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vbicq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = __p0 & ~__p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvta_u16_f16(float16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vcvta_u16_f16((int8x8_t)__p0, 17);
return __ret;
}
#else
-__ai uint32x4_t vbicq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 & ~__rev1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvta_u16_f16(float16x4_t __p0) {
+ uint16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vcvta_u16_f16((int8x8_t)__rev0, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vbicq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- __ret = __p0 & ~__p1;
- return __ret;
-}
-#else
-__ai uint64x2_t vbicq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 & ~__rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vbicq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = __p0 & ~__p1;
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtmq_s16_f16(float16x8_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vcvtmq_s16_f16((int8x16_t)__p0, 33);
return __ret;
}
#else
-__ai uint16x8_t vbicq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 & ~__rev1;
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtmq_s16_f16(float16x8_t __p0) {
+ int16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vcvtmq_s16_f16((int8x16_t)__rev0, 33);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vbicq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = __p0 & ~__p1;
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvtm_s16_f16(float16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vcvtm_s16_f16((int8x8_t)__p0, 1);
return __ret;
}
#else
-__ai int8x16_t vbicq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 & ~__rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvtm_s16_f16(float16x4_t __p0) {
+ int16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vcvtm_s16_f16((int8x8_t)__rev0, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vbicq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = __p0 & ~__p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtmq_u16_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vcvtmq_u16_f16((int8x16_t)__p0, 49);
return __ret;
}
#else
-__ai int32x4_t vbicq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 & ~__rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtmq_u16_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vcvtmq_u16_f16((int8x16_t)__rev0, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vbicq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- __ret = __p0 & ~__p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvtm_u16_f16(float16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vcvtm_u16_f16((int8x8_t)__p0, 17);
return __ret;
}
#else
-__ai int64x2_t vbicq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 & ~__rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvtm_u16_f16(float16x4_t __p0) {
+ uint16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vcvtm_u16_f16((int8x8_t)__rev0, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vbicq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtnq_s16_f16(float16x8_t __p0) {
int16x8_t __ret;
- __ret = __p0 & ~__p1;
+ __ret = (int16x8_t) __builtin_neon_vcvtnq_s16_f16((int8x16_t)__p0, 33);
return __ret;
}
#else
-__ai int16x8_t vbicq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtnq_s16_f16(float16x8_t __p0) {
int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 & ~__rev1;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vcvtnq_s16_f16((int8x16_t)__rev0, 33);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vbic_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = __p0 & ~__p1;
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvtn_s16_f16(float16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vcvtn_s16_f16((int8x8_t)__p0, 1);
return __ret;
}
#else
-__ai uint8x8_t vbic_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 & ~__rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvtn_s16_f16(float16x4_t __p0) {
+ int16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vcvtn_s16_f16((int8x8_t)__rev0, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vbic_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = __p0 & ~__p1;
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtnq_u16_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vcvtnq_u16_f16((int8x16_t)__p0, 49);
return __ret;
}
#else
-__ai uint32x2_t vbic_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 & ~__rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtnq_u16_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vcvtnq_u16_f16((int8x16_t)__rev0, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vbic_u64(uint64x1_t __p0, uint64x1_t __p1) {
- uint64x1_t __ret;
- __ret = __p0 & ~__p1;
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vbic_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvtn_u16_f16(float16x4_t __p0) {
uint16x4_t __ret;
- __ret = __p0 & ~__p1;
+ __ret = (uint16x4_t) __builtin_neon_vcvtn_u16_f16((int8x8_t)__p0, 17);
return __ret;
}
#else
-__ai uint16x4_t vbic_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvtn_u16_f16(float16x4_t __p0) {
uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 & ~__rev1;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vcvtn_u16_f16((int8x8_t)__rev0, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vbic_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = __p0 & ~__p1;
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtpq_s16_f16(float16x8_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vcvtpq_s16_f16((int8x16_t)__p0, 33);
return __ret;
}
#else
-__ai int8x8_t vbic_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 & ~__rev1;
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtpq_s16_f16(float16x8_t __p0) {
+ int16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vcvtpq_s16_f16((int8x16_t)__rev0, 33);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vbic_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = __p0 & ~__p1;
- return __ret;
-}
-#else
-__ai int32x2_t vbic_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 & ~__rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-__ai int64x1_t vbic_s64(int64x1_t __p0, int64x1_t __p1) {
- int64x1_t __ret;
- __ret = __p0 & ~__p1;
- return __ret;
-}
-#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vbic_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvtp_s16_f16(float16x4_t __p0) {
int16x4_t __ret;
- __ret = __p0 & ~__p1;
+ __ret = (int16x4_t) __builtin_neon_vcvtp_s16_f16((int8x8_t)__p0, 1);
return __ret;
}
#else
-__ai int16x4_t vbic_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvtp_s16_f16(float16x4_t __p0) {
int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 & ~__rev1;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vcvtp_s16_f16((int8x8_t)__rev0, 1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vbsl_p8(uint8x8_t __p0, poly8x8_t __p1, poly8x8_t __p2) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 4);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtpq_u16_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vcvtpq_u16_f16((int8x16_t)__p0, 49);
return __ret;
}
#else
-__ai poly8x8_t vbsl_p8(uint8x8_t __p0, poly8x8_t __p1, poly8x8_t __p2) {
- poly8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 4);
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtpq_u16_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vcvtpq_u16_f16((int8x16_t)__rev0, 49);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x4_t vbsl_p16(uint16x4_t __p0, poly16x4_t __p1, poly16x4_t __p2) {
- poly16x4_t __ret;
- __ret = (poly16x4_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 5);
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvtp_u16_f16(float16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vcvtp_u16_f16((int8x8_t)__p0, 17);
return __ret;
}
#else
-__ai poly16x4_t vbsl_p16(uint16x4_t __p0, poly16x4_t __p1, poly16x4_t __p2) {
- poly16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- poly16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (poly16x4_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 5);
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvtp_u16_f16(float16x4_t __p0) {
+ uint16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vcvtp_u16_f16((int8x8_t)__rev0, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vbslq_p8(uint8x16_t __p0, poly8x16_t __p1, poly8x16_t __p2) {
- poly8x16_t __ret;
- __ret = (poly8x16_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 36);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vfmaq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vfmaq_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
return __ret;
}
#else
-__ai poly8x16_t vbslq_p8(uint8x16_t __p0, poly8x16_t __p1, poly8x16_t __p2) {
- poly8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x16_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 36);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vfmaq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vfmaq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t __noswap_vfmaq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vfmaq_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x8_t vbslq_p16(uint16x8_t __p0, poly16x8_t __p1, poly16x8_t __p2) {
- poly16x8_t __ret;
- __ret = (poly16x8_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 37);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vfma_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vfma_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
return __ret;
}
#else
-__ai poly16x8_t vbslq_p16(uint16x8_t __p0, poly16x8_t __p1, poly16x8_t __p2) {
- poly16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- poly16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly16x8_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 37);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vfma_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vfma_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t __noswap_vfma_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vfma_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vbslq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 48);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vfmsq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
+ __ret = vfmaq_f16(__p0, -__p1, __p2);
return __ret;
}
#else
-__ai uint8x16_t vbslq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vfmsq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vfmaq_f16(__rev0, -__rev1, __rev2);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vbslq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vfms_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
+ __ret = vfma_f16(__p0, -__p1, __p2);
return __ret;
}
#else
-__ai uint32x4_t vbslq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- uint32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 50);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vfms_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __noswap_vfma_f16(__rev0, -__rev1, __rev2);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vbslq_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 51);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vmaxq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vmaxq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
return __ret;
}
#else
-__ai uint64x2_t vbslq_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- uint64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vmaxq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vmaxq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vbslq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 49);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmax_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vmax_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
return __ret;
}
#else
-__ai uint16x8_t vbslq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmax_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vmax_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vbslq_s8(uint8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 32);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vminq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vminq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
return __ret;
}
#else
-__ai int8x16_t vbslq_s8(uint8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
- int8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vminq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vminq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vbslq_f32(uint32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmin_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vmin_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
return __ret;
}
#else
-__ai float32x4_t vbslq_f32(uint32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
- float32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- float32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmin_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vmin_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vbslq_s32(uint32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vmulq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = __p0 * __p1;
return __ret;
}
#else
-__ai int32x4_t vbslq_s32(uint32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vmulq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 * __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vbslq_s64(uint64x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 35);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmul_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = __p0 * __p1;
return __ret;
}
#else
-__ai int64x2_t vbslq_s64(uint64x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
- int64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- int64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 35);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmul_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 * __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vbslq_s16(uint16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
- return __ret;
-}
-#else
-__ai int16x8_t vbslq_s16(uint16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vbsl_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 16);
- return __ret;
-}
-#else
-__ai uint8x8_t vbsl_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vbsl_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 18);
- return __ret;
-}
+#define vmulq_n_f16(__p0, __p1) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16_t __s1 = __p1; \
+ __ret = __s0 * (float16x8_t) {__s1, __s1, __s1, __s1, __s1, __s1, __s1, __s1}; \
+ __ret; \
+})
#else
-__ai uint32x2_t vbsl_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- uint32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vmulq_n_f16(__p0, __p1) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16_t __s1 = __p1; \
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = __rev0 * (float16x8_t) {__s1, __s1, __s1, __s1, __s1, __s1, __s1, __s1}; \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
-__ai uint64x1_t vbsl_u64(uint64x1_t __p0, uint64x1_t __p1, uint64x1_t __p2) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 19);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vbsl_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 17);
- return __ret;
-}
+#define vmul_n_f16(__p0, __p1) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16_t __s1 = __p1; \
+ __ret = __s0 * (float16x4_t) {__s1, __s1, __s1, __s1}; \
+ __ret; \
+})
#else
-__ai uint16x4_t vbsl_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- uint16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vmul_n_f16(__p0, __p1) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16_t __s1 = __p1; \
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = __rev0 * (float16x4_t) {__s1, __s1, __s1, __s1}; \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vbsl_s8(uint8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vnegq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ __ret = -__p0;
return __ret;
}
#else
-__ai int8x8_t vbsl_s8(uint8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
- int8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vnegq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = -__rev0;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vbsl_f32(uint32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vneg_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = -__p0;
return __ret;
}
#else
-__ai float32x2_t vbsl_f32(uint32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
- float32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- float32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vneg_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = -__rev0;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vbsl_s32(uint32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpadd_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vpadd_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
return __ret;
}
#else
-__ai int32x2_t vbsl_s32(uint32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
- int32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- int32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpadd_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vpadd_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai int64x1_t vbsl_s64(uint64x1_t __p0, int64x1_t __p1, int64x1_t __p2) {
- int64x1_t __ret;
- __ret = (int64x1_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 3);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vbsl_s16(uint16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 1);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpmax_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vpmax_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
return __ret;
}
#else
-__ai int16x4_t vbsl_s16(uint16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
- int16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- int16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 1);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpmax_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vpmax_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcageq_f32(float32x4_t __p0, float32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vcageq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpmin_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vpmin_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
return __ret;
}
#else
-__ai uint32x4_t vcageq_f32(float32x4_t __p0, float32x4_t __p1) {
- uint32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vcageq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpmin_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vpmin_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcage_f32(float32x2_t __p0, float32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vcage_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrecpeq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vrecpeq_f16((int8x16_t)__p0, 40);
return __ret;
}
#else
-__ai uint32x2_t vcage_f32(float32x2_t __p0, float32x2_t __p1) {
- uint32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vcage_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrecpeq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vrecpeq_f16((int8x16_t)__rev0, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcagtq_f32(float32x4_t __p0, float32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vcagtq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrecpe_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vrecpe_f16((int8x8_t)__p0, 8);
return __ret;
}
#else
-__ai uint32x4_t vcagtq_f32(float32x4_t __p0, float32x4_t __p1) {
- uint32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vcagtq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrecpe_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vrecpe_f16((int8x8_t)__rev0, 8);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcagt_f32(float32x2_t __p0, float32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vcagt_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrecpsq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vrecpsq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
return __ret;
}
#else
-__ai uint32x2_t vcagt_f32(float32x2_t __p0, float32x2_t __p1) {
- uint32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vcagt_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrecpsq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vrecpsq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcaleq_f32(float32x4_t __p0, float32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vcaleq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrecps_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vrecps_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
return __ret;
}
#else
-__ai uint32x4_t vcaleq_f32(float32x4_t __p0, float32x4_t __p1) {
- uint32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vcaleq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrecps_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vrecps_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcale_f32(float32x2_t __p0, float32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vcale_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrsqrteq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vrsqrteq_f16((int8x16_t)__p0, 40);
return __ret;
}
#else
-__ai uint32x2_t vcale_f32(float32x2_t __p0, float32x2_t __p1) {
- uint32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vcale_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrsqrteq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vrsqrteq_f16((int8x16_t)__rev0, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcaltq_f32(float32x4_t __p0, float32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vcaltq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrsqrte_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vrsqrte_f16((int8x8_t)__p0, 8);
return __ret;
}
#else
-__ai uint32x4_t vcaltq_f32(float32x4_t __p0, float32x4_t __p1) {
- uint32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vcaltq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrsqrte_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vrsqrte_f16((int8x8_t)__rev0, 8);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcalt_f32(float32x2_t __p0, float32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vcalt_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrsqrtsq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vrsqrtsq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
return __ret;
}
#else
-__ai uint32x2_t vcalt_f32(float32x2_t __p0, float32x2_t __p1) {
- uint32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vcalt_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrsqrtsq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vrsqrtsq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vceq_p8(poly8x8_t __p0, poly8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0 == __p1);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrsqrts_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vrsqrts_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
return __ret;
}
#else
-__ai uint8x8_t vceq_p8(poly8x8_t __p0, poly8x8_t __p1) {
- uint8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t)(__rev0 == __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrsqrts_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vrsqrts_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vceqq_p8(poly8x16_t __p0, poly8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0 == __p1);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vsubq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = __p0 - __p1;
return __ret;
}
#else
-__ai uint8x16_t vceqq_p8(poly8x16_t __p0, poly8x16_t __p1) {
- uint8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t)(__rev0 == __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vsubq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 - __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vceqq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0 == __p1);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vsub_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = __p0 - __p1;
return __ret;
}
#else
-__ai uint8x16_t vceqq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t)(__rev0 == __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vsub_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 - __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vceqq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("i8mm,neon"))) uint32x4_t vmmlaq_u32(uint32x4_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0 == __p1);
+ __ret = (uint32x4_t) __builtin_neon_vmmlaq_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
return __ret;
}
#else
-__ai uint32x4_t vceqq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("i8mm,neon"))) uint32x4_t vmmlaq_u32(uint32x4_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t)(__rev0 == __rev1);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vmmlaq_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 50);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vceqq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0 == __p1);
- return __ret;
-}
-#else
-__ai uint16x8_t vceqq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t)(__rev0 == __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vceqq_s8(int8x16_t __p0, int8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0 == __p1);
+__ai __attribute__((target("i8mm,neon"))) int32x4_t vmmlaq_s32(int32x4_t __p0, int8x16_t __p1, int8x16_t __p2) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vmmlaq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
return __ret;
}
#else
-__ai uint8x16_t vceqq_s8(int8x16_t __p0, int8x16_t __p1) {
- uint8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("i8mm,neon"))) int32x4_t vmmlaq_s32(int32x4_t __p0, int8x16_t __p1, int8x16_t __p2) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t)(__rev0 == __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vceqq_f32(float32x4_t __p0, float32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0 == __p1);
- return __ret;
-}
-#else
-__ai uint32x4_t vceqq_f32(float32x4_t __p0, float32x4_t __p1) {
- uint32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t)(__rev0 == __rev1);
+ int8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vmmlaq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vceqq_s32(int32x4_t __p0, int32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0 == __p1);
+__ai __attribute__((target("i8mm,neon"))) int32x4_t vusdotq_s32(int32x4_t __p0, uint8x16_t __p1, int8x16_t __p2) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vusdotq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
return __ret;
}
#else
-__ai uint32x4_t vceqq_s32(int32x4_t __p0, int32x4_t __p1) {
- uint32x4_t __ret;
+__ai __attribute__((target("i8mm,neon"))) int32x4_t vusdotq_s32(int32x4_t __p0, uint8x16_t __p1, int8x16_t __p2) {
+ int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t)(__rev0 == __rev1);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vusdotq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vceqq_s16(int16x8_t __p0, int16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0 == __p1);
- return __ret;
-}
-#else
-__ai uint16x8_t vceqq_s16(int16x8_t __p0, int16x8_t __p1) {
- uint16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t)(__rev0 == __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("i8mm,neon"))) int32x4_t __noswap_vusdotq_s32(int32x4_t __p0, uint8x16_t __p1, int8x16_t __p2) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vusdotq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vceq_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0 == __p1);
+__ai __attribute__((target("i8mm,neon"))) int32x2_t vusdot_s32(int32x2_t __p0, uint8x8_t __p1, int8x8_t __p2) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vusdot_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
return __ret;
}
#else
-__ai uint8x8_t vceq_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("i8mm,neon"))) int32x2_t vusdot_s32(int32x2_t __p0, uint8x8_t __p1, int8x8_t __p2) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t)(__rev0 == __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vceq_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0 == __p1);
+ int8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vusdot_s32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-#else
-__ai uint32x2_t vceq_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t)(__rev0 == __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("i8mm,neon"))) int32x2_t __noswap_vusdot_s32(int32x2_t __p0, uint8x8_t __p1, int8x8_t __p2) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vusdot_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vceq_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0 == __p1);
+__ai __attribute__((target("i8mm,neon"))) int32x4_t vusmmlaq_s32(int32x4_t __p0, uint8x16_t __p1, int8x16_t __p2) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vusmmlaq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
return __ret;
}
#else
-__ai uint16x4_t vceq_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t)(__rev0 == __rev1);
+__ai __attribute__((target("i8mm,neon"))) int32x4_t vusmmlaq_s32(int32x4_t __p0, uint8x16_t __p1, int8x16_t __p2) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vusmmlaq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vceq_s8(int8x8_t __p0, int8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0 == __p1);
- return __ret;
-}
+#define splat_lane_p8(__p0, __p1) __extension__ ({ \
+ poly8x8_t __ret; \
+ poly8x8_t __s0 = __p0; \
+ __ret = (poly8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 4); \
+ __ret; \
+})
#else
-__ai uint8x8_t vceq_s8(int8x8_t __p0, int8x8_t __p1) {
- uint8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t)(__rev0 == __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splat_lane_p8(__p0, __p1) __extension__ ({ \
+ poly8x8_t __ret; \
+ poly8x8_t __s0 = __p0; \
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 4); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_lane_p8(__p0, __p1) __extension__ ({ \
+ poly8x8_t __ret; \
+ poly8x8_t __s0 = __p0; \
+ __ret = (poly8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 4); \
+ __ret; \
+})
#endif
+#define splat_lane_p64(__p0, __p1) __extension__ ({ \
+ poly64x1_t __ret; \
+ poly64x1_t __s0 = __p0; \
+ __ret = (poly64x1_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 6); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vceq_f32(float32x2_t __p0, float32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0 == __p1);
- return __ret;
-}
+#define splat_lane_p16(__p0, __p1) __extension__ ({ \
+ poly16x4_t __ret; \
+ poly16x4_t __s0 = __p0; \
+ __ret = (poly16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 5); \
+ __ret; \
+})
#else
-__ai uint32x2_t vceq_f32(float32x2_t __p0, float32x2_t __p1) {
- uint32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t)(__rev0 == __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define splat_lane_p16(__p0, __p1) __extension__ ({ \
+ poly16x4_t __ret; \
+ poly16x4_t __s0 = __p0; \
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (poly16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 5); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_lane_p16(__p0, __p1) __extension__ ({ \
+ poly16x4_t __ret; \
+ poly16x4_t __s0 = __p0; \
+ __ret = (poly16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 5); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vceq_s32(int32x2_t __p0, int32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0 == __p1);
- return __ret;
-}
+#define splatq_lane_p8(__p0, __p1) __extension__ ({ \
+ poly8x16_t __ret; \
+ poly8x8_t __s0 = __p0; \
+ __ret = (poly8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 4); \
+ __ret; \
+})
#else
-__ai uint32x2_t vceq_s32(int32x2_t __p0, int32x2_t __p1) {
- uint32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t)(__rev0 == __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define splatq_lane_p8(__p0, __p1) __extension__ ({ \
+ poly8x16_t __ret; \
+ poly8x8_t __s0 = __p0; \
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 4); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_lane_p8(__p0, __p1) __extension__ ({ \
+ poly8x16_t __ret; \
+ poly8x8_t __s0 = __p0; \
+ __ret = (poly8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 4); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vceq_s16(int16x4_t __p0, int16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0 == __p1);
- return __ret;
-}
+#define splatq_lane_p64(__p0, __p1) __extension__ ({ \
+ poly64x2_t __ret; \
+ poly64x1_t __s0 = __p0; \
+ __ret = (poly64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 6); \
+ __ret; \
+})
#else
-__ai uint16x4_t vceq_s16(int16x4_t __p0, int16x4_t __p1) {
- uint16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t)(__rev0 == __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vcgeq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0 >= __p1);
- return __ret;
-}
-#else
-__ai uint8x16_t vcgeq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t)(__rev0 >= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_lane_p64(__p0, __p1) __extension__ ({ \
+ poly64x2_t __ret; \
+ poly64x1_t __s0 = __p0; \
+ __ret = (poly64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 6); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_lane_p64(__p0, __p1) __extension__ ({ \
+ poly64x2_t __ret; \
+ poly64x1_t __s0 = __p0; \
+ __ret = (poly64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 6); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcgeq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0 >= __p1);
- return __ret;
-}
+#define splatq_lane_p16(__p0, __p1) __extension__ ({ \
+ poly16x8_t __ret; \
+ poly16x4_t __s0 = __p0; \
+ __ret = (poly16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 5); \
+ __ret; \
+})
#else
-__ai uint32x4_t vcgeq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t)(__rev0 >= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_lane_p16(__p0, __p1) __extension__ ({ \
+ poly16x8_t __ret; \
+ poly16x4_t __s0 = __p0; \
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (poly16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 5); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_lane_p16(__p0, __p1) __extension__ ({ \
+ poly16x8_t __ret; \
+ poly16x4_t __s0 = __p0; \
+ __ret = (poly16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 5); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vcgeq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0 >= __p1);
- return __ret;
-}
+#define splatq_lane_u8(__p0, __p1) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ __ret = (uint8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 16); \
+ __ret; \
+})
#else
-__ai uint16x8_t vcgeq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t)(__rev0 >= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_lane_u8(__p0, __p1) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 16); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_lane_u8(__p0, __p1) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ __ret = (uint8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 16); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vcgeq_s8(int8x16_t __p0, int8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0 >= __p1);
- return __ret;
-}
+#define splatq_lane_u32(__p0, __p1) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ __ret = (uint32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 18); \
+ __ret; \
+})
#else
-__ai uint8x16_t vcgeq_s8(int8x16_t __p0, int8x16_t __p1) {
- uint8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t)(__rev0 >= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_lane_u32(__p0, __p1) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 18); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_lane_u32(__p0, __p1) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ __ret = (uint32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 18); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcgeq_f32(float32x4_t __p0, float32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0 >= __p1);
- return __ret;
-}
+#define splatq_lane_u64(__p0, __p1) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x1_t __s0 = __p0; \
+ __ret = (uint64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 19); \
+ __ret; \
+})
#else
-__ai uint32x4_t vcgeq_f32(float32x4_t __p0, float32x4_t __p1) {
- uint32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t)(__rev0 >= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_lane_u64(__p0, __p1) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x1_t __s0 = __p0; \
+ __ret = (uint64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 19); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_lane_u64(__p0, __p1) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x1_t __s0 = __p0; \
+ __ret = (uint64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 19); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcgeq_s32(int32x4_t __p0, int32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0 >= __p1);
- return __ret;
-}
+#define splatq_lane_u16(__p0, __p1) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ __ret = (uint16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 17); \
+ __ret; \
+})
#else
-__ai uint32x4_t vcgeq_s32(int32x4_t __p0, int32x4_t __p1) {
- uint32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t)(__rev0 >= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_lane_u16(__p0, __p1) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_lane_u16(__p0, __p1) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ __ret = (uint16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 17); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vcgeq_s16(int16x8_t __p0, int16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0 >= __p1);
- return __ret;
-}
+#define splatq_lane_s8(__p0, __p1) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x8_t __s0 = __p0; \
+ __ret = (int8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 0); \
+ __ret; \
+})
#else
-__ai uint16x8_t vcgeq_s16(int16x8_t __p0, int16x8_t __p1) {
- uint16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t)(__rev0 >= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_lane_s8(__p0, __p1) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x8_t __s0 = __p0; \
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 0); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_lane_s8(__p0, __p1) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x8_t __s0 = __p0; \
+ __ret = (int8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vcge_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0 >= __p1);
- return __ret;
-}
+#define splatq_lane_f64(__p0, __p1) __extension__ ({ \
+ float64x2_t __ret; \
+ float64x1_t __s0 = __p0; \
+ __ret = (float64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 10); \
+ __ret; \
+})
#else
-__ai uint8x8_t vcge_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t)(__rev0 >= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_lane_f64(__p0, __p1) __extension__ ({ \
+ float64x2_t __ret; \
+ float64x1_t __s0 = __p0; \
+ __ret = (float64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 10); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_lane_f64(__p0, __p1) __extension__ ({ \
+ float64x2_t __ret; \
+ float64x1_t __s0 = __p0; \
+ __ret = (float64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 10); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcge_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0 >= __p1);
- return __ret;
-}
+#define splatq_lane_f32(__p0, __p1) __extension__ ({ \
+ float32x4_t __ret; \
+ float32x2_t __s0 = __p0; \
+ __ret = (float32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 9); \
+ __ret; \
+})
#else
-__ai uint32x2_t vcge_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t)(__rev0 >= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define splatq_lane_f32(__p0, __p1) __extension__ ({ \
+ float32x4_t __ret; \
+ float32x2_t __s0 = __p0; \
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (float32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 9); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_lane_f32(__p0, __p1) __extension__ ({ \
+ float32x4_t __ret; \
+ float32x2_t __s0 = __p0; \
+ __ret = (float32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 9); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vcge_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0 >= __p1);
- return __ret;
-}
+#define splatq_lane_f16(__p0, __p1) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x4_t __s0 = __p0; \
+ __ret = (float16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 8); \
+ __ret; \
+})
#else
-__ai uint16x4_t vcge_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t)(__rev0 >= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_lane_f16(__p0, __p1) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (float16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 8); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_lane_f16(__p0, __p1) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x4_t __s0 = __p0; \
+ __ret = (float16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 8); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vcge_s8(int8x8_t __p0, int8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0 >= __p1);
- return __ret;
-}
+#define splatq_lane_s32(__p0, __p1) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x2_t __s0 = __p0; \
+ __ret = (int32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 2); \
+ __ret; \
+})
#else
-__ai uint8x8_t vcge_s8(int8x8_t __p0, int8x8_t __p1) {
- uint8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t)(__rev0 >= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_lane_s32(__p0, __p1) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (int32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_lane_s32(__p0, __p1) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x2_t __s0 = __p0; \
+ __ret = (int32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcge_f32(float32x2_t __p0, float32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0 >= __p1);
- return __ret;
-}
+#define splatq_lane_s64(__p0, __p1) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x1_t __s0 = __p0; \
+ __ret = (int64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 3); \
+ __ret; \
+})
#else
-__ai uint32x2_t vcge_f32(float32x2_t __p0, float32x2_t __p1) {
- uint32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t)(__rev0 >= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define splatq_lane_s64(__p0, __p1) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x1_t __s0 = __p0; \
+ __ret = (int64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 3); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_lane_s64(__p0, __p1) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x1_t __s0 = __p0; \
+ __ret = (int64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 3); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcge_s32(int32x2_t __p0, int32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0 >= __p1);
- return __ret;
-}
+#define splatq_lane_s16(__p0, __p1) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x4_t __s0 = __p0; \
+ __ret = (int16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 1); \
+ __ret; \
+})
#else
-__ai uint32x2_t vcge_s32(int32x2_t __p0, int32x2_t __p1) {
- uint32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t)(__rev0 >= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define splatq_lane_s16(__p0, __p1) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (int16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_lane_s16(__p0, __p1) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x4_t __s0 = __p0; \
+ __ret = (int16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 1); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vcge_s16(int16x4_t __p0, int16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0 >= __p1);
- return __ret;
-}
+#define splat_lane_u8(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ __ret = (uint8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 16); \
+ __ret; \
+})
#else
-__ai uint16x4_t vcge_s16(int16x4_t __p0, int16x4_t __p1) {
- uint16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t)(__rev0 >= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define splat_lane_u8(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 16); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_lane_u8(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ __ret = (uint8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 16); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vcgtq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0 > __p1);
- return __ret;
-}
+#define splat_lane_u32(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ __ret = (uint32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 18); \
+ __ret; \
+})
#else
-__ai uint8x16_t vcgtq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splat_lane_u32(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 18); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_lane_u32(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ __ret = (uint32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 18); \
+ __ret; \
+})
#endif
+#define splat_lane_u64(__p0, __p1) __extension__ ({ \
+ uint64x1_t __ret; \
+ uint64x1_t __s0 = __p0; \
+ __ret = (uint64x1_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 19); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcgtq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0 > __p1);
- return __ret;
-}
+#define splat_lane_u16(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ __ret = (uint16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 17); \
+ __ret; \
+})
#else
-__ai uint32x4_t vcgtq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define splat_lane_u16(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_lane_u16(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ __ret = (uint16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 17); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vcgtq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0 > __p1);
- return __ret;
-}
+#define splat_lane_s8(__p0, __p1) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ __ret = (int8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 0); \
+ __ret; \
+})
#else
-__ai uint16x8_t vcgtq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splat_lane_s8(__p0, __p1) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 0); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_lane_s8(__p0, __p1) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ __ret = (int8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 0); \
+ __ret; \
+})
#endif
+#define splat_lane_f64(__p0, __p1) __extension__ ({ \
+ float64x1_t __ret; \
+ float64x1_t __s0 = __p0; \
+ __ret = (float64x1_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 10); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vcgtq_s8(int8x16_t __p0, int8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0 > __p1);
- return __ret;
-}
+#define splat_lane_f32(__p0, __p1) __extension__ ({ \
+ float32x2_t __ret; \
+ float32x2_t __s0 = __p0; \
+ __ret = (float32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 9); \
+ __ret; \
+})
#else
-__ai uint8x16_t vcgtq_s8(int8x16_t __p0, int8x16_t __p1) {
- uint8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splat_lane_f32(__p0, __p1) __extension__ ({ \
+ float32x2_t __ret; \
+ float32x2_t __s0 = __p0; \
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (float32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 9); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_lane_f32(__p0, __p1) __extension__ ({ \
+ float32x2_t __ret; \
+ float32x2_t __s0 = __p0; \
+ __ret = (float32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 9); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcgtq_f32(float32x4_t __p0, float32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0 > __p1);
- return __ret;
-}
+#define splat_lane_f16(__p0, __p1) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ __ret = (float16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 8); \
+ __ret; \
+})
#else
-__ai uint32x4_t vcgtq_f32(float32x4_t __p0, float32x4_t __p1) {
- uint32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define splat_lane_f16(__p0, __p1) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (float16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 8); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_lane_f16(__p0, __p1) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ __ret = (float16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 8); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcgtq_s32(int32x4_t __p0, int32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0 > __p1);
- return __ret;
-}
+#define splat_lane_s32(__p0, __p1) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ __ret = (int32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 2); \
+ __ret; \
+})
#else
-__ai uint32x4_t vcgtq_s32(int32x4_t __p0, int32x4_t __p1) {
- uint32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define splat_lane_s32(__p0, __p1) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (int32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_lane_s32(__p0, __p1) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ __ret = (int32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 2); \
+ __ret; \
+})
#endif
+#define splat_lane_s64(__p0, __p1) __extension__ ({ \
+ int64x1_t __ret; \
+ int64x1_t __s0 = __p0; \
+ __ret = (int64x1_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 3); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vcgtq_s16(int16x8_t __p0, int16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0 > __p1);
- return __ret;
-}
+#define splat_lane_s16(__p0, __p1) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ __ret = (int16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 1); \
+ __ret; \
+})
#else
-__ai uint16x8_t vcgtq_s16(int16x8_t __p0, int16x8_t __p1) {
- uint16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splat_lane_s16(__p0, __p1) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (int16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_lane_s16(__p0, __p1) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ __ret = (int16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 1); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vcgt_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0 > __p1);
- return __ret;
-}
+#define splat_laneq_p8(__p0, __p1) __extension__ ({ \
+ poly8x8_t __ret; \
+ poly8x16_t __s0 = __p0; \
+ __ret = (poly8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 36); \
+ __ret; \
+})
#else
-__ai uint8x8_t vcgt_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splat_laneq_p8(__p0, __p1) __extension__ ({ \
+ poly8x8_t __ret; \
+ poly8x16_t __s0 = __p0; \
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 36); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_laneq_p8(__p0, __p1) __extension__ ({ \
+ poly8x8_t __ret; \
+ poly8x16_t __s0 = __p0; \
+ __ret = (poly8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 36); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcgt_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0 > __p1);
- return __ret;
-}
+#define splat_laneq_p64(__p0, __p1) __extension__ ({ \
+ poly64x1_t __ret; \
+ poly64x2_t __s0 = __p0; \
+ __ret = (poly64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 38); \
+ __ret; \
+})
#else
-__ai uint32x2_t vcgt_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define splat_laneq_p64(__p0, __p1) __extension__ ({ \
+ poly64x1_t __ret; \
+ poly64x2_t __s0 = __p0; \
+ poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (poly64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 38); \
+ __ret; \
+})
+#define __noswap_splat_laneq_p64(__p0, __p1) __extension__ ({ \
+ poly64x1_t __ret; \
+ poly64x2_t __s0 = __p0; \
+ __ret = (poly64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 38); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vcgt_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0 > __p1);
- return __ret;
-}
+#define splat_laneq_p16(__p0, __p1) __extension__ ({ \
+ poly16x4_t __ret; \
+ poly16x8_t __s0 = __p0; \
+ __ret = (poly16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 37); \
+ __ret; \
+})
#else
-__ai uint16x4_t vcgt_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define splat_laneq_p16(__p0, __p1) __extension__ ({ \
+ poly16x4_t __ret; \
+ poly16x8_t __s0 = __p0; \
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 37); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_laneq_p16(__p0, __p1) __extension__ ({ \
+ poly16x4_t __ret; \
+ poly16x8_t __s0 = __p0; \
+ __ret = (poly16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 37); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vcgt_s8(int8x8_t __p0, int8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0 > __p1);
- return __ret;
-}
+#define splatq_laneq_p8(__p0, __p1) __extension__ ({ \
+ poly8x16_t __ret; \
+ poly8x16_t __s0 = __p0; \
+ __ret = (poly8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 36); \
+ __ret; \
+})
#else
-__ai uint8x8_t vcgt_s8(int8x8_t __p0, int8x8_t __p1) {
- uint8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_laneq_p8(__p0, __p1) __extension__ ({ \
+ poly8x16_t __ret; \
+ poly8x16_t __s0 = __p0; \
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 36); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_laneq_p8(__p0, __p1) __extension__ ({ \
+ poly8x16_t __ret; \
+ poly8x16_t __s0 = __p0; \
+ __ret = (poly8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 36); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcgt_f32(float32x2_t __p0, float32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0 > __p1);
- return __ret;
-}
+#define splatq_laneq_p64(__p0, __p1) __extension__ ({ \
+ poly64x2_t __ret; \
+ poly64x2_t __s0 = __p0; \
+ __ret = (poly64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 38); \
+ __ret; \
+})
#else
-__ai uint32x2_t vcgt_f32(float32x2_t __p0, float32x2_t __p1) {
- uint32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define splatq_laneq_p64(__p0, __p1) __extension__ ({ \
+ poly64x2_t __ret; \
+ poly64x2_t __s0 = __p0; \
+ poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (poly64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 38); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_laneq_p64(__p0, __p1) __extension__ ({ \
+ poly64x2_t __ret; \
+ poly64x2_t __s0 = __p0; \
+ __ret = (poly64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 38); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcgt_s32(int32x2_t __p0, int32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0 > __p1);
- return __ret;
-}
+#define splatq_laneq_p16(__p0, __p1) __extension__ ({ \
+ poly16x8_t __ret; \
+ poly16x8_t __s0 = __p0; \
+ __ret = (poly16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 37); \
+ __ret; \
+})
#else
-__ai uint32x2_t vcgt_s32(int32x2_t __p0, int32x2_t __p1) {
- uint32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define splatq_laneq_p16(__p0, __p1) __extension__ ({ \
+ poly16x8_t __ret; \
+ poly16x8_t __s0 = __p0; \
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 37); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_laneq_p16(__p0, __p1) __extension__ ({ \
+ poly16x8_t __ret; \
+ poly16x8_t __s0 = __p0; \
+ __ret = (poly16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 37); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vcgt_s16(int16x4_t __p0, int16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0 > __p1);
- return __ret;
-}
+#define splatq_laneq_u8(__p0, __p1) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ __ret = (uint8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 48); \
+ __ret; \
+})
#else
-__ai uint16x4_t vcgt_s16(int16x4_t __p0, int16x4_t __p1) {
- uint16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_laneq_u8(__p0, __p1) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 48); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_laneq_u8(__p0, __p1) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ __ret = (uint8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 48); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vcleq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0 <= __p1);
- return __ret;
-}
+#define splatq_laneq_u32(__p0, __p1) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ __ret = (uint32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 50); \
+ __ret; \
+})
#else
-__ai uint8x16_t vcleq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t)(__rev0 <= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_laneq_u32(__p0, __p1) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 50); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_laneq_u32(__p0, __p1) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ __ret = (uint32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 50); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcleq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0 <= __p1);
- return __ret;
-}
+#define splatq_laneq_u64(__p0, __p1) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ __ret = (uint64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 51); \
+ __ret; \
+})
#else
-__ai uint32x4_t vcleq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t)(__rev0 <= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_laneq_u64(__p0, __p1) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 51); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_laneq_u64(__p0, __p1) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ __ret = (uint64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 51); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vcleq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0 <= __p1);
- return __ret;
-}
+#define splatq_laneq_u16(__p0, __p1) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ __ret = (uint16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 49); \
+ __ret; \
+})
#else
-__ai uint16x8_t vcleq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t)(__rev0 <= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_laneq_u16(__p0, __p1) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 49); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_laneq_u16(__p0, __p1) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ __ret = (uint16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 49); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vcleq_s8(int8x16_t __p0, int8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0 <= __p1);
- return __ret;
-}
+#define splatq_laneq_s8(__p0, __p1) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x16_t __s0 = __p0; \
+ __ret = (int8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 32); \
+ __ret; \
+})
#else
-__ai uint8x16_t vcleq_s8(int8x16_t __p0, int8x16_t __p1) {
- uint8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t)(__rev0 <= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_laneq_s8(__p0, __p1) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x16_t __s0 = __p0; \
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 32); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_laneq_s8(__p0, __p1) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x16_t __s0 = __p0; \
+ __ret = (int8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 32); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcleq_f32(float32x4_t __p0, float32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0 <= __p1);
- return __ret;
-}
+#define splatq_laneq_f64(__p0, __p1) __extension__ ({ \
+ float64x2_t __ret; \
+ float64x2_t __s0 = __p0; \
+ __ret = (float64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 42); \
+ __ret; \
+})
#else
-__ai uint32x4_t vcleq_f32(float32x4_t __p0, float32x4_t __p1) {
- uint32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t)(__rev0 <= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_laneq_f64(__p0, __p1) __extension__ ({ \
+ float64x2_t __ret; \
+ float64x2_t __s0 = __p0; \
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (float64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 42); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_laneq_f64(__p0, __p1) __extension__ ({ \
+ float64x2_t __ret; \
+ float64x2_t __s0 = __p0; \
+ __ret = (float64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 42); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcleq_s32(int32x4_t __p0, int32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0 <= __p1);
- return __ret;
-}
+#define splatq_laneq_f32(__p0, __p1) __extension__ ({ \
+ float32x4_t __ret; \
+ float32x4_t __s0 = __p0; \
+ __ret = (float32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 41); \
+ __ret; \
+})
#else
-__ai uint32x4_t vcleq_s32(int32x4_t __p0, int32x4_t __p1) {
- uint32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t)(__rev0 <= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_laneq_f32(__p0, __p1) __extension__ ({ \
+ float32x4_t __ret; \
+ float32x4_t __s0 = __p0; \
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (float32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 41); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_laneq_f32(__p0, __p1) __extension__ ({ \
+ float32x4_t __ret; \
+ float32x4_t __s0 = __p0; \
+ __ret = (float32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 41); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vcleq_s16(int16x8_t __p0, int16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0 <= __p1);
- return __ret;
-}
+#define splatq_laneq_f16(__p0, __p1) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ __ret = (float16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 40); \
+ __ret; \
+})
#else
-__ai uint16x8_t vcleq_s16(int16x8_t __p0, int16x8_t __p1) {
- uint16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t)(__rev0 <= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_laneq_f16(__p0, __p1) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (float16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 40); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_laneq_f16(__p0, __p1) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ __ret = (float16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 40); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vcle_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0 <= __p1);
- return __ret;
-}
+#define splatq_laneq_s32(__p0, __p1) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (int32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 34); \
+ __ret; \
+})
#else
-__ai uint8x8_t vcle_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t)(__rev0 <= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_laneq_s32(__p0, __p1) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (int32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 34); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_laneq_s32(__p0, __p1) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (int32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 34); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcle_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0 <= __p1);
- return __ret;
-}
+#define splatq_laneq_s64(__p0, __p1) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (int64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 35); \
+ __ret; \
+})
#else
-__ai uint32x2_t vcle_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t)(__rev0 <= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define splatq_laneq_s64(__p0, __p1) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (int64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 35); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_laneq_s64(__p0, __p1) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (int64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 35); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vcle_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0 <= __p1);
- return __ret;
-}
+#define splatq_laneq_s16(__p0, __p1) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (int16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 33); \
+ __ret; \
+})
#else
-__ai uint16x4_t vcle_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t)(__rev0 <= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define splatq_laneq_s16(__p0, __p1) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 33); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splatq_laneq_s16(__p0, __p1) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (int16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 33); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vcle_s8(int8x8_t __p0, int8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0 <= __p1);
- return __ret;
-}
+#define splat_laneq_u8(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ __ret = (uint8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 48); \
+ __ret; \
+})
#else
-__ai uint8x8_t vcle_s8(int8x8_t __p0, int8x8_t __p1) {
- uint8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t)(__rev0 <= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define splat_laneq_u8(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 48); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_laneq_u8(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ __ret = (uint8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 48); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcle_f32(float32x2_t __p0, float32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0 <= __p1);
- return __ret;
-}
+#define splat_laneq_u32(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ __ret = (uint32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 50); \
+ __ret; \
+})
#else
-__ai uint32x2_t vcle_f32(float32x2_t __p0, float32x2_t __p1) {
- uint32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t)(__rev0 <= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define splat_laneq_u32(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 50); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_laneq_u32(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ __ret = (uint32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 50); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcle_s32(int32x2_t __p0, int32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0 <= __p1);
- return __ret;
-}
+#define splat_laneq_u64(__p0, __p1) __extension__ ({ \
+ uint64x1_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ __ret = (uint64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 51); \
+ __ret; \
+})
#else
-__ai uint32x2_t vcle_s32(int32x2_t __p0, int32x2_t __p1) {
- uint32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t)(__rev0 <= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define splat_laneq_u64(__p0, __p1) __extension__ ({ \
+ uint64x1_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 51); \
+ __ret; \
+})
+#define __noswap_splat_laneq_u64(__p0, __p1) __extension__ ({ \
+ uint64x1_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ __ret = (uint64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 51); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vcle_s16(int16x4_t __p0, int16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0 <= __p1);
- return __ret;
-}
+#define splat_laneq_u16(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ __ret = (uint16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 49); \
+ __ret; \
+})
#else
-__ai uint16x4_t vcle_s16(int16x4_t __p0, int16x4_t __p1) {
- uint16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t)(__rev0 <= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define splat_laneq_u16(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 49); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_laneq_u16(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ __ret = (uint16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 49); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vclsq_u8(uint8x16_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vclsq_v((int8x16_t)__p0, 32);
+#define splat_laneq_s8(__p0, __p1) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x16_t __s0 = __p0; \
+ __ret = (int8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 32); \
+ __ret; \
+})
+#else
+#define splat_laneq_s8(__p0, __p1) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x16_t __s0 = __p0; \
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 32); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_laneq_s8(__p0, __p1) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x16_t __s0 = __p0; \
+ __ret = (int8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 32); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_f64(__p0, __p1) __extension__ ({ \
+ float64x1_t __ret; \
+ float64x2_t __s0 = __p0; \
+ __ret = (float64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 42); \
+ __ret; \
+})
+#else
+#define splat_laneq_f64(__p0, __p1) __extension__ ({ \
+ float64x1_t __ret; \
+ float64x2_t __s0 = __p0; \
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (float64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 42); \
+ __ret; \
+})
+#define __noswap_splat_laneq_f64(__p0, __p1) __extension__ ({ \
+ float64x1_t __ret; \
+ float64x2_t __s0 = __p0; \
+ __ret = (float64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 42); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_f32(__p0, __p1) __extension__ ({ \
+ float32x2_t __ret; \
+ float32x4_t __s0 = __p0; \
+ __ret = (float32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 41); \
+ __ret; \
+})
+#else
+#define splat_laneq_f32(__p0, __p1) __extension__ ({ \
+ float32x2_t __ret; \
+ float32x4_t __s0 = __p0; \
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (float32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 41); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_laneq_f32(__p0, __p1) __extension__ ({ \
+ float32x2_t __ret; \
+ float32x4_t __s0 = __p0; \
+ __ret = (float32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 41); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_f16(__p0, __p1) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x8_t __s0 = __p0; \
+ __ret = (float16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 40); \
+ __ret; \
+})
+#else
+#define splat_laneq_f16(__p0, __p1) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (float16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 40); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_laneq_f16(__p0, __p1) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x8_t __s0 = __p0; \
+ __ret = (float16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 40); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_s32(__p0, __p1) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (int32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 34); \
+ __ret; \
+})
+#else
+#define splat_laneq_s32(__p0, __p1) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (int32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 34); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_laneq_s32(__p0, __p1) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (int32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 34); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_s64(__p0, __p1) __extension__ ({ \
+ int64x1_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (int64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 35); \
+ __ret; \
+})
+#else
+#define splat_laneq_s64(__p0, __p1) __extension__ ({ \
+ int64x1_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (int64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 35); \
+ __ret; \
+})
+#define __noswap_splat_laneq_s64(__p0, __p1) __extension__ ({ \
+ int64x1_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (int64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 35); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_s16(__p0, __p1) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (int16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 33); \
+ __ret; \
+})
+#else
+#define splat_laneq_s16(__p0, __p1) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 33); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_splat_laneq_s16(__p0, __p1) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (int16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 33); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vabdq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
return __ret;
}
#else
-__ai int8x16_t vclsq_u8(uint8x16_t __p0) {
- int8x16_t __ret;
+__ai __attribute__((target("neon"))) uint8x16_t vabdq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vclsq_v((int8x16_t)__rev0, 32);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) uint8x16_t __noswap_vabdq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vclsq_u32(uint32x4_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vclsq_v((int8x16_t)__p0, 34);
+__ai __attribute__((target("neon"))) uint32x4_t vabdq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
return __ret;
}
#else
-__ai int32x4_t vclsq_u32(uint32x4_t __p0) {
- int32x4_t __ret;
+__ai __attribute__((target("neon"))) uint32x4_t vabdq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vclsq_v((int8x16_t)__rev0, 34);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vabdq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vclsq_u16(uint16x8_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vclsq_v((int8x16_t)__p0, 33);
+__ai __attribute__((target("neon"))) uint16x8_t vabdq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
return __ret;
}
#else
-__ai int16x8_t vclsq_u16(uint16x8_t __p0) {
- int16x8_t __ret;
+__ai __attribute__((target("neon"))) uint16x8_t vabdq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vclsq_v((int8x16_t)__rev0, 33);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) uint16x8_t __noswap_vabdq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vclsq_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vabdq_s8(int8x16_t __p0, int8x16_t __p1) {
int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vclsq_v((int8x16_t)__p0, 32);
+ __ret = (int8x16_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
return __ret;
}
#else
-__ai int8x16_t vclsq_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vabdq_s8(int8x16_t __p0, int8x16_t __p1) {
int8x16_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vclsq_v((int8x16_t)__rev0, 32);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) int8x16_t __noswap_vabdq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vclsq_s32(int32x4_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vclsq_v((int8x16_t)__p0, 34);
+__ai __attribute__((target("neon"))) float32x4_t vabdq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
return __ret;
}
#else
-__ai int32x4_t vclsq_s32(int32x4_t __p0) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vclsq_v((int8x16_t)__rev0, 34);
+__ai __attribute__((target("neon"))) float32x4_t vabdq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vabdq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vabdq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vabdq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vclsq_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vabdq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vclsq_v((int8x16_t)__p0, 33);
+ __ret = (int16x8_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
return __ret;
}
#else
-__ai int16x8_t vclsq_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vabdq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vclsq_v((int8x16_t)__rev0, 33);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vabdq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vcls_u8(uint8x8_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vcls_v((int8x8_t)__p0, 0);
+__ai __attribute__((target("neon"))) uint8x8_t vabd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
return __ret;
}
#else
-__ai int8x8_t vcls_u8(uint8x8_t __p0) {
- int8x8_t __ret;
+__ai __attribute__((target("neon"))) uint8x8_t vabd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vcls_v((int8x8_t)__rev0, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) uint8x8_t __noswap_vabd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vcls_u32(uint32x2_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vcls_v((int8x8_t)__p0, 2);
+__ai __attribute__((target("neon"))) uint32x2_t vabd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
return __ret;
}
#else
-__ai int32x2_t vcls_u32(uint32x2_t __p0) {
- int32x2_t __ret;
+__ai __attribute__((target("neon"))) uint32x2_t vabd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vcls_v((int8x8_t)__rev0, 2);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) uint32x2_t __noswap_vabd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vcls_u16(uint16x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vcls_v((int8x8_t)__p0, 1);
+__ai __attribute__((target("neon"))) uint16x4_t vabd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
return __ret;
}
#else
-__ai int16x4_t vcls_u16(uint16x4_t __p0) {
- int16x4_t __ret;
+__ai __attribute__((target("neon"))) uint16x4_t vabd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vcls_v((int8x8_t)__rev0, 1);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) uint16x4_t __noswap_vabd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vcls_s8(int8x8_t __p0) {
+__ai __attribute__((target("neon"))) int8x8_t vabd_s8(int8x8_t __p0, int8x8_t __p1) {
int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vcls_v((int8x8_t)__p0, 0);
+ __ret = (int8x8_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
return __ret;
}
#else
-__ai int8x8_t vcls_s8(int8x8_t __p0) {
+__ai __attribute__((target("neon"))) int8x8_t vabd_s8(int8x8_t __p0, int8x8_t __p1) {
int8x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vcls_v((int8x8_t)__rev0, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) int8x8_t __noswap_vabd_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vcls_s32(int32x2_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vcls_v((int8x8_t)__p0, 2);
+__ai __attribute__((target("neon"))) float32x2_t vabd_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
return __ret;
}
#else
-__ai int32x2_t vcls_s32(int32x2_t __p0) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vcls_v((int8x8_t)__rev0, 2);
+__ai __attribute__((target("neon"))) float32x2_t vabd_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vcls_s16(int16x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vcls_v((int8x8_t)__p0, 1);
+__ai __attribute__((target("neon"))) int32x2_t vabd_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
return __ret;
}
#else
-__ai int16x4_t vcls_s16(int16x4_t __p0) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vcls_v((int8x8_t)__rev0, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vcltq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0 < __p1);
+__ai __attribute__((target("neon"))) int32x2_t vabd_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-#else
-__ai uint8x16_t vcltq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t)(__rev0 < __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vabd_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcltq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0 < __p1);
+__ai __attribute__((target("neon"))) int16x4_t vabd_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
return __ret;
}
#else
-__ai uint32x4_t vcltq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t)(__rev0 < __rev1);
+__ai __attribute__((target("neon"))) int16x4_t vabd_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vcltq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0 < __p1);
- return __ret;
-}
-#else
-__ai uint16x8_t vcltq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t)(__rev0 < __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vabd_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vcltq_s8(int8x16_t __p0, int8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0 < __p1);
+__ai __attribute__((target("neon"))) int8x16_t vabsq_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vabsq_v((int8x16_t)__p0, 32);
return __ret;
}
#else
-__ai uint8x16_t vcltq_s8(int8x16_t __p0, int8x16_t __p1) {
- uint8x16_t __ret;
+__ai __attribute__((target("neon"))) int8x16_t vabsq_s8(int8x16_t __p0) {
+ int8x16_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t)(__rev0 < __rev1);
+ __ret = (int8x16_t) __builtin_neon_vabsq_v((int8x16_t)__rev0, 32);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcltq_f32(float32x4_t __p0, float32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0 < __p1);
+__ai __attribute__((target("neon"))) float32x4_t vabsq_f32(float32x4_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vabsq_v((int8x16_t)__p0, 41);
return __ret;
}
#else
-__ai uint32x4_t vcltq_f32(float32x4_t __p0, float32x4_t __p1) {
- uint32x4_t __ret;
+__ai __attribute__((target("neon"))) float32x4_t vabsq_f32(float32x4_t __p0) {
+ float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t)(__rev0 < __rev1);
+ __ret = (float32x4_t) __builtin_neon_vabsq_v((int8x16_t)__rev0, 41);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcltq_s32(int32x4_t __p0, int32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0 < __p1);
+__ai __attribute__((target("neon"))) int32x4_t vabsq_s32(int32x4_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vabsq_v((int8x16_t)__p0, 34);
return __ret;
}
#else
-__ai uint32x4_t vcltq_s32(int32x4_t __p0, int32x4_t __p1) {
- uint32x4_t __ret;
+__ai __attribute__((target("neon"))) int32x4_t vabsq_s32(int32x4_t __p0) {
+ int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t)(__rev0 < __rev1);
+ __ret = (int32x4_t) __builtin_neon_vabsq_v((int8x16_t)__rev0, 34);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vcltq_s16(int16x8_t __p0, int16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0 < __p1);
+__ai __attribute__((target("neon"))) int16x8_t vabsq_s16(int16x8_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vabsq_v((int8x16_t)__p0, 33);
return __ret;
}
#else
-__ai uint16x8_t vcltq_s16(int16x8_t __p0, int16x8_t __p1) {
- uint16x8_t __ret;
+__ai __attribute__((target("neon"))) int16x8_t vabsq_s16(int16x8_t __p0) {
+ int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t)(__rev0 < __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vclt_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0 < __p1);
- return __ret;
-}
-#else
-__ai uint8x8_t vclt_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t)(__rev0 < __rev1);
+ __ret = (int16x8_t) __builtin_neon_vabsq_v((int8x16_t)__rev0, 33);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vclt_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0 < __p1);
- return __ret;
-}
-#else
-__ai uint32x2_t vclt_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t)(__rev0 < __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vclt_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0 < __p1);
- return __ret;
-}
-#else
-__ai uint16x4_t vclt_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t)(__rev0 < __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vclt_s8(int8x8_t __p0, int8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0 < __p1);
+__ai __attribute__((target("neon"))) int8x8_t vabs_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vabs_v((int8x8_t)__p0, 0);
return __ret;
}
#else
-__ai uint8x8_t vclt_s8(int8x8_t __p0, int8x8_t __p1) {
- uint8x8_t __ret;
+__ai __attribute__((target("neon"))) int8x8_t vabs_s8(int8x8_t __p0) {
+ int8x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t)(__rev0 < __rev1);
+ __ret = (int8x8_t) __builtin_neon_vabs_v((int8x8_t)__rev0, 0);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vclt_f32(float32x2_t __p0, float32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0 < __p1);
+__ai __attribute__((target("neon"))) float32x2_t vabs_f32(float32x2_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vabs_v((int8x8_t)__p0, 9);
return __ret;
}
#else
-__ai uint32x2_t vclt_f32(float32x2_t __p0, float32x2_t __p1) {
- uint32x2_t __ret;
+__ai __attribute__((target("neon"))) float32x2_t vabs_f32(float32x2_t __p0) {
+ float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t)(__rev0 < __rev1);
+ __ret = (float32x2_t) __builtin_neon_vabs_v((int8x8_t)__rev0, 9);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vclt_s32(int32x2_t __p0, int32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0 < __p1);
+__ai __attribute__((target("neon"))) int32x2_t vabs_s32(int32x2_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vabs_v((int8x8_t)__p0, 2);
return __ret;
}
#else
-__ai uint32x2_t vclt_s32(int32x2_t __p0, int32x2_t __p1) {
- uint32x2_t __ret;
+__ai __attribute__((target("neon"))) int32x2_t vabs_s32(int32x2_t __p0) {
+ int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t)(__rev0 < __rev1);
+ __ret = (int32x2_t) __builtin_neon_vabs_v((int8x8_t)__rev0, 2);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vclt_s16(int16x4_t __p0, int16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0 < __p1);
+__ai __attribute__((target("neon"))) int16x4_t vabs_s16(int16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vabs_v((int8x8_t)__p0, 1);
return __ret;
}
#else
-__ai uint16x4_t vclt_s16(int16x4_t __p0, int16x4_t __p1) {
- uint16x4_t __ret;
+__ai __attribute__((target("neon"))) int16x4_t vabs_s16(int16x4_t __p0) {
+ int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t)(__rev0 < __rev1);
+ __ret = (int16x4_t) __builtin_neon_vabs_v((int8x8_t)__rev0, 1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vclzq_u8(uint8x16_t __p0) {
+__ai __attribute__((target("neon"))) uint8x16_t vaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vclzq_v((int8x16_t)__p0, 48);
+ __ret = __p0 + __p1;
return __ret;
}
#else
-__ai uint8x16_t vclzq_u8(uint8x16_t __p0) {
+__ai __attribute__((target("neon"))) uint8x16_t vaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
uint8x16_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vclzq_v((int8x16_t)__rev0, 48);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vclzq_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vclzq_v((int8x16_t)__p0, 50);
+ __ret = __p0 + __p1;
return __ret;
}
#else
-__ai uint32x4_t vclzq_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vclzq_v((int8x16_t)__rev0, 50);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vclzq_u16(uint16x8_t __p0) {
+__ai __attribute__((target("neon"))) uint64x2_t vaddq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = __p0 + __p1;
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vaddq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 + __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vclzq_v((int8x16_t)__p0, 49);
+ __ret = __p0 + __p1;
return __ret;
}
#else
-__ai uint16x8_t vclzq_u16(uint16x8_t __p0) {
+__ai __attribute__((target("neon"))) uint16x8_t vaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vclzq_v((int8x16_t)__rev0, 49);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vclzq_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vaddq_s8(int8x16_t __p0, int8x16_t __p1) {
int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vclzq_v((int8x16_t)__p0, 32);
+ __ret = __p0 + __p1;
return __ret;
}
#else
-__ai int8x16_t vclzq_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vaddq_s8(int8x16_t __p0, int8x16_t __p1) {
int8x16_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vclzq_v((int8x16_t)__rev0, 32);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vclzq_s32(int32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vaddq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = __p0 + __p1;
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vaddq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vaddq_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vclzq_v((int8x16_t)__p0, 34);
+ __ret = __p0 + __p1;
return __ret;
}
#else
-__ai int32x4_t vclzq_s32(int32x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vaddq_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vclzq_v((int8x16_t)__rev0, 34);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vclzq_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vaddq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ __ret = __p0 + __p1;
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vaddq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 + __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vaddq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vclzq_v((int8x16_t)__p0, 33);
+ __ret = __p0 + __p1;
return __ret;
}
#else
-__ai int16x8_t vclzq_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vaddq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vclzq_v((int8x16_t)__rev0, 33);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vclz_u8(uint8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vclz_v((int8x8_t)__p0, 16);
+ __ret = __p0 + __p1;
return __ret;
}
#else
-__ai uint8x8_t vclz_u8(uint8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint8x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vclz_v((int8x8_t)__rev0, 16);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vclz_u32(uint32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vclz_v((int8x8_t)__p0, 18);
+ __ret = __p0 + __p1;
return __ret;
}
#else
-__ai uint32x2_t vclz_u32(uint32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vclz_v((int8x8_t)__rev0, 18);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 + __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vadd_u64(uint64x1_t __p0, uint64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = __p0 + __p1;
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vclz_u16(uint16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vclz_v((int8x8_t)__p0, 17);
+ __ret = __p0 + __p1;
return __ret;
}
#else
-__ai uint16x4_t vclz_u16(uint16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vclz_v((int8x8_t)__rev0, 17);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vclz_s8(int8x8_t __p0) {
+__ai __attribute__((target("neon"))) int8x8_t vadd_s8(int8x8_t __p0, int8x8_t __p1) {
int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vclz_v((int8x8_t)__p0, 0);
+ __ret = __p0 + __p1;
return __ret;
}
#else
-__ai int8x8_t vclz_s8(int8x8_t __p0) {
+__ai __attribute__((target("neon"))) int8x8_t vadd_s8(int8x8_t __p0, int8x8_t __p1) {
int8x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vclz_v((int8x8_t)__rev0, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vclz_s32(int32x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vadd_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = __p0 + __p1;
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vadd_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 + __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vadd_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vclz_v((int8x8_t)__p0, 2);
+ __ret = __p0 + __p1;
return __ret;
}
#else
-__ai int32x2_t vclz_s32(int32x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vadd_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vclz_v((int8x8_t)__rev0, 2);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 + __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
+__ai __attribute__((target("neon"))) int64x1_t vadd_s64(int64x1_t __p0, int64x1_t __p1) {
+ int64x1_t __ret;
+ __ret = __p0 + __p1;
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vclz_s16(int16x4_t __p0) {
+__ai __attribute__((target("neon"))) int16x4_t vadd_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vclz_v((int8x8_t)__p0, 1);
+ __ret = __p0 + __p1;
return __ret;
}
#else
-__ai int16x4_t vclz_s16(int16x4_t __p0) {
+__ai __attribute__((target("neon"))) int16x4_t vadd_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vclz_v((int8x8_t)__rev0, 1);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vcnt_p8(poly8x8_t __p0) {
+__ai __attribute__((target("neon"))) poly8x8_t vadd_p8(poly8x8_t __p0, poly8x8_t __p1) {
poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vcnt_v((int8x8_t)__p0, 4);
+ __ret = (poly8x8_t) __builtin_neon_vadd_v((int8x8_t)__p0, (int8x8_t)__p1, 4);
return __ret;
}
#else
-__ai poly8x8_t vcnt_p8(poly8x8_t __p0) {
+__ai __attribute__((target("neon"))) poly8x8_t vadd_p8(poly8x8_t __p0, poly8x8_t __p1) {
poly8x8_t __ret;
poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vcnt_v((int8x8_t)__rev0, 4);
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 4);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
+__ai __attribute__((target("neon"))) poly64x1_t vadd_p64(poly64x1_t __p0, poly64x1_t __p1) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t) __builtin_neon_vadd_v((int8x8_t)__p0, (int8x8_t)__p1, 6);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vcntq_p8(poly8x16_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t) __builtin_neon_vcntq_v((int8x16_t)__p0, 36);
+__ai __attribute__((target("neon"))) poly16x4_t vadd_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t) __builtin_neon_vadd_v((int8x8_t)__p0, (int8x8_t)__p1, 5);
return __ret;
}
#else
-__ai poly8x16_t vcntq_p8(poly8x16_t __p0) {
- poly8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x16_t) __builtin_neon_vcntq_v((int8x16_t)__rev0, 36);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly16x4_t vadd_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ poly16x4_t __ret;
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (poly16x4_t) __builtin_neon_vadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 5);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vcntq_u8(uint8x16_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vcntq_v((int8x16_t)__p0, 48);
+__ai __attribute__((target("neon"))) poly8x16_t vaddq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t) __builtin_neon_vaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 36);
return __ret;
}
#else
-__ai uint8x16_t vcntq_u8(uint8x16_t __p0) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vcntq_v((int8x16_t)__rev0, 48);
+__ai __attribute__((target("neon"))) poly8x16_t vaddq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly8x16_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x16_t) __builtin_neon_vaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 36);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vcntq_s8(int8x16_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vcntq_v((int8x16_t)__p0, 32);
+__ai __attribute__((target("neon"))) poly64x2_t vaddq_p64(poly64x2_t __p0, poly64x2_t __p1) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t) __builtin_neon_vaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 38);
return __ret;
}
#else
-__ai int8x16_t vcntq_s8(int8x16_t __p0) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vcntq_v((int8x16_t)__rev0, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly64x2_t vaddq_p64(poly64x2_t __p0, poly64x2_t __p1) {
+ poly64x2_t __ret;
+ poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (poly64x2_t) __builtin_neon_vaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 38);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vcnt_u8(uint8x8_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vcnt_v((int8x8_t)__p0, 16);
+__ai __attribute__((target("neon"))) poly16x8_t vaddq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t) __builtin_neon_vaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 37);
return __ret;
}
#else
-__ai uint8x8_t vcnt_u8(uint8x8_t __p0) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vcnt_v((int8x8_t)__rev0, 16);
+__ai __attribute__((target("neon"))) poly16x8_t vaddq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+ poly16x8_t __ret;
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly16x8_t) __builtin_neon_vaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 37);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vcnt_s8(int8x8_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vcnt_v((int8x8_t)__p0, 0);
+__ai __attribute__((target("neon"))) uint16x4_t vaddhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
return __ret;
}
#else
-__ai int8x8_t vcnt_s8(int8x8_t __p0) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vcnt_v((int8x8_t)__rev0, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint16x4_t vaddhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint16x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vaddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t __noswap_vaddhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vcombine_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+__ai __attribute__((target("neon"))) uint32x2_t vaddhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
return __ret;
}
#else
-__ai poly8x16_t vcombine_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x16_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x2_t vaddhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint32x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vaddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t __noswap_vaddhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x8_t vcombine_p16(poly16x4_t __p0, poly16x4_t __p1) {
- poly16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) uint8x8_t vaddhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
return __ret;
}
#else
-__ai poly16x8_t vcombine_p16(poly16x4_t __p0, poly16x4_t __p1) {
- poly16x8_t __ret;
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) uint8x8_t vaddhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint8x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vaddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 16);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) uint8x8_t __noswap_vaddhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vcombine_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+__ai __attribute__((target("neon"))) int16x4_t vaddhn_s32(int32x4_t __p0, int32x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
return __ret;
}
#else
-__ai uint8x16_t vcombine_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x16_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-__ai uint8x16_t __noswap_vcombine_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcombine_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3);
- return __ret;
-}
-#else
-__ai uint32x4_t vcombine_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x4_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3);
+__ai __attribute__((target("neon"))) int16x4_t vaddhn_s32(int32x4_t __p0, int32x4_t __p1) {
+ int16x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vaddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai uint32x4_t __noswap_vcombine_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3);
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vaddhn_s32(int32x4_t __p0, int32x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcombine_u64(uint64x1_t __p0, uint64x1_t __p1) {
- uint64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+__ai __attribute__((target("neon"))) int32x2_t vaddhn_s64(int64x2_t __p0, int64x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
return __ret;
}
#else
-__ai uint64x2_t vcombine_u64(uint64x1_t __p0, uint64x1_t __p1) {
- uint64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+__ai __attribute__((target("neon"))) int32x2_t vaddhn_s64(int64x2_t __p0, int64x2_t __p1) {
+ int32x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vaddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 2);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vaddhn_s64(int64x2_t __p0, int64x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vcombine_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) int8x8_t vaddhn_s16(int16x8_t __p0, int16x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
return __ret;
}
#else
-__ai uint16x8_t vcombine_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x8_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) int8x8_t vaddhn_s16(int16x8_t __p0, int16x8_t __p1) {
+ int8x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vaddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 0);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai uint16x8_t __noswap_vcombine_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) int8x8_t __noswap_vaddhn_s16(int16x8_t __p0, int16x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vcombine_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+__ai __attribute__((target("neon"))) uint8x16_t vandq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = __p0 & __p1;
return __ret;
}
#else
-__ai int8x16_t vcombine_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x16_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+__ai __attribute__((target("neon"))) uint8x16_t vandq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 & __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai int8x16_t __noswap_vcombine_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vcombine_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3);
+__ai __attribute__((target("neon"))) uint32x4_t vandq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = __p0 & __p1;
return __ret;
}
#else
-__ai float32x4_t vcombine_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x4_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3);
+__ai __attribute__((target("neon"))) uint32x4_t vandq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 & __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai float32x4_t __noswap_vcombine_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vandq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = __p0 & __p1;
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vandq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 & __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float16x8_t vcombine_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) uint16x8_t vandq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = __p0 & __p1;
return __ret;
}
#else
-__ai float16x8_t vcombine_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x8_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) uint16x8_t vandq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 & __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai float16x8_t __noswap_vcombine_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vandq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = __p0 & __p1;
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vandq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 & __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vcombine_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vandq_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3);
+ __ret = __p0 & __p1;
return __ret;
}
#else
-__ai int32x4_t vcombine_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vandq_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3);
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 & __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int32x4_t __noswap_vcombine_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vcombine_s64(int64x1_t __p0, int64x1_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vandq_s64(int64x2_t __p0, int64x2_t __p1) {
int64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+ __ret = __p0 & __p1;
return __ret;
}
#else
-__ai int64x2_t vcombine_s64(int64x1_t __p0, int64x1_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vandq_s64(int64x2_t __p0, int64x2_t __p1) {
int64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 & __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vcombine_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vandq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+ __ret = __p0 & __p1;
return __ret;
}
#else
-__ai int16x8_t vcombine_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vandq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7);
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 & __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai int16x8_t __noswap_vcombine_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vand_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = __p0 & __p1;
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vand_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 & __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
-#define vcreate_p8(__p0) __extension__ ({ \
- poly8x8_t __ret; \
- uint64_t __promote = __p0; \
- __ret = (poly8x8_t)(__promote); \
- __ret; \
-})
-#define vcreate_p16(__p0) __extension__ ({ \
- poly16x4_t __ret; \
- uint64_t __promote = __p0; \
- __ret = (poly16x4_t)(__promote); \
- __ret; \
-})
-#define vcreate_u8(__p0) __extension__ ({ \
- uint8x8_t __ret; \
- uint64_t __promote = __p0; \
- __ret = (uint8x8_t)(__promote); \
- __ret; \
-})
-#define vcreate_u32(__p0) __extension__ ({ \
- uint32x2_t __ret; \
- uint64_t __promote = __p0; \
- __ret = (uint32x2_t)(__promote); \
- __ret; \
-})
-#define vcreate_u64(__p0) __extension__ ({ \
- uint64x1_t __ret; \
- uint64_t __promote = __p0; \
- __ret = (uint64x1_t)(__promote); \
- __ret; \
-})
-#define vcreate_u16(__p0) __extension__ ({ \
- uint16x4_t __ret; \
- uint64_t __promote = __p0; \
- __ret = (uint16x4_t)(__promote); \
- __ret; \
-})
-#define vcreate_s8(__p0) __extension__ ({ \
- int8x8_t __ret; \
- uint64_t __promote = __p0; \
- __ret = (int8x8_t)(__promote); \
- __ret; \
-})
-#define vcreate_f32(__p0) __extension__ ({ \
- float32x2_t __ret; \
- uint64_t __promote = __p0; \
- __ret = (float32x2_t)(__promote); \
- __ret; \
-})
-#define vcreate_f16(__p0) __extension__ ({ \
- float16x4_t __ret; \
- uint64_t __promote = __p0; \
- __ret = (float16x4_t)(__promote); \
- __ret; \
-})
-#define vcreate_s32(__p0) __extension__ ({ \
- int32x2_t __ret; \
- uint64_t __promote = __p0; \
- __ret = (int32x2_t)(__promote); \
- __ret; \
-})
-#define vcreate_s64(__p0) __extension__ ({ \
- int64x1_t __ret; \
- uint64_t __promote = __p0; \
- __ret = (int64x1_t)(__promote); \
- __ret; \
-})
-#define vcreate_s16(__p0) __extension__ ({ \
- int16x4_t __ret; \
- uint64_t __promote = __p0; \
- __ret = (int16x4_t)(__promote); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vcvtq_f32_u32(uint32x4_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vcvtq_f32_v((int8x16_t)__p0, 50);
+__ai __attribute__((target("neon"))) uint32x2_t vand_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = __p0 & __p1;
return __ret;
}
#else
-__ai float32x4_t vcvtq_f32_u32(uint32x4_t __p0) {
- float32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vcvtq_f32_v((int8x16_t)__rev0, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x2_t vand_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 & __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vand_u64(uint64x1_t __p0, uint64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = __p0 & __p1;
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vcvtq_f32_s32(int32x4_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vcvtq_f32_v((int8x16_t)__p0, 34);
+__ai __attribute__((target("neon"))) uint16x4_t vand_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = __p0 & __p1;
return __ret;
}
#else
-__ai float32x4_t vcvtq_f32_s32(int32x4_t __p0) {
- float32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vcvtq_f32_v((int8x16_t)__rev0, 34);
+__ai __attribute__((target("neon"))) uint16x4_t vand_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 & __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vcvt_f32_u32(uint32x2_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vcvt_f32_v((int8x8_t)__p0, 18);
+__ai __attribute__((target("neon"))) int8x8_t vand_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = __p0 & __p1;
return __ret;
}
#else
-__ai float32x2_t vcvt_f32_u32(uint32x2_t __p0) {
- float32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vcvt_f32_v((int8x8_t)__rev0, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int8x8_t vand_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 & __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vcvt_f32_s32(int32x2_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vcvt_f32_v((int8x8_t)__p0, 2);
+__ai __attribute__((target("neon"))) int32x2_t vand_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = __p0 & __p1;
return __ret;
}
#else
-__ai float32x2_t vcvt_f32_s32(int32x2_t __p0) {
- float32x2_t __ret;
+__ai __attribute__((target("neon"))) int32x2_t vand_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vcvt_f32_v((int8x8_t)__rev0, 2);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 & __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
+__ai __attribute__((target("neon"))) int64x1_t vand_s64(int64x1_t __p0, int64x1_t __p1) {
+ int64x1_t __ret;
+ __ret = __p0 & __p1;
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vcvtq_n_f32_u32(__p0, __p1) __extension__ ({ \
- float32x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- __ret = (float32x4_t) __builtin_neon_vcvtq_n_f32_v((int8x16_t)__s0, __p1, 50); \
- __ret; \
-})
-#else
-#define vcvtq_n_f32_u32(__p0, __p1) __extension__ ({ \
- float32x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (float32x4_t) __builtin_neon_vcvtq_n_f32_v((int8x16_t)__rev0, __p1, 50); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcvtq_n_f32_s32(__p0, __p1) __extension__ ({ \
- float32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (float32x4_t) __builtin_neon_vcvtq_n_f32_v((int8x16_t)__s0, __p1, 34); \
- __ret; \
-})
-#else
-#define vcvtq_n_f32_s32(__p0, __p1) __extension__ ({ \
- float32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (float32x4_t) __builtin_neon_vcvtq_n_f32_v((int8x16_t)__rev0, __p1, 34); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcvt_n_f32_u32(__p0, __p1) __extension__ ({ \
- float32x2_t __ret; \
- uint32x2_t __s0 = __p0; \
- __ret = (float32x2_t) __builtin_neon_vcvt_n_f32_v((int8x8_t)__s0, __p1, 18); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vand_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = __p0 & __p1;
+ return __ret;
+}
#else
-#define vcvt_n_f32_u32(__p0, __p1) __extension__ ({ \
- float32x2_t __ret; \
- uint32x2_t __s0 = __p0; \
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (float32x2_t) __builtin_neon_vcvt_n_f32_v((int8x8_t)__rev0, __p1, 18); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vand_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 & __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcvt_n_f32_s32(__p0, __p1) __extension__ ({ \
- float32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- __ret = (float32x2_t) __builtin_neon_vcvt_n_f32_v((int8x8_t)__s0, __p1, 2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vbicq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = __p0 & ~__p1;
+ return __ret;
+}
#else
-#define vcvt_n_f32_s32(__p0, __p1) __extension__ ({ \
- float32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (float32x2_t) __builtin_neon_vcvt_n_f32_v((int8x8_t)__rev0, __p1, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vbicq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 & ~__rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcvtq_n_s32_f32(__p0, __p1) __extension__ ({ \
- int32x4_t __ret; \
- float32x4_t __s0 = __p0; \
- __ret = (int32x4_t) __builtin_neon_vcvtq_n_s32_v((int8x16_t)__s0, __p1, 34); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vbicq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = __p0 & ~__p1;
+ return __ret;
+}
#else
-#define vcvtq_n_s32_f32(__p0, __p1) __extension__ ({ \
- int32x4_t __ret; \
- float32x4_t __s0 = __p0; \
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_vcvtq_n_s32_v((int8x16_t)__rev0, __p1, 34); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vbicq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 & ~__rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcvt_n_s32_f32(__p0, __p1) __extension__ ({ \
- int32x2_t __ret; \
- float32x2_t __s0 = __p0; \
- __ret = (int32x2_t) __builtin_neon_vcvt_n_s32_v((int8x8_t)__s0, __p1, 2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vbicq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = __p0 & ~__p1;
+ return __ret;
+}
#else
-#define vcvt_n_s32_f32(__p0, __p1) __extension__ ({ \
- int32x2_t __ret; \
- float32x2_t __s0 = __p0; \
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vcvt_n_s32_v((int8x8_t)__rev0, __p1, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vbicq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 & ~__rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcvtq_n_u32_f32(__p0, __p1) __extension__ ({ \
- uint32x4_t __ret; \
- float32x4_t __s0 = __p0; \
- __ret = (uint32x4_t) __builtin_neon_vcvtq_n_u32_v((int8x16_t)__s0, __p1, 50); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vbicq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = __p0 & ~__p1;
+ return __ret;
+}
#else
-#define vcvtq_n_u32_f32(__p0, __p1) __extension__ ({ \
- uint32x4_t __ret; \
- float32x4_t __s0 = __p0; \
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint32x4_t) __builtin_neon_vcvtq_n_u32_v((int8x16_t)__rev0, __p1, 50); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vbicq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 & ~__rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcvt_n_u32_f32(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- float32x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_vcvt_n_u32_v((int8x8_t)__s0, __p1, 18); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vbicq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = __p0 & ~__p1;
+ return __ret;
+}
#else
-#define vcvt_n_u32_f32(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- float32x2_t __s0 = __p0; \
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vcvt_n_u32_v((int8x8_t)__rev0, __p1, 18); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vbicq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 & ~__rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vcvtq_s32_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vbicq_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vcvtq_s32_v((int8x16_t)__p0, 34);
+ __ret = __p0 & ~__p1;
return __ret;
}
#else
-__ai int32x4_t vcvtq_s32_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vbicq_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vcvtq_s32_v((int8x16_t)__rev0, 34);
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 & ~__rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vcvt_s32_f32(float32x2_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vcvt_s32_v((int8x8_t)__p0, 2);
+__ai __attribute__((target("neon"))) int64x2_t vbicq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ __ret = __p0 & ~__p1;
return __ret;
}
#else
-__ai int32x2_t vcvt_s32_f32(float32x2_t __p0) {
- int32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vcvt_s32_v((int8x8_t)__rev0, 2);
+__ai __attribute__((target("neon"))) int64x2_t vbicq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 & ~__rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcvtq_u32_f32(float32x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vcvtq_u32_v((int8x16_t)__p0, 50);
+__ai __attribute__((target("neon"))) int16x8_t vbicq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = __p0 & ~__p1;
return __ret;
}
#else
-__ai uint32x4_t vcvtq_u32_f32(float32x4_t __p0) {
- uint32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vcvtq_u32_v((int8x16_t)__rev0, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16x8_t vbicq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 & ~__rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcvt_u32_f32(float32x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vcvt_u32_v((int8x8_t)__p0, 18);
+__ai __attribute__((target("neon"))) uint8x8_t vbic_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = __p0 & ~__p1;
return __ret;
}
#else
-__ai uint32x2_t vcvt_u32_f32(float32x2_t __p0) {
- uint32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vcvt_u32_v((int8x8_t)__rev0, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint8x8_t vbic_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 & ~__rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdup_lane_p8(__p0_0, __p1_0) __extension__ ({ \
- poly8x8_t __ret_0; \
- poly8x8_t __s0_0 = __p0_0; \
- __ret_0 = splat_lane_p8(__s0_0, __p1_0); \
- __ret_0; \
-})
-#else
-#define vdup_lane_p8(__p0_1, __p1_1) __extension__ ({ \
- poly8x8_t __ret_1; \
- poly8x8_t __s0_1 = __p0_1; \
- poly8x8_t __rev0_1; __rev0_1 = __builtin_shufflevector(__s0_1, __s0_1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_1 = __noswap_splat_lane_p8(__rev0_1, __p1_1); \
- __ret_1 = __builtin_shufflevector(__ret_1, __ret_1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_1; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vdup_lane_p16(__p0_2, __p1_2) __extension__ ({ \
- poly16x4_t __ret_2; \
- poly16x4_t __s0_2 = __p0_2; \
- __ret_2 = splat_lane_p16(__s0_2, __p1_2); \
- __ret_2; \
-})
-#else
-#define vdup_lane_p16(__p0_3, __p1_3) __extension__ ({ \
- poly16x4_t __ret_3; \
- poly16x4_t __s0_3 = __p0_3; \
- poly16x4_t __rev0_3; __rev0_3 = __builtin_shufflevector(__s0_3, __s0_3, 3, 2, 1, 0); \
- __ret_3 = __noswap_splat_lane_p16(__rev0_3, __p1_3); \
- __ret_3 = __builtin_shufflevector(__ret_3, __ret_3, 3, 2, 1, 0); \
- __ret_3; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vdupq_lane_p8(__p0_4, __p1_4) __extension__ ({ \
- poly8x16_t __ret_4; \
- poly8x8_t __s0_4 = __p0_4; \
- __ret_4 = splatq_lane_p8(__s0_4, __p1_4); \
- __ret_4; \
-})
-#else
-#define vdupq_lane_p8(__p0_5, __p1_5) __extension__ ({ \
- poly8x16_t __ret_5; \
- poly8x8_t __s0_5 = __p0_5; \
- poly8x8_t __rev0_5; __rev0_5 = __builtin_shufflevector(__s0_5, __s0_5, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_5 = __noswap_splatq_lane_p8(__rev0_5, __p1_5); \
- __ret_5 = __builtin_shufflevector(__ret_5, __ret_5, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_5; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vdupq_lane_p16(__p0_6, __p1_6) __extension__ ({ \
- poly16x8_t __ret_6; \
- poly16x4_t __s0_6 = __p0_6; \
- __ret_6 = splatq_lane_p16(__s0_6, __p1_6); \
- __ret_6; \
-})
-#else
-#define vdupq_lane_p16(__p0_7, __p1_7) __extension__ ({ \
- poly16x8_t __ret_7; \
- poly16x4_t __s0_7 = __p0_7; \
- poly16x4_t __rev0_7; __rev0_7 = __builtin_shufflevector(__s0_7, __s0_7, 3, 2, 1, 0); \
- __ret_7 = __noswap_splatq_lane_p16(__rev0_7, __p1_7); \
- __ret_7 = __builtin_shufflevector(__ret_7, __ret_7, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_7; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vdupq_lane_u8(__p0_8, __p1_8) __extension__ ({ \
- uint8x16_t __ret_8; \
- uint8x8_t __s0_8 = __p0_8; \
- __ret_8 = splatq_lane_u8(__s0_8, __p1_8); \
- __ret_8; \
-})
-#else
-#define vdupq_lane_u8(__p0_9, __p1_9) __extension__ ({ \
- uint8x16_t __ret_9; \
- uint8x8_t __s0_9 = __p0_9; \
- uint8x8_t __rev0_9; __rev0_9 = __builtin_shufflevector(__s0_9, __s0_9, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_9 = __noswap_splatq_lane_u8(__rev0_9, __p1_9); \
- __ret_9 = __builtin_shufflevector(__ret_9, __ret_9, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_9; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vdupq_lane_u32(__p0_10, __p1_10) __extension__ ({ \
- uint32x4_t __ret_10; \
- uint32x2_t __s0_10 = __p0_10; \
- __ret_10 = splatq_lane_u32(__s0_10, __p1_10); \
- __ret_10; \
-})
-#else
-#define vdupq_lane_u32(__p0_11, __p1_11) __extension__ ({ \
- uint32x4_t __ret_11; \
- uint32x2_t __s0_11 = __p0_11; \
- uint32x2_t __rev0_11; __rev0_11 = __builtin_shufflevector(__s0_11, __s0_11, 1, 0); \
- __ret_11 = __noswap_splatq_lane_u32(__rev0_11, __p1_11); \
- __ret_11 = __builtin_shufflevector(__ret_11, __ret_11, 3, 2, 1, 0); \
- __ret_11; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vdupq_lane_u64(__p0_12, __p1_12) __extension__ ({ \
- uint64x2_t __ret_12; \
- uint64x1_t __s0_12 = __p0_12; \
- __ret_12 = splatq_lane_u64(__s0_12, __p1_12); \
- __ret_12; \
-})
-#else
-#define vdupq_lane_u64(__p0_13, __p1_13) __extension__ ({ \
- uint64x2_t __ret_13; \
- uint64x1_t __s0_13 = __p0_13; \
- __ret_13 = __noswap_splatq_lane_u64(__s0_13, __p1_13); \
- __ret_13 = __builtin_shufflevector(__ret_13, __ret_13, 1, 0); \
- __ret_13; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vdupq_lane_u16(__p0_14, __p1_14) __extension__ ({ \
- uint16x8_t __ret_14; \
- uint16x4_t __s0_14 = __p0_14; \
- __ret_14 = splatq_lane_u16(__s0_14, __p1_14); \
- __ret_14; \
-})
-#else
-#define vdupq_lane_u16(__p0_15, __p1_15) __extension__ ({ \
- uint16x8_t __ret_15; \
- uint16x4_t __s0_15 = __p0_15; \
- uint16x4_t __rev0_15; __rev0_15 = __builtin_shufflevector(__s0_15, __s0_15, 3, 2, 1, 0); \
- __ret_15 = __noswap_splatq_lane_u16(__rev0_15, __p1_15); \
- __ret_15 = __builtin_shufflevector(__ret_15, __ret_15, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_15; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vdupq_lane_s8(__p0_16, __p1_16) __extension__ ({ \
- int8x16_t __ret_16; \
- int8x8_t __s0_16 = __p0_16; \
- __ret_16 = splatq_lane_s8(__s0_16, __p1_16); \
- __ret_16; \
-})
-#else
-#define vdupq_lane_s8(__p0_17, __p1_17) __extension__ ({ \
- int8x16_t __ret_17; \
- int8x8_t __s0_17 = __p0_17; \
- int8x8_t __rev0_17; __rev0_17 = __builtin_shufflevector(__s0_17, __s0_17, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_17 = __noswap_splatq_lane_s8(__rev0_17, __p1_17); \
- __ret_17 = __builtin_shufflevector(__ret_17, __ret_17, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_17; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vdupq_lane_f32(__p0_18, __p1_18) __extension__ ({ \
- float32x4_t __ret_18; \
- float32x2_t __s0_18 = __p0_18; \
- __ret_18 = splatq_lane_f32(__s0_18, __p1_18); \
- __ret_18; \
-})
-#else
-#define vdupq_lane_f32(__p0_19, __p1_19) __extension__ ({ \
- float32x4_t __ret_19; \
- float32x2_t __s0_19 = __p0_19; \
- float32x2_t __rev0_19; __rev0_19 = __builtin_shufflevector(__s0_19, __s0_19, 1, 0); \
- __ret_19 = __noswap_splatq_lane_f32(__rev0_19, __p1_19); \
- __ret_19 = __builtin_shufflevector(__ret_19, __ret_19, 3, 2, 1, 0); \
- __ret_19; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vdupq_lane_f16(__p0_20, __p1_20) __extension__ ({ \
- float16x8_t __ret_20; \
- float16x4_t __s0_20 = __p0_20; \
- __ret_20 = splatq_lane_f16(__s0_20, __p1_20); \
- __ret_20; \
-})
-#else
-#define vdupq_lane_f16(__p0_21, __p1_21) __extension__ ({ \
- float16x8_t __ret_21; \
- float16x4_t __s0_21 = __p0_21; \
- float16x4_t __rev0_21; __rev0_21 = __builtin_shufflevector(__s0_21, __s0_21, 3, 2, 1, 0); \
- __ret_21 = __noswap_splatq_lane_f16(__rev0_21, __p1_21); \
- __ret_21 = __builtin_shufflevector(__ret_21, __ret_21, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_21; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vdupq_lane_s32(__p0_22, __p1_22) __extension__ ({ \
- int32x4_t __ret_22; \
- int32x2_t __s0_22 = __p0_22; \
- __ret_22 = splatq_lane_s32(__s0_22, __p1_22); \
- __ret_22; \
-})
-#else
-#define vdupq_lane_s32(__p0_23, __p1_23) __extension__ ({ \
- int32x4_t __ret_23; \
- int32x2_t __s0_23 = __p0_23; \
- int32x2_t __rev0_23; __rev0_23 = __builtin_shufflevector(__s0_23, __s0_23, 1, 0); \
- __ret_23 = __noswap_splatq_lane_s32(__rev0_23, __p1_23); \
- __ret_23 = __builtin_shufflevector(__ret_23, __ret_23, 3, 2, 1, 0); \
- __ret_23; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vdupq_lane_s64(__p0_24, __p1_24) __extension__ ({ \
- int64x2_t __ret_24; \
- int64x1_t __s0_24 = __p0_24; \
- __ret_24 = splatq_lane_s64(__s0_24, __p1_24); \
- __ret_24; \
-})
-#else
-#define vdupq_lane_s64(__p0_25, __p1_25) __extension__ ({ \
- int64x2_t __ret_25; \
- int64x1_t __s0_25 = __p0_25; \
- __ret_25 = __noswap_splatq_lane_s64(__s0_25, __p1_25); \
- __ret_25 = __builtin_shufflevector(__ret_25, __ret_25, 1, 0); \
- __ret_25; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vdupq_lane_s16(__p0_26, __p1_26) __extension__ ({ \
- int16x8_t __ret_26; \
- int16x4_t __s0_26 = __p0_26; \
- __ret_26 = splatq_lane_s16(__s0_26, __p1_26); \
- __ret_26; \
-})
-#else
-#define vdupq_lane_s16(__p0_27, __p1_27) __extension__ ({ \
- int16x8_t __ret_27; \
- int16x4_t __s0_27 = __p0_27; \
- int16x4_t __rev0_27; __rev0_27 = __builtin_shufflevector(__s0_27, __s0_27, 3, 2, 1, 0); \
- __ret_27 = __noswap_splatq_lane_s16(__rev0_27, __p1_27); \
- __ret_27 = __builtin_shufflevector(__ret_27, __ret_27, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_27; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vdup_lane_u8(__p0_28, __p1_28) __extension__ ({ \
- uint8x8_t __ret_28; \
- uint8x8_t __s0_28 = __p0_28; \
- __ret_28 = splat_lane_u8(__s0_28, __p1_28); \
- __ret_28; \
-})
-#else
-#define vdup_lane_u8(__p0_29, __p1_29) __extension__ ({ \
- uint8x8_t __ret_29; \
- uint8x8_t __s0_29 = __p0_29; \
- uint8x8_t __rev0_29; __rev0_29 = __builtin_shufflevector(__s0_29, __s0_29, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_29 = __noswap_splat_lane_u8(__rev0_29, __p1_29); \
- __ret_29 = __builtin_shufflevector(__ret_29, __ret_29, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_29; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vdup_lane_u32(__p0_30, __p1_30) __extension__ ({ \
- uint32x2_t __ret_30; \
- uint32x2_t __s0_30 = __p0_30; \
- __ret_30 = splat_lane_u32(__s0_30, __p1_30); \
- __ret_30; \
-})
-#else
-#define vdup_lane_u32(__p0_31, __p1_31) __extension__ ({ \
- uint32x2_t __ret_31; \
- uint32x2_t __s0_31 = __p0_31; \
- uint32x2_t __rev0_31; __rev0_31 = __builtin_shufflevector(__s0_31, __s0_31, 1, 0); \
- __ret_31 = __noswap_splat_lane_u32(__rev0_31, __p1_31); \
- __ret_31 = __builtin_shufflevector(__ret_31, __ret_31, 1, 0); \
- __ret_31; \
-})
-#endif
-
-#define vdup_lane_u64(__p0_32, __p1_32) __extension__ ({ \
- uint64x1_t __ret_32; \
- uint64x1_t __s0_32 = __p0_32; \
- __ret_32 = splat_lane_u64(__s0_32, __p1_32); \
- __ret_32; \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vdup_lane_u16(__p0_33, __p1_33) __extension__ ({ \
- uint16x4_t __ret_33; \
- uint16x4_t __s0_33 = __p0_33; \
- __ret_33 = splat_lane_u16(__s0_33, __p1_33); \
- __ret_33; \
-})
-#else
-#define vdup_lane_u16(__p0_34, __p1_34) __extension__ ({ \
- uint16x4_t __ret_34; \
- uint16x4_t __s0_34 = __p0_34; \
- uint16x4_t __rev0_34; __rev0_34 = __builtin_shufflevector(__s0_34, __s0_34, 3, 2, 1, 0); \
- __ret_34 = __noswap_splat_lane_u16(__rev0_34, __p1_34); \
- __ret_34 = __builtin_shufflevector(__ret_34, __ret_34, 3, 2, 1, 0); \
- __ret_34; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vdup_lane_s8(__p0_35, __p1_35) __extension__ ({ \
- int8x8_t __ret_35; \
- int8x8_t __s0_35 = __p0_35; \
- __ret_35 = splat_lane_s8(__s0_35, __p1_35); \
- __ret_35; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vbic_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = __p0 & ~__p1;
+ return __ret;
+}
#else
-#define vdup_lane_s8(__p0_36, __p1_36) __extension__ ({ \
- int8x8_t __ret_36; \
- int8x8_t __s0_36 = __p0_36; \
- int8x8_t __rev0_36; __rev0_36 = __builtin_shufflevector(__s0_36, __s0_36, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_36 = __noswap_splat_lane_s8(__rev0_36, __p1_36); \
- __ret_36 = __builtin_shufflevector(__ret_36, __ret_36, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_36; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vbic_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 & ~__rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vbic_u64(uint64x1_t __p0, uint64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = __p0 & ~__p1;
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vdup_lane_f32(__p0_37, __p1_37) __extension__ ({ \
- float32x2_t __ret_37; \
- float32x2_t __s0_37 = __p0_37; \
- __ret_37 = splat_lane_f32(__s0_37, __p1_37); \
- __ret_37; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vbic_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = __p0 & ~__p1;
+ return __ret;
+}
#else
-#define vdup_lane_f32(__p0_38, __p1_38) __extension__ ({ \
- float32x2_t __ret_38; \
- float32x2_t __s0_38 = __p0_38; \
- float32x2_t __rev0_38; __rev0_38 = __builtin_shufflevector(__s0_38, __s0_38, 1, 0); \
- __ret_38 = __noswap_splat_lane_f32(__rev0_38, __p1_38); \
- __ret_38 = __builtin_shufflevector(__ret_38, __ret_38, 1, 0); \
- __ret_38; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vbic_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 & ~__rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdup_lane_f16(__p0_39, __p1_39) __extension__ ({ \
- float16x4_t __ret_39; \
- float16x4_t __s0_39 = __p0_39; \
- __ret_39 = splat_lane_f16(__s0_39, __p1_39); \
- __ret_39; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vbic_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = __p0 & ~__p1;
+ return __ret;
+}
#else
-#define vdup_lane_f16(__p0_40, __p1_40) __extension__ ({ \
- float16x4_t __ret_40; \
- float16x4_t __s0_40 = __p0_40; \
- float16x4_t __rev0_40; __rev0_40 = __builtin_shufflevector(__s0_40, __s0_40, 3, 2, 1, 0); \
- __ret_40 = __noswap_splat_lane_f16(__rev0_40, __p1_40); \
- __ret_40 = __builtin_shufflevector(__ret_40, __ret_40, 3, 2, 1, 0); \
- __ret_40; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vbic_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 & ~__rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdup_lane_s32(__p0_41, __p1_41) __extension__ ({ \
- int32x2_t __ret_41; \
- int32x2_t __s0_41 = __p0_41; \
- __ret_41 = splat_lane_s32(__s0_41, __p1_41); \
- __ret_41; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vbic_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = __p0 & ~__p1;
+ return __ret;
+}
#else
-#define vdup_lane_s32(__p0_42, __p1_42) __extension__ ({ \
- int32x2_t __ret_42; \
- int32x2_t __s0_42 = __p0_42; \
- int32x2_t __rev0_42; __rev0_42 = __builtin_shufflevector(__s0_42, __s0_42, 1, 0); \
- __ret_42 = __noswap_splat_lane_s32(__rev0_42, __p1_42); \
- __ret_42 = __builtin_shufflevector(__ret_42, __ret_42, 1, 0); \
- __ret_42; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vbic_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 & ~__rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
-#define vdup_lane_s64(__p0_43, __p1_43) __extension__ ({ \
- int64x1_t __ret_43; \
- int64x1_t __s0_43 = __p0_43; \
- __ret_43 = splat_lane_s64(__s0_43, __p1_43); \
- __ret_43; \
-})
+__ai __attribute__((target("neon"))) int64x1_t vbic_s64(int64x1_t __p0, int64x1_t __p1) {
+ int64x1_t __ret;
+ __ret = __p0 & ~__p1;
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vdup_lane_s16(__p0_44, __p1_44) __extension__ ({ \
- int16x4_t __ret_44; \
- int16x4_t __s0_44 = __p0_44; \
- __ret_44 = splat_lane_s16(__s0_44, __p1_44); \
- __ret_44; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vbic_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = __p0 & ~__p1;
+ return __ret;
+}
#else
-#define vdup_lane_s16(__p0_45, __p1_45) __extension__ ({ \
- int16x4_t __ret_45; \
- int16x4_t __s0_45 = __p0_45; \
- int16x4_t __rev0_45; __rev0_45 = __builtin_shufflevector(__s0_45, __s0_45, 3, 2, 1, 0); \
- __ret_45 = __noswap_splat_lane_s16(__rev0_45, __p1_45); \
- __ret_45 = __builtin_shufflevector(__ret_45, __ret_45, 3, 2, 1, 0); \
- __ret_45; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vbic_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 & ~__rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vdup_n_p8(poly8_t __p0) {
+__ai __attribute__((target("neon"))) poly8x8_t vbsl_p8(uint8x8_t __p0, poly8x8_t __p1, poly8x8_t __p2) {
poly8x8_t __ret;
- __ret = (poly8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = (poly8x8_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 4);
return __ret;
}
#else
-__ai poly8x8_t vdup_n_p8(poly8_t __p0) {
+__ai __attribute__((target("neon"))) poly8x8_t vbsl_p8(uint8x8_t __p0, poly8x8_t __p1, poly8x8_t __p2) {
poly8x8_t __ret;
- __ret = (poly8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 4);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x4_t vdup_n_p16(poly16_t __p0) {
+__ai __attribute__((target("neon"))) poly16x4_t vbsl_p16(uint16x4_t __p0, poly16x4_t __p1, poly16x4_t __p2) {
poly16x4_t __ret;
- __ret = (poly16x4_t) {__p0, __p0, __p0, __p0};
+ __ret = (poly16x4_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 5);
return __ret;
}
#else
-__ai poly16x4_t vdup_n_p16(poly16_t __p0) {
+__ai __attribute__((target("neon"))) poly16x4_t vbsl_p16(uint16x4_t __p0, poly16x4_t __p1, poly16x4_t __p2) {
poly16x4_t __ret;
- __ret = (poly16x4_t) {__p0, __p0, __p0, __p0};
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ poly16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (poly16x4_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 5);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vdupq_n_p8(poly8_t __p0) {
+__ai __attribute__((target("neon"))) poly8x16_t vbslq_p8(uint8x16_t __p0, poly8x16_t __p1, poly8x16_t __p2) {
poly8x16_t __ret;
- __ret = (poly8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = (poly8x16_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 36);
return __ret;
}
#else
-__ai poly8x16_t vdupq_n_p8(poly8_t __p0) {
+__ai __attribute__((target("neon"))) poly8x16_t vbslq_p8(uint8x16_t __p0, poly8x16_t __p1, poly8x16_t __p2) {
poly8x16_t __ret;
- __ret = (poly8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x16_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 36);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x8_t vdupq_n_p16(poly16_t __p0) {
+__ai __attribute__((target("neon"))) poly16x8_t vbslq_p16(uint16x8_t __p0, poly16x8_t __p1, poly16x8_t __p2) {
poly16x8_t __ret;
- __ret = (poly16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = (poly16x8_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 37);
return __ret;
}
#else
-__ai poly16x8_t vdupq_n_p16(poly16_t __p0) {
+__ai __attribute__((target("neon"))) poly16x8_t vbslq_p16(uint16x8_t __p0, poly16x8_t __p1, poly16x8_t __p2) {
poly16x8_t __ret;
- __ret = (poly16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly16x8_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 37);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vdupq_n_u8(uint8_t __p0) {
+__ai __attribute__((target("neon"))) uint8x16_t vbslq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint8x16_t __ret;
- __ret = (uint8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = (uint8x16_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 48);
return __ret;
}
#else
-__ai uint8x16_t vdupq_n_u8(uint8_t __p0) {
+__ai __attribute__((target("neon"))) uint8x16_t vbslq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint8x16_t __ret;
- __ret = (uint8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 48);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vdupq_n_u32(uint32_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vbslq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
- __ret = (uint32x4_t) {__p0, __p0, __p0, __p0};
+ __ret = (uint32x4_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
return __ret;
}
#else
-__ai uint32x4_t vdupq_n_u32(uint32_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vbslq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
- __ret = (uint32x4_t) {__p0, __p0, __p0, __p0};
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ uint32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 50);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vdupq_n_u64(uint64_t __p0) {
+__ai __attribute__((target("neon"))) uint64x2_t vbslq_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
uint64x2_t __ret;
- __ret = (uint64x2_t) {__p0, __p0};
+ __ret = (uint64x2_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 51);
return __ret;
}
#else
-__ai uint64x2_t vdupq_n_u64(uint64_t __p0) {
+__ai __attribute__((target("neon"))) uint64x2_t vbslq_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
uint64x2_t __ret;
- __ret = (uint64x2_t) {__p0, __p0};
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ uint64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 51);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vdupq_n_u16(uint16_t __p0) {
+__ai __attribute__((target("neon"))) uint16x8_t vbslq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
uint16x8_t __ret;
- __ret = (uint16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = (uint16x8_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 49);
return __ret;
}
#else
-__ai uint16x8_t vdupq_n_u16(uint16_t __p0) {
+__ai __attribute__((target("neon"))) uint16x8_t vbslq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
uint16x8_t __ret;
- __ret = (uint16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 49);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vdupq_n_s8(int8_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vbslq_s8(uint8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
int8x16_t __ret;
- __ret = (int8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = (int8x16_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 32);
return __ret;
}
#else
-__ai int8x16_t vdupq_n_s8(int8_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vbslq_s8(uint8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
int8x16_t __ret;
- __ret = (int8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 32);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vdupq_n_f32(float32_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vbslq_f32(uint32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
float32x4_t __ret;
- __ret = (float32x4_t) {__p0, __p0, __p0, __p0};
+ __ret = (float32x4_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
return __ret;
}
#else
-__ai float32x4_t vdupq_n_f32(float32_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vbslq_f32(uint32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
float32x4_t __ret;
- __ret = (float32x4_t) {__p0, __p0, __p0, __p0};
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ float32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupq_n_f16(__p0) __extension__ ({ \
- float16x8_t __ret; \
- float16_t __s0 = __p0; \
- __ret = (float16x8_t) {__s0, __s0, __s0, __s0, __s0, __s0, __s0, __s0}; \
- __ret; \
-})
-#else
-#define vdupq_n_f16(__p0) __extension__ ({ \
- float16x8_t __ret; \
- float16_t __s0 = __p0; \
- __ret = (float16x8_t) {__s0, __s0, __s0, __s0, __s0, __s0, __s0, __s0}; \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vdupq_n_s32(int32_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vbslq_s32(uint32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
int32x4_t __ret;
- __ret = (int32x4_t) {__p0, __p0, __p0, __p0};
+ __ret = (int32x4_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
return __ret;
}
#else
-__ai int32x4_t vdupq_n_s32(int32_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vbslq_s32(uint32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
int32x4_t __ret;
- __ret = (int32x4_t) {__p0, __p0, __p0, __p0};
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vdupq_n_s64(int64_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vbslq_s64(uint64x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
int64x2_t __ret;
- __ret = (int64x2_t) {__p0, __p0};
+ __ret = (int64x2_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 35);
return __ret;
}
#else
-__ai int64x2_t vdupq_n_s64(int64_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vbslq_s64(uint64x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
int64x2_t __ret;
- __ret = (int64x2_t) {__p0, __p0};
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ int64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 35);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vdupq_n_s16(int16_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vbslq_s16(uint16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
int16x8_t __ret;
- __ret = (int16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = (int16x8_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
return __ret;
}
#else
-__ai int16x8_t vdupq_n_s16(int16_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vbslq_s16(uint16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
int16x8_t __ret;
- __ret = (int16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 33);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vdup_n_u8(uint8_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vbsl_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint8x8_t __ret;
- __ret = (uint8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = (uint8x8_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 16);
return __ret;
}
#else
-__ai uint8x8_t vdup_n_u8(uint8_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vbsl_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint8x8_t __ret;
- __ret = (uint8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 16);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vdup_n_u32(uint32_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vbsl_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
uint32x2_t __ret;
- __ret = (uint32x2_t) {__p0, __p0};
+ __ret = (uint32x2_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 18);
return __ret;
}
#else
-__ai uint32x2_t vdup_n_u32(uint32_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vbsl_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
uint32x2_t __ret;
- __ret = (uint32x2_t) {__p0, __p0};
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ uint32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 18);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vdup_n_u64(uint64_t __p0) {
+__ai __attribute__((target("neon"))) uint64x1_t vbsl_u64(uint64x1_t __p0, uint64x1_t __p1, uint64x1_t __p2) {
uint64x1_t __ret;
- __ret = (uint64x1_t) {__p0};
+ __ret = (uint64x1_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 19);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vdup_n_u16(uint16_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vbsl_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
uint16x4_t __ret;
- __ret = (uint16x4_t) {__p0, __p0, __p0, __p0};
+ __ret = (uint16x4_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 17);
return __ret;
}
#else
-__ai uint16x4_t vdup_n_u16(uint16_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vbsl_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
uint16x4_t __ret;
- __ret = (uint16x4_t) {__p0, __p0, __p0, __p0};
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ uint16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vdup_n_s8(int8_t __p0) {
+__ai __attribute__((target("neon"))) int8x8_t vbsl_s8(uint8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
int8x8_t __ret;
- __ret = (int8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = (int8x8_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 0);
return __ret;
}
#else
-__ai int8x8_t vdup_n_s8(int8_t __p0) {
+__ai __attribute__((target("neon"))) int8x8_t vbsl_s8(uint8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
int8x8_t __ret;
- __ret = (int8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 0);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vdup_n_f32(float32_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vbsl_f32(uint32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
float32x2_t __ret;
- __ret = (float32x2_t) {__p0, __p0};
+ __ret = (float32x2_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
return __ret;
}
#else
-__ai float32x2_t vdup_n_f32(float32_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vbsl_f32(uint32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
float32x2_t __ret;
- __ret = (float32x2_t) {__p0, __p0};
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ float32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdup_n_f16(__p0) __extension__ ({ \
- float16x4_t __ret; \
- float16_t __s0 = __p0; \
- __ret = (float16x4_t) {__s0, __s0, __s0, __s0}; \
- __ret; \
-})
-#else
-#define vdup_n_f16(__p0) __extension__ ({ \
- float16x4_t __ret; \
- float16_t __s0 = __p0; \
- __ret = (float16x4_t) {__s0, __s0, __s0, __s0}; \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vdup_n_s32(int32_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vbsl_s32(uint32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int32x2_t __ret;
- __ret = (int32x2_t) {__p0, __p0};
+ __ret = (int32x2_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
return __ret;
}
#else
-__ai int32x2_t vdup_n_s32(int32_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vbsl_s32(uint32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int32x2_t __ret;
- __ret = (int32x2_t) {__p0, __p0};
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ int32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 2);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai int64x1_t vdup_n_s64(int64_t __p0) {
+__ai __attribute__((target("neon"))) int64x1_t vbsl_s64(uint64x1_t __p0, int64x1_t __p1, int64x1_t __p2) {
int64x1_t __ret;
- __ret = (int64x1_t) {__p0};
+ __ret = (int64x1_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 3);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vdup_n_s16(int16_t __p0) {
+__ai __attribute__((target("neon"))) int16x4_t vbsl_s16(uint16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
int16x4_t __ret;
- __ret = (int16x4_t) {__p0, __p0, __p0, __p0};
+ __ret = (int16x4_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 1);
return __ret;
}
#else
-__ai int16x4_t vdup_n_s16(int16_t __p0) {
+__ai __attribute__((target("neon"))) int16x4_t vbsl_s16(uint16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
int16x4_t __ret;
- __ret = (int16x4_t) {__p0, __p0, __p0, __p0};
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ int16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t veorq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = __p0 ^ __p1;
+__ai __attribute__((target("neon"))) float16x8_t vbslq_f16(uint16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
return __ret;
}
#else
-__ai uint8x16_t veorq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 ^ __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float16x8_t vbslq_f16(uint16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t veorq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = __p0 ^ __p1;
+__ai __attribute__((target("neon"))) float16x4_t vbsl_f16(uint16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
return __ret;
}
#else
-__ai uint32x4_t veorq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 ^ __rev1;
+__ai __attribute__((target("neon"))) float16x4_t vbsl_f16(uint16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 8);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t veorq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- __ret = __p0 ^ __p1;
+__ai __attribute__((target("neon"))) uint32x4_t vcageq_f32(float32x4_t __p0, float32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vcageq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
return __ret;
}
#else
-__ai uint64x2_t veorq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 ^ __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint32x4_t vcageq_f32(float32x4_t __p0, float32x4_t __p1) {
+ uint32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vcageq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t veorq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = __p0 ^ __p1;
+__ai __attribute__((target("neon"))) uint32x2_t vcage_f32(float32x2_t __p0, float32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vcage_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
return __ret;
}
#else
-__ai uint16x8_t veorq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 ^ __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x2_t vcage_f32(float32x2_t __p0, float32x2_t __p1) {
+ uint32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vcage_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t veorq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = __p0 ^ __p1;
+__ai __attribute__((target("neon"))) uint32x4_t vcagtq_f32(float32x4_t __p0, float32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vcagtq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
return __ret;
}
#else
-__ai int8x16_t veorq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 ^ __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x4_t vcagtq_f32(float32x4_t __p0, float32x4_t __p1) {
+ uint32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vcagtq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t veorq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = __p0 ^ __p1;
+__ai __attribute__((target("neon"))) uint32x2_t vcagt_f32(float32x2_t __p0, float32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vcagt_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
return __ret;
}
#else
-__ai int32x4_t veorq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 ^ __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x2_t vcagt_f32(float32x2_t __p0, float32x2_t __p1) {
+ uint32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vcagt_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t veorq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- __ret = __p0 ^ __p1;
+__ai __attribute__((target("neon"))) uint32x4_t vcaleq_f32(float32x4_t __p0, float32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vcaleq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
return __ret;
}
#else
-__ai int64x2_t veorq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 ^ __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint32x4_t vcaleq_f32(float32x4_t __p0, float32x4_t __p1) {
+ uint32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vcaleq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t veorq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = __p0 ^ __p1;
+__ai __attribute__((target("neon"))) uint32x2_t vcale_f32(float32x2_t __p0, float32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vcale_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
return __ret;
}
#else
-__ai int16x8_t veorq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
+__ai __attribute__((target("neon"))) uint32x2_t vcale_f32(float32x2_t __p0, float32x2_t __p1) {
+ uint32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vcale_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcaltq_f32(float32x4_t __p0, float32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vcaltq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcaltq_f32(float32x4_t __p0, float32x4_t __p1) {
+ uint32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vcaltq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcalt_f32(float32x2_t __p0, float32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vcalt_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcalt_f32(float32x2_t __p0, float32x2_t __p1) {
+ uint32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vcalt_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vceq_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0 == __p1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vceq_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ uint8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t)(__rev0 == __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vceqq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0 == __p1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vceqq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ uint8x16_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t)(__rev0 == __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vceqq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0 == __p1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vceqq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t)(__rev0 == __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vceqq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0 == __p1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vceqq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t)(__rev0 == __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vceqq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0 == __p1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vceqq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t)(__rev0 == __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vceqq_s8(int8x16_t __p0, int8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0 == __p1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vceqq_s8(int8x16_t __p0, int8x16_t __p1) {
+ uint8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t)(__rev0 == __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vceqq_f32(float32x4_t __p0, float32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0 == __p1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vceqq_f32(float32x4_t __p0, float32x4_t __p1) {
+ uint32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t)(__rev0 == __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vceqq_s32(int32x4_t __p0, int32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0 == __p1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vceqq_s32(int32x4_t __p0, int32x4_t __p1) {
+ uint32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t)(__rev0 == __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vceqq_s16(int16x8_t __p0, int16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0 == __p1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vceqq_s16(int16x8_t __p0, int16x8_t __p1) {
+ uint16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 ^ __rev1;
+ __ret = (uint16x8_t)(__rev0 == __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t veor_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vceq_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint8x8_t __ret;
- __ret = __p0 ^ __p1;
+ __ret = (uint8x8_t)(__p0 == __p1);
return __ret;
}
#else
-__ai uint8x8_t veor_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vceq_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint8x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 ^ __rev1;
+ __ret = (uint8x8_t)(__rev0 == __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t veor_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vceq_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint32x2_t __ret;
- __ret = __p0 ^ __p1;
+ __ret = (uint32x2_t)(__p0 == __p1);
return __ret;
}
#else
-__ai uint32x2_t veor_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vceq_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 ^ __rev1;
+ __ret = (uint32x2_t)(__rev0 == __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t veor_u64(uint64x1_t __p0, uint64x1_t __p1) {
- uint64x1_t __ret;
- __ret = __p0 ^ __p1;
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t veor_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vceq_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint16x4_t __ret;
- __ret = __p0 ^ __p1;
+ __ret = (uint16x4_t)(__p0 == __p1);
return __ret;
}
#else
-__ai uint16x4_t veor_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vceq_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 ^ __rev1;
+ __ret = (uint16x4_t)(__rev0 == __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t veor_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = __p0 ^ __p1;
+__ai __attribute__((target("neon"))) uint8x8_t vceq_s8(int8x8_t __p0, int8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0 == __p1);
return __ret;
}
#else
-__ai int8x8_t veor_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
+__ai __attribute__((target("neon"))) uint8x8_t vceq_s8(int8x8_t __p0, int8x8_t __p1) {
+ uint8x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 ^ __rev1;
+ __ret = (uint8x8_t)(__rev0 == __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t veor_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = __p0 ^ __p1;
+__ai __attribute__((target("neon"))) uint32x2_t vceq_f32(float32x2_t __p0, float32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0 == __p1);
return __ret;
}
#else
-__ai int32x2_t veor_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 ^ __rev1;
+__ai __attribute__((target("neon"))) uint32x2_t vceq_f32(float32x2_t __p0, float32x2_t __p1) {
+ uint32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t)(__rev0 == __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai int64x1_t veor_s64(int64x1_t __p0, int64x1_t __p1) {
- int64x1_t __ret;
- __ret = __p0 ^ __p1;
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vceq_s32(int32x2_t __p0, int32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0 == __p1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vceq_s32(int32x2_t __p0, int32x2_t __p1) {
+ uint32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t)(__rev0 == __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
+#endif
+
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t veor_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = __p0 ^ __p1;
+__ai __attribute__((target("neon"))) uint16x4_t vceq_s16(int16x4_t __p0, int16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0 == __p1);
return __ret;
}
#else
-__ai int16x4_t veor_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
+__ai __attribute__((target("neon"))) uint16x4_t vceq_s16(int16x4_t __p0, int16x4_t __p1) {
+ uint16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 ^ __rev1;
+ __ret = (uint16x4_t)(__rev0 == __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vext_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8_t __ret; \
- poly8x8_t __s0 = __p0; \
- poly8x8_t __s1 = __p1; \
- __ret = (poly8x8_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 4); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vcgeq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0 >= __p1);
+ return __ret;
+}
#else
-#define vext_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8_t __ret; \
- poly8x8_t __s0 = __p0; \
- poly8x8_t __s1 = __p1; \
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly8x8_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 4); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vcgeq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vext_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4_t __ret; \
- poly16x4_t __s0 = __p0; \
- poly16x4_t __s1 = __p1; \
- __ret = (poly16x4_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 5); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcgeq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0 >= __p1);
+ return __ret;
+}
#else
-#define vext_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4_t __ret; \
- poly16x4_t __s0 = __p0; \
- poly16x4_t __s1 = __p1; \
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (poly16x4_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 5); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcgeq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vextq_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16_t __ret; \
- poly8x16_t __s0 = __p0; \
- poly8x16_t __s1 = __p1; \
- __ret = (poly8x16_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 36); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vcgeq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0 >= __p1);
+ return __ret;
+}
#else
-#define vextq_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16_t __ret; \
- poly8x16_t __s0 = __p0; \
- poly8x16_t __s1 = __p1; \
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly8x16_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 36); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vcgeq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vextq_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8_t __ret; \
- poly16x8_t __s0 = __p0; \
- poly16x8_t __s1 = __p1; \
- __ret = (poly16x8_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 37); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vcgeq_s8(int8x16_t __p0, int8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0 >= __p1);
+ return __ret;
+}
#else
-#define vextq_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8_t __ret; \
- poly16x8_t __s0 = __p0; \
- poly16x8_t __s1 = __p1; \
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly16x8_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 37); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vcgeq_s8(int8x16_t __p0, int8x16_t __p1) {
+ uint8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vextq_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16_t __ret; \
- uint8x16_t __s0 = __p0; \
- uint8x16_t __s1 = __p1; \
- __ret = (uint8x16_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 48); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcgeq_f32(float32x4_t __p0, float32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0 >= __p1);
+ return __ret;
+}
#else
-#define vextq_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16_t __ret; \
- uint8x16_t __s0 = __p0; \
- uint8x16_t __s1 = __p1; \
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x16_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 48); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcgeq_f32(float32x4_t __p0, float32x4_t __p1) {
+ uint32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vextq_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- uint32x4_t __s1 = __p1; \
- __ret = (uint32x4_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 50); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcgeq_s32(int32x4_t __p0, int32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0 >= __p1);
+ return __ret;
+}
#else
-#define vextq_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- uint32x4_t __s1 = __p1; \
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (uint32x4_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 50); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcgeq_s32(int32x4_t __p0, int32x4_t __p1) {
+ uint32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vextq_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- uint64x2_t __s1 = __p1; \
- __ret = (uint64x2_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 51); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vcgeq_s16(int16x8_t __p0, int16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0 >= __p1);
+ return __ret;
+}
#else
-#define vextq_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- uint64x2_t __s1 = __p1; \
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (uint64x2_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 51); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vcgeq_s16(int16x8_t __p0, int16x8_t __p1) {
+ uint16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vextq_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- uint16x8_t __s1 = __p1; \
- __ret = (uint16x8_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 49); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vcge_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0 >= __p1);
+ return __ret;
+}
#else
-#define vextq_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- uint16x8_t __s1 = __p1; \
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint16x8_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 49); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vcge_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vextq_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16_t __ret; \
- int8x16_t __s0 = __p0; \
- int8x16_t __s1 = __p1; \
- __ret = (int8x16_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 32); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcge_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0 >= __p1);
+ return __ret;
+}
#else
-#define vextq_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16_t __ret; \
- int8x16_t __s0 = __p0; \
- int8x16_t __s1 = __p1; \
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x16_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 32); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcge_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vextq_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x4_t __ret; \
- float32x4_t __s0 = __p0; \
- float32x4_t __s1 = __p1; \
- __ret = (float32x4_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 41); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vcge_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0 >= __p1);
+ return __ret;
+}
#else
-#define vextq_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x4_t __ret; \
- float32x4_t __s0 = __p0; \
- float32x4_t __s1 = __p1; \
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (float32x4_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 41); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vcge_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vextq_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __s1 = __p1; \
- __ret = (int32x4_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vcge_s8(int8x8_t __p0, int8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0 >= __p1);
+ return __ret;
+}
#else
-#define vextq_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __s1 = __p1; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vcge_s8(int8x8_t __p0, int8x8_t __p1) {
+ uint8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vextq_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2_t __ret; \
- int64x2_t __s0 = __p0; \
- int64x2_t __s1 = __p1; \
- __ret = (int64x2_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 35); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcge_f32(float32x2_t __p0, float32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0 >= __p1);
+ return __ret;
+}
#else
-#define vextq_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2_t __ret; \
- int64x2_t __s0 = __p0; \
- int64x2_t __s1 = __p1; \
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (int64x2_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 35); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcge_f32(float32x2_t __p0, float32x2_t __p1) {
+ uint32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vextq_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __s1 = __p1; \
- __ret = (int16x8_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcge_s32(int32x2_t __p0, int32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0 >= __p1);
+ return __ret;
+}
#else
-#define vextq_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __s1 = __p1; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcge_s32(int32x2_t __p0, int32x2_t __p1) {
+ uint32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vext_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8_t __ret; \
- uint8x8_t __s0 = __p0; \
- uint8x8_t __s1 = __p1; \
- __ret = (uint8x8_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 16); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vcge_s16(int16x4_t __p0, int16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0 >= __p1);
+ return __ret;
+}
#else
-#define vext_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8_t __ret; \
- uint8x8_t __s0 = __p0; \
- uint8x8_t __s1 = __p1; \
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 16); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vcge_s16(int16x4_t __p0, int16x4_t __p1) {
+ uint16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vext_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2_t __ret; \
- uint32x2_t __s0 = __p0; \
- uint32x2_t __s1 = __p1; \
- __ret = (uint32x2_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 18); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vcgtq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0 > __p1);
+ return __ret;
+}
#else
-#define vext_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2_t __ret; \
- uint32x2_t __s0 = __p0; \
- uint32x2_t __s1 = __p1; \
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 18); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vcgtq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t)(__rev0 > __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vext_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x1_t __ret; \
- uint64x1_t __s0 = __p0; \
- uint64x1_t __s1 = __p1; \
- __ret = (uint64x1_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 19); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vext_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4_t __ret; \
- uint16x4_t __s0 = __p0; \
- uint16x4_t __s1 = __p1; \
- __ret = (uint16x4_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 17); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcgtq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0 > __p1);
+ return __ret;
+}
#else
-#define vext_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4_t __ret; \
- uint16x4_t __s0 = __p0; \
- uint16x4_t __s1 = __p1; \
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 17); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcgtq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t)(__rev0 > __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vext_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8_t __ret; \
- int8x8_t __s0 = __p0; \
- int8x8_t __s1 = __p1; \
- __ret = (int8x8_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vcgtq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0 > __p1);
+ return __ret;
+}
#else
-#define vext_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8_t __ret; \
- int8x8_t __s0 = __p0; \
- int8x8_t __s1 = __p1; \
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x8_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 0); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vcgtq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t)(__rev0 > __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vext_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x2_t __ret; \
- float32x2_t __s0 = __p0; \
- float32x2_t __s1 = __p1; \
- __ret = (float32x2_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 9); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vcgtq_s8(int8x16_t __p0, int8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0 > __p1);
+ return __ret;
+}
#else
-#define vext_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x2_t __ret; \
- float32x2_t __s0 = __p0; \
- float32x2_t __s1 = __p1; \
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (float32x2_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 9); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vcgtq_s8(int8x16_t __p0, int8x16_t __p1) {
+ uint8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t)(__rev0 > __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vext_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __s1 = __p1; \
- __ret = (int32x2_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcgtq_f32(float32x4_t __p0, float32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0 > __p1);
+ return __ret;
+}
#else
-#define vext_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __s1 = __p1; \
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcgtq_f32(float32x4_t __p0, float32x4_t __p1) {
+ uint32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t)(__rev0 > __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vext_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x1_t __ret; \
- int64x1_t __s0 = __p0; \
- int64x1_t __s1 = __p1; \
- __ret = (int64x1_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 3); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vext_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __s1 = __p1; \
- __ret = (int16x4_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcgtq_s32(int32x4_t __p0, int32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0 > __p1);
+ return __ret;
+}
#else
-#define vext_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __s1 = __p1; \
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcgtq_s32(int32x4_t __p0, int32x4_t __p1) {
+ uint32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t)(__rev0 > __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vget_high_p8(poly8x16_t __p0) {
- poly8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 8, 9, 10, 11, 12, 13, 14, 15);
+__ai __attribute__((target("neon"))) uint16x8_t vcgtq_s16(int16x8_t __p0, int16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0 > __p1);
return __ret;
}
#else
-__ai poly8x8_t vget_high_p8(poly8x16_t __p0) {
- poly8x8_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 8, 9, 10, 11, 12, 13, 14, 15);
+__ai __attribute__((target("neon"))) uint16x8_t vcgtq_s16(int16x8_t __p0, int16x8_t __p1) {
+ uint16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t)(__rev0 > __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly8x8_t __noswap_vget_high_p8(poly8x16_t __p0) {
- poly8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 8, 9, 10, 11, 12, 13, 14, 15);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vcgt_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0 > __p1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vcgt_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t)(__rev0 > __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x4_t vget_high_p16(poly16x8_t __p0) {
- poly16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) uint32x2_t vcgt_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0 > __p1);
return __ret;
}
#else
-__ai poly16x4_t vget_high_p16(poly16x8_t __p0) {
- poly16x4_t __ret;
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 4, 5, 6, 7);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x2_t vcgt_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t)(__rev0 > __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vget_high_u8(uint8x16_t __p0) {
- uint8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 8, 9, 10, 11, 12, 13, 14, 15);
+__ai __attribute__((target("neon"))) uint16x4_t vcgt_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0 > __p1);
return __ret;
}
#else
-__ai uint8x8_t vget_high_u8(uint8x16_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vcgt_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t)(__rev0 > __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vcgt_s8(int8x8_t __p0, int8x8_t __p1) {
uint8x8_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 8, 9, 10, 11, 12, 13, 14, 15);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t)(__p0 > __p1);
return __ret;
}
-__ai uint8x8_t __noswap_vget_high_u8(uint8x16_t __p0) {
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vcgt_s8(int8x8_t __p0, int8x8_t __p1) {
uint8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 8, 9, 10, 11, 12, 13, 14, 15);
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t)(__rev0 > __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vget_high_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vcgt_f32(float32x2_t __p0, float32x2_t __p1) {
uint32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 2, 3);
+ __ret = (uint32x2_t)(__p0 > __p1);
return __ret;
}
#else
-__ai uint32x2_t vget_high_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vcgt_f32(float32x2_t __p0, float32x2_t __p1) {
uint32x2_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 2, 3);
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t)(__rev0 > __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai uint32x2_t __noswap_vget_high_u32(uint32x4_t __p0) {
- uint32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 2, 3);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x1_t vget_high_u64(uint64x2_t __p0) {
- uint64x1_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1);
+__ai __attribute__((target("neon"))) uint32x2_t vcgt_s32(int32x2_t __p0, int32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0 > __p1);
return __ret;
}
#else
-__ai uint64x1_t vget_high_u64(uint64x2_t __p0) {
- uint64x1_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1);
+__ai __attribute__((target("neon"))) uint32x2_t vcgt_s32(int32x2_t __p0, int32x2_t __p1) {
+ uint32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t)(__rev0 > __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vget_high_u16(uint16x8_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vcgt_s16(int16x4_t __p0, int16x4_t __p1) {
uint16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+ __ret = (uint16x4_t)(__p0 > __p1);
return __ret;
}
#else
-__ai uint16x4_t vget_high_u16(uint16x8_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vcgt_s16(int16x4_t __p0, int16x4_t __p1) {
uint16x4_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 4, 5, 6, 7);
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t)(__rev0 > __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai uint16x4_t __noswap_vget_high_u16(uint16x8_t __p0) {
- uint16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vget_high_s8(int8x16_t __p0) {
- int8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 8, 9, 10, 11, 12, 13, 14, 15);
+__ai __attribute__((target("neon"))) uint8x16_t vcleq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0 <= __p1);
return __ret;
}
#else
-__ai int8x8_t vget_high_s8(int8x16_t __p0) {
- int8x8_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 8, 9, 10, 11, 12, 13, 14, 15);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vcleq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t)(__rev0 <= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai int8x8_t __noswap_vget_high_s8(int8x16_t __p0) {
- int8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 8, 9, 10, 11, 12, 13, 14, 15);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcleq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0 <= __p1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcleq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t)(__rev0 <= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vget_high_f32(float32x4_t __p0) {
- float32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 2, 3);
+__ai __attribute__((target("neon"))) uint16x8_t vcleq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0 <= __p1);
return __ret;
}
#else
-__ai float32x2_t vget_high_f32(float32x4_t __p0) {
- float32x2_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 2, 3);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint16x8_t vcleq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t)(__rev0 <= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai float32x2_t __noswap_vget_high_f32(float32x4_t __p0) {
- float32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 2, 3);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vcleq_s8(int8x16_t __p0, int8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0 <= __p1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vcleq_s8(int8x16_t __p0, int8x16_t __p1) {
+ uint8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t)(__rev0 <= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float16x4_t vget_high_f16(float16x8_t __p0) {
- float16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) uint32x4_t vcleq_f32(float32x4_t __p0, float32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0 <= __p1);
return __ret;
}
#else
-__ai float16x4_t vget_high_f16(float16x8_t __p0) {
- float16x4_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) uint32x4_t vcleq_f32(float32x4_t __p0, float32x4_t __p1) {
+ uint32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t)(__rev0 <= __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai float16x4_t __noswap_vget_high_f16(float16x8_t __p0) {
- float16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vget_high_s32(int32x4_t __p0) {
- int32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 2, 3);
+__ai __attribute__((target("neon"))) uint32x4_t vcleq_s32(int32x4_t __p0, int32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0 <= __p1);
return __ret;
}
#else
-__ai int32x2_t vget_high_s32(int32x4_t __p0) {
- int32x2_t __ret;
+__ai __attribute__((target("neon"))) uint32x4_t vcleq_s32(int32x4_t __p0, int32x4_t __p1) {
+ uint32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 2, 3);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai int32x2_t __noswap_vget_high_s32(int32x4_t __p0) {
- int32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 2, 3);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t)(__rev0 <= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x1_t vget_high_s64(int64x2_t __p0) {
- int64x1_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1);
+__ai __attribute__((target("neon"))) uint16x8_t vcleq_s16(int16x8_t __p0, int16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0 <= __p1);
return __ret;
}
#else
-__ai int64x1_t vget_high_s64(int64x2_t __p0) {
- int64x1_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1);
+__ai __attribute__((target("neon"))) uint16x8_t vcleq_s16(int16x8_t __p0, int16x8_t __p1) {
+ uint16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t)(__rev0 <= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vget_high_s16(int16x8_t __p0) {
- int16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) uint8x8_t vcle_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0 <= __p1);
return __ret;
}
#else
-__ai int16x4_t vget_high_s16(int16x8_t __p0) {
- int16x4_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 4, 5, 6, 7);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai int16x4_t __noswap_vget_high_s16(int16x8_t __p0) {
- int16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) uint8x8_t vcle_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t)(__rev0 <= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vget_lane_p8(__p0, __p1) __extension__ ({ \
- poly8_t __ret; \
- poly8x8_t __s0 = __p0; \
- __ret = (poly8_t) __builtin_neon_vget_lane_i8((poly8x8_t)__s0, __p1); \
- __ret; \
-})
-#else
-#define vget_lane_p8(__p0, __p1) __extension__ ({ \
- poly8_t __ret; \
- poly8x8_t __s0 = __p0; \
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly8_t) __builtin_neon_vget_lane_i8((poly8x8_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vget_lane_p8(__p0, __p1) __extension__ ({ \
- poly8_t __ret; \
- poly8x8_t __s0 = __p0; \
- __ret = (poly8_t) __builtin_neon_vget_lane_i8((poly8x8_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcle_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0 <= __p1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcle_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t)(__rev0 <= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vget_lane_p16(__p0, __p1) __extension__ ({ \
- poly16_t __ret; \
- poly16x4_t __s0 = __p0; \
- __ret = (poly16_t) __builtin_neon_vget_lane_i16((poly16x4_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vcle_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0 <= __p1);
+ return __ret;
+}
#else
-#define vget_lane_p16(__p0, __p1) __extension__ ({ \
- poly16_t __ret; \
- poly16x4_t __s0 = __p0; \
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (poly16_t) __builtin_neon_vget_lane_i16((poly16x4_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vget_lane_p16(__p0, __p1) __extension__ ({ \
- poly16_t __ret; \
- poly16x4_t __s0 = __p0; \
- __ret = (poly16_t) __builtin_neon_vget_lane_i16((poly16x4_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vcle_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t)(__rev0 <= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vgetq_lane_p8(__p0, __p1) __extension__ ({ \
- poly8_t __ret; \
- poly8x16_t __s0 = __p0; \
- __ret = (poly8_t) __builtin_neon_vgetq_lane_i8((poly8x16_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vcle_s8(int8x8_t __p0, int8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0 <= __p1);
+ return __ret;
+}
#else
-#define vgetq_lane_p8(__p0, __p1) __extension__ ({ \
- poly8_t __ret; \
- poly8x16_t __s0 = __p0; \
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly8_t) __builtin_neon_vgetq_lane_i8((poly8x16_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vgetq_lane_p8(__p0, __p1) __extension__ ({ \
- poly8_t __ret; \
- poly8x16_t __s0 = __p0; \
- __ret = (poly8_t) __builtin_neon_vgetq_lane_i8((poly8x16_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vcle_s8(int8x8_t __p0, int8x8_t __p1) {
+ uint8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t)(__rev0 <= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vgetq_lane_p16(__p0, __p1) __extension__ ({ \
- poly16_t __ret; \
- poly16x8_t __s0 = __p0; \
- __ret = (poly16_t) __builtin_neon_vgetq_lane_i16((poly16x8_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcle_f32(float32x2_t __p0, float32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0 <= __p1);
+ return __ret;
+}
#else
-#define vgetq_lane_p16(__p0, __p1) __extension__ ({ \
- poly16_t __ret; \
- poly16x8_t __s0 = __p0; \
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly16_t) __builtin_neon_vgetq_lane_i16((poly16x8_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vgetq_lane_p16(__p0, __p1) __extension__ ({ \
- poly16_t __ret; \
- poly16x8_t __s0 = __p0; \
- __ret = (poly16_t) __builtin_neon_vgetq_lane_i16((poly16x8_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcle_f32(float32x2_t __p0, float32x2_t __p1) {
+ uint32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t)(__rev0 <= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vgetq_lane_u8(__p0, __p1) __extension__ ({ \
- uint8_t __ret; \
- uint8x16_t __s0 = __p0; \
- __ret = (uint8_t) __builtin_neon_vgetq_lane_i8((int8x16_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcle_s32(int32x2_t __p0, int32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0 <= __p1);
+ return __ret;
+}
#else
-#define vgetq_lane_u8(__p0, __p1) __extension__ ({ \
- uint8_t __ret; \
- uint8x16_t __s0 = __p0; \
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8_t) __builtin_neon_vgetq_lane_i8((int8x16_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vgetq_lane_u8(__p0, __p1) __extension__ ({ \
- uint8_t __ret; \
- uint8x16_t __s0 = __p0; \
- __ret = (uint8_t) __builtin_neon_vgetq_lane_i8((int8x16_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcle_s32(int32x2_t __p0, int32x2_t __p1) {
+ uint32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t)(__rev0 <= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vgetq_lane_u32(__p0, __p1) __extension__ ({ \
- uint32_t __ret; \
- uint32x4_t __s0 = __p0; \
- __ret = (uint32_t) __builtin_neon_vgetq_lane_i32((int32x4_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vcle_s16(int16x4_t __p0, int16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0 <= __p1);
+ return __ret;
+}
#else
-#define vgetq_lane_u32(__p0, __p1) __extension__ ({ \
- uint32_t __ret; \
- uint32x4_t __s0 = __p0; \
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint32_t) __builtin_neon_vgetq_lane_i32((int32x4_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vgetq_lane_u32(__p0, __p1) __extension__ ({ \
- uint32_t __ret; \
- uint32x4_t __s0 = __p0; \
- __ret = (uint32_t) __builtin_neon_vgetq_lane_i32((int32x4_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vcle_s16(int16x4_t __p0, int16x4_t __p1) {
+ uint16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t)(__rev0 <= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vgetq_lane_u64(__p0, __p1) __extension__ ({ \
- uint64_t __ret; \
- uint64x2_t __s0 = __p0; \
- __ret = (uint64_t) __builtin_neon_vgetq_lane_i64((int64x2_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vclsq_u8(uint8x16_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vclsq_v((int8x16_t)__p0, 32);
+ return __ret;
+}
#else
-#define vgetq_lane_u64(__p0, __p1) __extension__ ({ \
- uint64_t __ret; \
- uint64x2_t __s0 = __p0; \
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint64_t) __builtin_neon_vgetq_lane_i64((int64x2_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vgetq_lane_u64(__p0, __p1) __extension__ ({ \
- uint64_t __ret; \
- uint64x2_t __s0 = __p0; \
- __ret = (uint64_t) __builtin_neon_vgetq_lane_i64((int64x2_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vclsq_u8(uint8x16_t __p0) {
+ int8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vclsq_v((int8x16_t)__rev0, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vgetq_lane_u16(__p0, __p1) __extension__ ({ \
- uint16_t __ret; \
- uint16x8_t __s0 = __p0; \
- __ret = (uint16_t) __builtin_neon_vgetq_lane_i16((int16x8_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vclsq_u32(uint32x4_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vclsq_v((int8x16_t)__p0, 34);
+ return __ret;
+}
#else
-#define vgetq_lane_u16(__p0, __p1) __extension__ ({ \
- uint16_t __ret; \
- uint16x8_t __s0 = __p0; \
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint16_t) __builtin_neon_vgetq_lane_i16((int16x8_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vgetq_lane_u16(__p0, __p1) __extension__ ({ \
- uint16_t __ret; \
- uint16x8_t __s0 = __p0; \
- __ret = (uint16_t) __builtin_neon_vgetq_lane_i16((int16x8_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vclsq_u32(uint32x4_t __p0) {
+ int32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vclsq_v((int8x16_t)__rev0, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vgetq_lane_s8(__p0, __p1) __extension__ ({ \
- int8_t __ret; \
- int8x16_t __s0 = __p0; \
- __ret = (int8_t) __builtin_neon_vgetq_lane_i8((int8x16_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vclsq_u16(uint16x8_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vclsq_v((int8x16_t)__p0, 33);
+ return __ret;
+}
#else
-#define vgetq_lane_s8(__p0, __p1) __extension__ ({ \
- int8_t __ret; \
- int8x16_t __s0 = __p0; \
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8_t) __builtin_neon_vgetq_lane_i8((int8x16_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vgetq_lane_s8(__p0, __p1) __extension__ ({ \
- int8_t __ret; \
- int8x16_t __s0 = __p0; \
- __ret = (int8_t) __builtin_neon_vgetq_lane_i8((int8x16_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vclsq_u16(uint16x8_t __p0) {
+ int16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vclsq_v((int8x16_t)__rev0, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vgetq_lane_f32(__p0, __p1) __extension__ ({ \
- float32_t __ret; \
- float32x4_t __s0 = __p0; \
- __ret = (float32_t) __builtin_neon_vgetq_lane_f32((float32x4_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vclsq_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vclsq_v((int8x16_t)__p0, 32);
+ return __ret;
+}
#else
-#define vgetq_lane_f32(__p0, __p1) __extension__ ({ \
- float32_t __ret; \
- float32x4_t __s0 = __p0; \
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (float32_t) __builtin_neon_vgetq_lane_f32((float32x4_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vgetq_lane_f32(__p0, __p1) __extension__ ({ \
- float32_t __ret; \
- float32x4_t __s0 = __p0; \
- __ret = (float32_t) __builtin_neon_vgetq_lane_f32((float32x4_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vclsq_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vclsq_v((int8x16_t)__rev0, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vgetq_lane_s32(__p0, __p1) __extension__ ({ \
- int32_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (int32_t) __builtin_neon_vgetq_lane_i32((int32x4_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vclsq_s32(int32x4_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vclsq_v((int8x16_t)__p0, 34);
+ return __ret;
+}
#else
-#define vgetq_lane_s32(__p0, __p1) __extension__ ({ \
- int32_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int32_t) __builtin_neon_vgetq_lane_i32((int32x4_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vgetq_lane_s32(__p0, __p1) __extension__ ({ \
- int32_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (int32_t) __builtin_neon_vgetq_lane_i32((int32x4_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vclsq_s32(int32x4_t __p0) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vclsq_v((int8x16_t)__rev0, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vgetq_lane_s64(__p0, __p1) __extension__ ({ \
- int64_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (int64_t) __builtin_neon_vgetq_lane_i64((int64x2_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vclsq_s16(int16x8_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vclsq_v((int8x16_t)__p0, 33);
+ return __ret;
+}
#else
-#define vgetq_lane_s64(__p0, __p1) __extension__ ({ \
- int64_t __ret; \
- int64x2_t __s0 = __p0; \
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int64_t) __builtin_neon_vgetq_lane_i64((int64x2_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vgetq_lane_s64(__p0, __p1) __extension__ ({ \
- int64_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (int64_t) __builtin_neon_vgetq_lane_i64((int64x2_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vclsq_s16(int16x8_t __p0) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vclsq_v((int8x16_t)__rev0, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vgetq_lane_s16(__p0, __p1) __extension__ ({ \
- int16_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (int16_t) __builtin_neon_vgetq_lane_i16((int16x8_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vcls_u8(uint8x8_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vcls_v((int8x8_t)__p0, 0);
+ return __ret;
+}
#else
-#define vgetq_lane_s16(__p0, __p1) __extension__ ({ \
- int16_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16_t) __builtin_neon_vgetq_lane_i16((int16x8_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vgetq_lane_s16(__p0, __p1) __extension__ ({ \
- int16_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (int16_t) __builtin_neon_vgetq_lane_i16((int16x8_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vcls_u8(uint8x8_t __p0) {
+ int8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vcls_v((int8x8_t)__rev0, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vget_lane_u8(__p0, __p1) __extension__ ({ \
- uint8_t __ret; \
- uint8x8_t __s0 = __p0; \
- __ret = (uint8_t) __builtin_neon_vget_lane_i8((int8x8_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vcls_u32(uint32x2_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vcls_v((int8x8_t)__p0, 2);
+ return __ret;
+}
#else
-#define vget_lane_u8(__p0, __p1) __extension__ ({ \
- uint8_t __ret; \
- uint8x8_t __s0 = __p0; \
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8_t) __builtin_neon_vget_lane_i8((int8x8_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vget_lane_u8(__p0, __p1) __extension__ ({ \
- uint8_t __ret; \
- uint8x8_t __s0 = __p0; \
- __ret = (uint8_t) __builtin_neon_vget_lane_i8((int8x8_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vcls_u32(uint32x2_t __p0) {
+ int32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vcls_v((int8x8_t)__rev0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vget_lane_u32(__p0, __p1) __extension__ ({ \
- uint32_t __ret; \
- uint32x2_t __s0 = __p0; \
- __ret = (uint32_t) __builtin_neon_vget_lane_i32((int32x2_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vcls_u16(uint16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vcls_v((int8x8_t)__p0, 1);
+ return __ret;
+}
#else
-#define vget_lane_u32(__p0, __p1) __extension__ ({ \
- uint32_t __ret; \
- uint32x2_t __s0 = __p0; \
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint32_t) __builtin_neon_vget_lane_i32((int32x2_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vget_lane_u32(__p0, __p1) __extension__ ({ \
- uint32_t __ret; \
- uint32x2_t __s0 = __p0; \
- __ret = (uint32_t) __builtin_neon_vget_lane_i32((int32x2_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vcls_u16(uint16x4_t __p0) {
+ int16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vcls_v((int8x8_t)__rev0, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vget_lane_u64(__p0, __p1) __extension__ ({ \
- uint64_t __ret; \
- uint64x1_t __s0 = __p0; \
- __ret = (uint64_t) __builtin_neon_vget_lane_i64((int64x1_t)__s0, __p1); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vget_lane_u16(__p0, __p1) __extension__ ({ \
- uint16_t __ret; \
- uint16x4_t __s0 = __p0; \
- __ret = (uint16_t) __builtin_neon_vget_lane_i16((int16x4_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vcls_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vcls_v((int8x8_t)__p0, 0);
+ return __ret;
+}
#else
-#define vget_lane_u16(__p0, __p1) __extension__ ({ \
- uint16_t __ret; \
- uint16x4_t __s0 = __p0; \
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint16_t) __builtin_neon_vget_lane_i16((int16x4_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vget_lane_u16(__p0, __p1) __extension__ ({ \
- uint16_t __ret; \
- uint16x4_t __s0 = __p0; \
- __ret = (uint16_t) __builtin_neon_vget_lane_i16((int16x4_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vcls_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vcls_v((int8x8_t)__rev0, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vget_lane_s8(__p0, __p1) __extension__ ({ \
- int8_t __ret; \
- int8x8_t __s0 = __p0; \
- __ret = (int8_t) __builtin_neon_vget_lane_i8((int8x8_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vcls_s32(int32x2_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vcls_v((int8x8_t)__p0, 2);
+ return __ret;
+}
#else
-#define vget_lane_s8(__p0, __p1) __extension__ ({ \
- int8_t __ret; \
- int8x8_t __s0 = __p0; \
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8_t) __builtin_neon_vget_lane_i8((int8x8_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vget_lane_s8(__p0, __p1) __extension__ ({ \
- int8_t __ret; \
- int8x8_t __s0 = __p0; \
- __ret = (int8_t) __builtin_neon_vget_lane_i8((int8x8_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vcls_s32(int32x2_t __p0) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vcls_v((int8x8_t)__rev0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vget_lane_f32(__p0, __p1) __extension__ ({ \
- float32_t __ret; \
- float32x2_t __s0 = __p0; \
- __ret = (float32_t) __builtin_neon_vget_lane_f32((float32x2_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vcls_s16(int16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vcls_v((int8x8_t)__p0, 1);
+ return __ret;
+}
#else
-#define vget_lane_f32(__p0, __p1) __extension__ ({ \
- float32_t __ret; \
- float32x2_t __s0 = __p0; \
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (float32_t) __builtin_neon_vget_lane_f32((float32x2_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vget_lane_f32(__p0, __p1) __extension__ ({ \
- float32_t __ret; \
- float32x2_t __s0 = __p0; \
- __ret = (float32_t) __builtin_neon_vget_lane_f32((float32x2_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vcls_s16(int16x4_t __p0) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vcls_v((int8x8_t)__rev0, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vget_lane_s32(__p0, __p1) __extension__ ({ \
- int32_t __ret; \
- int32x2_t __s0 = __p0; \
- __ret = (int32_t) __builtin_neon_vget_lane_i32((int32x2_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vcltq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0 < __p1);
+ return __ret;
+}
#else
-#define vget_lane_s32(__p0, __p1) __extension__ ({ \
- int32_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int32_t) __builtin_neon_vget_lane_i32((int32x2_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vget_lane_s32(__p0, __p1) __extension__ ({ \
- int32_t __ret; \
- int32x2_t __s0 = __p0; \
- __ret = (int32_t) __builtin_neon_vget_lane_i32((int32x2_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vcltq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t)(__rev0 < __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vget_lane_s64(__p0, __p1) __extension__ ({ \
- int64_t __ret; \
- int64x1_t __s0 = __p0; \
- __ret = (int64_t) __builtin_neon_vget_lane_i64((int64x1_t)__s0, __p1); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vget_lane_s16(__p0, __p1) __extension__ ({ \
- int16_t __ret; \
- int16x4_t __s0 = __p0; \
- __ret = (int16_t) __builtin_neon_vget_lane_i16((int16x4_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcltq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0 < __p1);
+ return __ret;
+}
#else
-#define vget_lane_s16(__p0, __p1) __extension__ ({ \
- int16_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int16_t) __builtin_neon_vget_lane_i16((int16x4_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vget_lane_s16(__p0, __p1) __extension__ ({ \
- int16_t __ret; \
- int16x4_t __s0 = __p0; \
- __ret = (int16_t) __builtin_neon_vget_lane_i16((int16x4_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcltq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t)(__rev0 < __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vget_low_p8(poly8x16_t __p0) {
- poly8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) uint16x8_t vcltq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0 < __p1);
return __ret;
}
#else
-__ai poly8x8_t vget_low_p8(poly8x16_t __p0) {
- poly8x8_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) uint16x8_t vcltq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t)(__rev0 < __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x4_t vget_low_p16(poly16x8_t __p0) {
- poly16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3);
+__ai __attribute__((target("neon"))) uint8x16_t vcltq_s8(int8x16_t __p0, int8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0 < __p1);
return __ret;
}
#else
-__ai poly16x4_t vget_low_p16(poly16x8_t __p0) {
- poly16x4_t __ret;
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vcltq_s8(int8x16_t __p0, int8x16_t __p1) {
+ uint8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t)(__rev0 < __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vget_low_u8(uint8x16_t __p0) {
- uint8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) uint32x4_t vcltq_f32(float32x4_t __p0, float32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0 < __p1);
return __ret;
}
#else
-__ai uint8x8_t vget_low_u8(uint8x16_t __p0) {
- uint8x8_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3, 4, 5, 6, 7);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x4_t vcltq_f32(float32x4_t __p0, float32x4_t __p1) {
+ uint32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t)(__rev0 < __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vget_low_u32(uint32x4_t __p0) {
- uint32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 0, 1);
+__ai __attribute__((target("neon"))) uint32x4_t vcltq_s32(int32x4_t __p0, int32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0 < __p1);
return __ret;
}
#else
-__ai uint32x2_t vget_low_u32(uint32x4_t __p0) {
- uint32x2_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint32x4_t vcltq_s32(int32x4_t __p0, int32x4_t __p1) {
+ uint32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t)(__rev0 < __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x1_t vget_low_u64(uint64x2_t __p0) {
- uint64x1_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 0);
+__ai __attribute__((target("neon"))) uint16x8_t vcltq_s16(int16x8_t __p0, int16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0 < __p1);
return __ret;
}
#else
-__ai uint64x1_t vget_low_u64(uint64x2_t __p0) {
- uint64x1_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 0);
+__ai __attribute__((target("neon"))) uint16x8_t vcltq_s16(int16x8_t __p0, int16x8_t __p1) {
+ uint16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t)(__rev0 < __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vget_low_u16(uint16x8_t __p0) {
- uint16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3);
+__ai __attribute__((target("neon"))) uint8x8_t vclt_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0 < __p1);
return __ret;
}
#else
-__ai uint16x4_t vget_low_u16(uint16x8_t __p0) {
- uint16x4_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x8_t vclt_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t)(__rev0 < __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vget_low_s8(int8x16_t __p0) {
- int8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) uint32x2_t vclt_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0 < __p1);
return __ret;
}
#else
-__ai int8x8_t vget_low_s8(int8x16_t __p0) {
- int8x8_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3, 4, 5, 6, 7);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x2_t vclt_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t)(__rev0 < __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vget_low_f32(float32x4_t __p0) {
- float32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 0, 1);
+__ai __attribute__((target("neon"))) uint16x4_t vclt_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0 < __p1);
return __ret;
}
#else
-__ai float32x2_t vget_low_f32(float32x4_t __p0) {
- float32x2_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint16x4_t vclt_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t)(__rev0 < __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float16x4_t vget_low_f16(float16x8_t __p0) {
- float16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3);
+__ai __attribute__((target("neon"))) uint8x8_t vclt_s8(int8x8_t __p0, int8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0 < __p1);
return __ret;
}
#else
-__ai float16x4_t vget_low_f16(float16x8_t __p0) {
- float16x4_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x8_t vclt_s8(int8x8_t __p0, int8x8_t __p1) {
+ uint8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t)(__rev0 < __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vget_low_s32(int32x4_t __p0) {
- int32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 0, 1);
+__ai __attribute__((target("neon"))) uint32x2_t vclt_f32(float32x2_t __p0, float32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0 < __p1);
return __ret;
}
#else
-__ai int32x2_t vget_low_s32(int32x4_t __p0) {
- int32x2_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1);
+__ai __attribute__((target("neon"))) uint32x2_t vclt_f32(float32x2_t __p0, float32x2_t __p1) {
+ uint32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t)(__rev0 < __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x1_t vget_low_s64(int64x2_t __p0) {
- int64x1_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 0);
+__ai __attribute__((target("neon"))) uint32x2_t vclt_s32(int32x2_t __p0, int32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0 < __p1);
return __ret;
}
#else
-__ai int64x1_t vget_low_s64(int64x2_t __p0) {
- int64x1_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 0);
+__ai __attribute__((target("neon"))) uint32x2_t vclt_s32(int32x2_t __p0, int32x2_t __p1) {
+ uint32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t)(__rev0 < __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vget_low_s16(int16x8_t __p0) {
- int16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3);
+__ai __attribute__((target("neon"))) uint16x4_t vclt_s16(int16x4_t __p0, int16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0 < __p1);
return __ret;
}
#else
-__ai int16x4_t vget_low_s16(int16x8_t __p0) {
- int16x4_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3);
+__ai __attribute__((target("neon"))) uint16x4_t vclt_s16(int16x4_t __p0, int16x4_t __p1) {
+ uint16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t)(__rev0 < __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vhaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint8x16_t vclzq_u8(uint8x16_t __p0) {
uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ __ret = (uint8x16_t) __builtin_neon_vclzq_v((int8x16_t)__p0, 48);
return __ret;
}
#else
-__ai uint8x16_t vhaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint8x16_t vclzq_u8(uint8x16_t __p0) {
uint8x16_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = (uint8x16_t) __builtin_neon_vclzq_v((int8x16_t)__rev0, 48);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vhaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vclzq_u32(uint32x4_t __p0) {
uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+ __ret = (uint32x4_t) __builtin_neon_vclzq_v((int8x16_t)__p0, 50);
return __ret;
}
#else
-__ai uint32x4_t vhaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vclzq_u32(uint32x4_t __p0) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = (uint32x4_t) __builtin_neon_vclzq_v((int8x16_t)__rev0, 50);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vhaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vclzq_u16(uint16x8_t __p0) {
uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ __ret = (uint16x8_t) __builtin_neon_vclzq_v((int8x16_t)__p0, 49);
return __ret;
}
#else
-__ai uint16x8_t vhaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vclzq_u16(uint16x8_t __p0) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = (uint16x8_t) __builtin_neon_vclzq_v((int8x16_t)__rev0, 49);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vhaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) int8x16_t vclzq_s8(int8x16_t __p0) {
int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+ __ret = (int8x16_t) __builtin_neon_vclzq_v((int8x16_t)__p0, 32);
return __ret;
}
#else
-__ai int8x16_t vhaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) int8x16_t vclzq_s8(int8x16_t __p0) {
int8x16_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+ __ret = (int8x16_t) __builtin_neon_vclzq_v((int8x16_t)__rev0, 32);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vhaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vclzq_s32(int32x4_t __p0) {
int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+ __ret = (int32x4_t) __builtin_neon_vclzq_v((int8x16_t)__p0, 34);
return __ret;
}
#else
-__ai int32x4_t vhaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vclzq_s32(int32x4_t __p0) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+ __ret = (int32x4_t) __builtin_neon_vclzq_v((int8x16_t)__rev0, 34);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vhaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vclzq_s16(int16x8_t __p0) {
int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ __ret = (int16x8_t) __builtin_neon_vclzq_v((int8x16_t)__p0, 33);
return __ret;
}
#else
-__ai int16x8_t vhaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vclzq_s16(int16x8_t __p0) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = (int16x8_t) __builtin_neon_vclzq_v((int8x16_t)__rev0, 33);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vhadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vclz_u8(uint8x8_t __p0) {
uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ __ret = (uint8x8_t) __builtin_neon_vclz_v((int8x8_t)__p0, 16);
return __ret;
}
#else
-__ai uint8x8_t vhadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vclz_u8(uint8x8_t __p0) {
uint8x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = (uint8x8_t) __builtin_neon_vclz_v((int8x8_t)__rev0, 16);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vhadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vclz_u32(uint32x2_t __p0) {
uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ __ret = (uint32x2_t) __builtin_neon_vclz_v((int8x8_t)__p0, 18);
return __ret;
}
#else
-__ai uint32x2_t vhadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vclz_u32(uint32x2_t __p0) {
uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = (uint32x2_t) __builtin_neon_vclz_v((int8x8_t)__rev0, 18);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vhadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vclz_u16(uint16x4_t __p0) {
uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ __ret = (uint16x4_t) __builtin_neon_vclz_v((int8x8_t)__p0, 17);
return __ret;
}
#else
-__ai uint16x4_t vhadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vclz_u16(uint16x4_t __p0) {
uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = (uint16x4_t) __builtin_neon_vclz_v((int8x8_t)__rev0, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vhadd_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vclz_s8(int8x8_t __p0) {
int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+ __ret = (int8x8_t) __builtin_neon_vclz_v((int8x8_t)__p0, 0);
return __ret;
}
#else
-__ai int8x8_t vhadd_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vclz_s8(int8x8_t __p0) {
int8x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = (int8x8_t) __builtin_neon_vclz_v((int8x8_t)__rev0, 0);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vhadd_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vclz_s32(int32x2_t __p0) {
int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+ __ret = (int32x2_t) __builtin_neon_vclz_v((int8x8_t)__p0, 2);
return __ret;
}
#else
-__ai int32x2_t vhadd_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vclz_s32(int32x2_t __p0) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = (int32x2_t) __builtin_neon_vclz_v((int8x8_t)__rev0, 2);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vhadd_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vclz_s16(int16x4_t __p0) {
int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ __ret = (int16x4_t) __builtin_neon_vclz_v((int8x8_t)__p0, 1);
return __ret;
}
#else
-__ai int16x4_t vhadd_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vclz_s16(int16x4_t __p0) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = (int16x4_t) __builtin_neon_vclz_v((int8x8_t)__rev0, 1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vhsubq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) poly8x8_t vcnt_p8(poly8x8_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) __builtin_neon_vcnt_v((int8x8_t)__p0, 4);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vcnt_p8(poly8x8_t __p0) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vcnt_v((int8x8_t)__rev0, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vcntq_p8(poly8x16_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t) __builtin_neon_vcntq_v((int8x16_t)__p0, 36);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vcntq_p8(poly8x16_t __p0) {
+ poly8x16_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x16_t) __builtin_neon_vcntq_v((int8x16_t)__rev0, 36);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vcntq_u8(uint8x16_t __p0) {
uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vhsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ __ret = (uint8x16_t) __builtin_neon_vcntq_v((int8x16_t)__p0, 48);
return __ret;
}
#else
-__ai uint8x16_t vhsubq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint8x16_t vcntq_u8(uint8x16_t __p0) {
uint8x16_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vhsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = (uint8x16_t) __builtin_neon_vcntq_v((int8x16_t)__rev0, 48);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vhsubq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vhsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+__ai __attribute__((target("neon"))) int8x16_t vcntq_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vcntq_v((int8x16_t)__p0, 32);
return __ret;
}
#else
-__ai uint32x4_t vhsubq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vhsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int8x16_t vcntq_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vcntq_v((int8x16_t)__rev0, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vhsubq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vhsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+__ai __attribute__((target("neon"))) uint8x8_t vcnt_u8(uint8x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vcnt_v((int8x8_t)__p0, 16);
return __ret;
}
#else
-__ai uint16x8_t vhsubq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vhsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+__ai __attribute__((target("neon"))) uint8x8_t vcnt_u8(uint8x8_t __p0) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vcnt_v((int8x8_t)__rev0, 16);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vhsubq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vhsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+__ai __attribute__((target("neon"))) int8x8_t vcnt_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vcnt_v((int8x8_t)__p0, 0);
return __ret;
}
#else
-__ai int8x16_t vhsubq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vhsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int8x8_t vcnt_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vcnt_v((int8x8_t)__rev0, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vhsubq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vhsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+__ai __attribute__((target("neon"))) poly8x16_t vcombine_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
return __ret;
}
#else
-__ai int32x4_t vhsubq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vhsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly8x16_t vcombine_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly8x16_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vhsubq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vhsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+__ai __attribute__((target("neon"))) poly16x8_t vcombine_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ poly16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
return __ret;
}
#else
-__ai int16x8_t vhsubq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vhsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+__ai __attribute__((target("neon"))) poly16x8_t vcombine_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ poly16x8_t __ret;
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vhsub_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vhsub_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+__ai __attribute__((target("neon"))) uint8x16_t vcombine_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
return __ret;
}
#else
-__ai uint8x8_t vhsub_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
+__ai __attribute__((target("neon"))) uint8x16_t vcombine_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x16_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vhsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t __noswap_vcombine_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vhsub_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vhsub_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+__ai __attribute__((target("neon"))) uint32x4_t vcombine_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3);
return __ret;
}
#else
-__ai uint32x2_t vhsub_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
+__ai __attribute__((target("neon"))) uint32x4_t vcombine_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x4_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vhsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vcombine_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vhsub_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vhsub_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+__ai __attribute__((target("neon"))) uint64x2_t vcombine_u64(uint64x1_t __p0, uint64x1_t __p1) {
+ uint64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
return __ret;
}
#else
-__ai uint16x4_t vhsub_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vhsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint64x2_t vcombine_u64(uint64x1_t __p0, uint64x1_t __p1) {
+ uint64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vhsub_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vhsub_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+__ai __attribute__((target("neon"))) uint16x8_t vcombine_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
return __ret;
}
#else
-__ai int8x8_t vhsub_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vhsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+__ai __attribute__((target("neon"))) uint16x8_t vcombine_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x8_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) uint16x8_t __noswap_vcombine_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vhsub_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vhsub_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+__ai __attribute__((target("neon"))) int8x16_t vcombine_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
return __ret;
}
#else
-__ai int32x2_t vhsub_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vhsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int8x16_t vcombine_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x16_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t __noswap_vcombine_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vhsub_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+__ai __attribute__((target("neon"))) float32x4_t vcombine_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3);
return __ret;
}
#else
-__ai int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vhsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+__ai __attribute__((target("neon"))) float32x4_t vcombine_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x4_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) float32x4_t __noswap_vcombine_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_p8(__p0) __extension__ ({ \
- poly8x8_t __ret; \
- __ret = (poly8x8_t) __builtin_neon_vld1_v(__p0, 4); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float16x8_t vcombine_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+ return __ret;
+}
#else
-#define vld1_p8(__p0) __extension__ ({ \
- poly8x8_t __ret; \
- __ret = (poly8x8_t) __builtin_neon_vld1_v(__p0, 4); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float16x8_t vcombine_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x8_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t __noswap_vcombine_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_p16(__p0) __extension__ ({ \
- poly16x4_t __ret; \
- __ret = (poly16x4_t) __builtin_neon_vld1_v(__p0, 5); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vcombine_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3);
+ return __ret;
+}
#else
-#define vld1_p16(__p0) __extension__ ({ \
- poly16x4_t __ret; \
- __ret = (poly16x4_t) __builtin_neon_vld1_v(__p0, 5); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vcombine_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x4_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vcombine_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_p8(__p0) __extension__ ({ \
- poly8x16_t __ret; \
- __ret = (poly8x16_t) __builtin_neon_vld1q_v(__p0, 36); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vcombine_s64(int64x1_t __p0, int64x1_t __p1) {
+ int64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+ return __ret;
+}
#else
-#define vld1q_p8(__p0) __extension__ ({ \
- poly8x16_t __ret; \
- __ret = (poly8x16_t) __builtin_neon_vld1q_v(__p0, 36); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vcombine_s64(int64x1_t __p0, int64x1_t __p1) {
+ int64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_p16(__p0) __extension__ ({ \
- poly16x8_t __ret; \
- __ret = (poly16x8_t) __builtin_neon_vld1q_v(__p0, 37); \
+__ai __attribute__((target("neon"))) int16x8_t vcombine_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vcombine_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x8_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vcombine_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+ return __ret;
+}
+#endif
+
+#define vcreate_p8(__p0) __extension__ ({ \
+ poly8x8_t __ret; \
+ uint64_t __promote = __p0; \
+ __ret = (poly8x8_t)(__promote); \
__ret; \
})
-#else
-#define vld1q_p16(__p0) __extension__ ({ \
- poly16x8_t __ret; \
- __ret = (poly16x8_t) __builtin_neon_vld1q_v(__p0, 37); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vcreate_p16(__p0) __extension__ ({ \
+ poly16x4_t __ret; \
+ uint64_t __promote = __p0; \
+ __ret = (poly16x4_t)(__promote); \
__ret; \
})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vld1q_u8(__p0) __extension__ ({ \
- uint8x16_t __ret; \
- __ret = (uint8x16_t) __builtin_neon_vld1q_v(__p0, 48); \
+#define vcreate_u8(__p0) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint64_t __promote = __p0; \
+ __ret = (uint8x8_t)(__promote); \
__ret; \
})
-#else
-#define vld1q_u8(__p0) __extension__ ({ \
- uint8x16_t __ret; \
- __ret = (uint8x16_t) __builtin_neon_vld1q_v(__p0, 48); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vcreate_u32(__p0) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint64_t __promote = __p0; \
+ __ret = (uint32x2_t)(__promote); \
__ret; \
})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vld1q_u32(__p0) __extension__ ({ \
- uint32x4_t __ret; \
- __ret = (uint32x4_t) __builtin_neon_vld1q_v(__p0, 50); \
+#define vcreate_u64(__p0) __extension__ ({ \
+ uint64x1_t __ret; \
+ uint64_t __promote = __p0; \
+ __ret = (uint64x1_t)(__promote); \
__ret; \
})
-#else
-#define vld1q_u32(__p0) __extension__ ({ \
- uint32x4_t __ret; \
- __ret = (uint32x4_t) __builtin_neon_vld1q_v(__p0, 50); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+#define vcreate_u16(__p0) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint64_t __promote = __p0; \
+ __ret = (uint16x4_t)(__promote); \
__ret; \
})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vld1q_u64(__p0) __extension__ ({ \
- uint64x2_t __ret; \
- __ret = (uint64x2_t) __builtin_neon_vld1q_v(__p0, 51); \
+#define vcreate_s8(__p0) __extension__ ({ \
+ int8x8_t __ret; \
+ uint64_t __promote = __p0; \
+ __ret = (int8x8_t)(__promote); \
__ret; \
})
-#else
-#define vld1q_u64(__p0) __extension__ ({ \
- uint64x2_t __ret; \
- __ret = (uint64x2_t) __builtin_neon_vld1q_v(__p0, 51); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+#define vcreate_f32(__p0) __extension__ ({ \
+ float32x2_t __ret; \
+ uint64_t __promote = __p0; \
+ __ret = (float32x2_t)(__promote); \
__ret; \
})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vld1q_u16(__p0) __extension__ ({ \
- uint16x8_t __ret; \
- __ret = (uint16x8_t) __builtin_neon_vld1q_v(__p0, 49); \
+#define vcreate_f16(__p0) __extension__ ({ \
+ float16x4_t __ret; \
+ uint64_t __promote = __p0; \
+ __ret = (float16x4_t)(__promote); \
__ret; \
})
-#else
-#define vld1q_u16(__p0) __extension__ ({ \
- uint16x8_t __ret; \
- __ret = (uint16x8_t) __builtin_neon_vld1q_v(__p0, 49); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vcreate_s32(__p0) __extension__ ({ \
+ int32x2_t __ret; \
+ uint64_t __promote = __p0; \
+ __ret = (int32x2_t)(__promote); \
__ret; \
})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vld1q_s8(__p0) __extension__ ({ \
- int8x16_t __ret; \
- __ret = (int8x16_t) __builtin_neon_vld1q_v(__p0, 32); \
+#define vcreate_s64(__p0) __extension__ ({ \
+ int64x1_t __ret; \
+ uint64_t __promote = __p0; \
+ __ret = (int64x1_t)(__promote); \
__ret; \
})
-#else
-#define vld1q_s8(__p0) __extension__ ({ \
- int8x16_t __ret; \
- __ret = (int8x16_t) __builtin_neon_vld1q_v(__p0, 32); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vcreate_s16(__p0) __extension__ ({ \
+ int16x4_t __ret; \
+ uint64_t __promote = __p0; \
+ __ret = (int16x4_t)(__promote); \
__ret; \
})
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vcvtq_f32_u32(uint32x4_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vcvtq_f32_v((int8x16_t)__p0, 50);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vcvtq_f32_u32(uint32x4_t __p0) {
+ float32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vcvtq_f32_v((int8x16_t)__rev0, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_f32(__p0) __extension__ ({ \
+__ai __attribute__((target("neon"))) float32x4_t vcvtq_f32_s32(int32x4_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vcvtq_f32_v((int8x16_t)__p0, 34);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vcvtq_f32_s32(int32x4_t __p0) {
+ float32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vcvtq_f32_v((int8x16_t)__rev0, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vcvt_f32_u32(uint32x2_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vcvt_f32_v((int8x8_t)__p0, 18);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vcvt_f32_u32(uint32x2_t __p0) {
+ float32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vcvt_f32_v((int8x8_t)__rev0, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vcvt_f32_s32(int32x2_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vcvt_f32_v((int8x8_t)__p0, 2);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vcvt_f32_s32(int32x2_t __p0) {
+ float32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vcvt_f32_v((int8x8_t)__rev0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcvtq_n_f32_u32(__p0, __p1) __extension__ ({ \
float32x4_t __ret; \
- __ret = (float32x4_t) __builtin_neon_vld1q_v(__p0, 41); \
+ uint32x4_t __s0 = __p0; \
+ __ret = (float32x4_t) __builtin_neon_vcvtq_n_f32_v((int8x16_t)__s0, __p1, 50); \
__ret; \
})
#else
-#define vld1q_f32(__p0) __extension__ ({ \
+#define vcvtq_n_f32_u32(__p0, __p1) __extension__ ({ \
float32x4_t __ret; \
- __ret = (float32x4_t) __builtin_neon_vld1q_v(__p0, 41); \
+ uint32x4_t __s0 = __p0; \
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (float32x4_t) __builtin_neon_vcvtq_n_f32_v((int8x16_t)__rev0, __p1, 50); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_s32(__p0) __extension__ ({ \
- int32x4_t __ret; \
- __ret = (int32x4_t) __builtin_neon_vld1q_v(__p0, 34); \
+#define vcvtq_n_f32_s32(__p0, __p1) __extension__ ({ \
+ float32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (float32x4_t) __builtin_neon_vcvtq_n_f32_v((int8x16_t)__s0, __p1, 34); \
__ret; \
})
#else
-#define vld1q_s32(__p0) __extension__ ({ \
- int32x4_t __ret; \
- __ret = (int32x4_t) __builtin_neon_vld1q_v(__p0, 34); \
+#define vcvtq_n_f32_s32(__p0, __p1) __extension__ ({ \
+ float32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (float32x4_t) __builtin_neon_vcvtq_n_f32_v((int8x16_t)__rev0, __p1, 34); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_s64(__p0) __extension__ ({ \
- int64x2_t __ret; \
- __ret = (int64x2_t) __builtin_neon_vld1q_v(__p0, 35); \
+#define vcvt_n_f32_u32(__p0, __p1) __extension__ ({ \
+ float32x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ __ret = (float32x2_t) __builtin_neon_vcvt_n_f32_v((int8x8_t)__s0, __p1, 18); \
__ret; \
})
#else
-#define vld1q_s64(__p0) __extension__ ({ \
- int64x2_t __ret; \
- __ret = (int64x2_t) __builtin_neon_vld1q_v(__p0, 35); \
+#define vcvt_n_f32_u32(__p0, __p1) __extension__ ({ \
+ float32x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (float32x2_t) __builtin_neon_vcvt_n_f32_v((int8x8_t)__rev0, __p1, 18); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_s16(__p0) __extension__ ({ \
- int16x8_t __ret; \
- __ret = (int16x8_t) __builtin_neon_vld1q_v(__p0, 33); \
+#define vcvt_n_f32_s32(__p0, __p1) __extension__ ({ \
+ float32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ __ret = (float32x2_t) __builtin_neon_vcvt_n_f32_v((int8x8_t)__s0, __p1, 2); \
__ret; \
})
#else
-#define vld1q_s16(__p0) __extension__ ({ \
- int16x8_t __ret; \
- __ret = (int16x8_t) __builtin_neon_vld1q_v(__p0, 33); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vcvt_n_f32_s32(__p0, __p1) __extension__ ({ \
+ float32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (float32x2_t) __builtin_neon_vcvt_n_f32_v((int8x8_t)__rev0, __p1, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_u8(__p0) __extension__ ({ \
- uint8x8_t __ret; \
- __ret = (uint8x8_t) __builtin_neon_vld1_v(__p0, 16); \
+#define vcvtq_n_s32_f32(__p0, __p1) __extension__ ({ \
+ int32x4_t __ret; \
+ float32x4_t __s0 = __p0; \
+ __ret = (int32x4_t) __builtin_neon_vcvtq_n_s32_v((int8x16_t)__s0, __p1, 34); \
__ret; \
})
#else
-#define vld1_u8(__p0) __extension__ ({ \
- uint8x8_t __ret; \
- __ret = (uint8x8_t) __builtin_neon_vld1_v(__p0, 16); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vcvtq_n_s32_f32(__p0, __p1) __extension__ ({ \
+ int32x4_t __ret; \
+ float32x4_t __s0 = __p0; \
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (int32x4_t) __builtin_neon_vcvtq_n_s32_v((int8x16_t)__rev0, __p1, 34); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_u32(__p0) __extension__ ({ \
- uint32x2_t __ret; \
- __ret = (uint32x2_t) __builtin_neon_vld1_v(__p0, 18); \
+#define vcvt_n_s32_f32(__p0, __p1) __extension__ ({ \
+ int32x2_t __ret; \
+ float32x2_t __s0 = __p0; \
+ __ret = (int32x2_t) __builtin_neon_vcvt_n_s32_v((int8x8_t)__s0, __p1, 2); \
__ret; \
})
#else
-#define vld1_u32(__p0) __extension__ ({ \
- uint32x2_t __ret; \
- __ret = (uint32x2_t) __builtin_neon_vld1_v(__p0, 18); \
+#define vcvt_n_s32_f32(__p0, __p1) __extension__ ({ \
+ int32x2_t __ret; \
+ float32x2_t __s0 = __p0; \
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (int32x2_t) __builtin_neon_vcvt_n_s32_v((int8x8_t)__rev0, __p1, 2); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
-#define vld1_u64(__p0) __extension__ ({ \
- uint64x1_t __ret; \
- __ret = (uint64x1_t) __builtin_neon_vld1_v(__p0, 19); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vld1_u16(__p0) __extension__ ({ \
- uint16x4_t __ret; \
- __ret = (uint16x4_t) __builtin_neon_vld1_v(__p0, 17); \
+#define vcvtq_n_u32_f32(__p0, __p1) __extension__ ({ \
+ uint32x4_t __ret; \
+ float32x4_t __s0 = __p0; \
+ __ret = (uint32x4_t) __builtin_neon_vcvtq_n_u32_v((int8x16_t)__s0, __p1, 50); \
__ret; \
})
#else
-#define vld1_u16(__p0) __extension__ ({ \
- uint16x4_t __ret; \
- __ret = (uint16x4_t) __builtin_neon_vld1_v(__p0, 17); \
+#define vcvtq_n_u32_f32(__p0, __p1) __extension__ ({ \
+ uint32x4_t __ret; \
+ float32x4_t __s0 = __p0; \
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint32x4_t) __builtin_neon_vcvtq_n_u32_v((int8x16_t)__rev0, __p1, 50); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_s8(__p0) __extension__ ({ \
- int8x8_t __ret; \
- __ret = (int8x8_t) __builtin_neon_vld1_v(__p0, 0); \
+#define vcvt_n_u32_f32(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ float32x2_t __s0 = __p0; \
+ __ret = (uint32x2_t) __builtin_neon_vcvt_n_u32_v((int8x8_t)__s0, __p1, 18); \
__ret; \
})
#else
-#define vld1_s8(__p0) __extension__ ({ \
- int8x8_t __ret; \
- __ret = (int8x8_t) __builtin_neon_vld1_v(__p0, 0); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vcvt_n_u32_f32(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ float32x2_t __s0 = __p0; \
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint32x2_t) __builtin_neon_vcvt_n_u32_v((int8x8_t)__rev0, __p1, 18); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_f32(__p0) __extension__ ({ \
- float32x2_t __ret; \
- __ret = (float32x2_t) __builtin_neon_vld1_v(__p0, 9); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vcvtq_s32_f32(float32x4_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vcvtq_s32_v((int8x16_t)__p0, 34);
+ return __ret;
+}
#else
-#define vld1_f32(__p0) __extension__ ({ \
- float32x2_t __ret; \
- __ret = (float32x2_t) __builtin_neon_vld1_v(__p0, 9); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vcvtq_s32_f32(float32x4_t __p0) {
+ int32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vcvtq_s32_v((int8x16_t)__rev0, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_s32(__p0) __extension__ ({ \
- int32x2_t __ret; \
- __ret = (int32x2_t) __builtin_neon_vld1_v(__p0, 2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vcvt_s32_f32(float32x2_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vcvt_s32_v((int8x8_t)__p0, 2);
+ return __ret;
+}
#else
-#define vld1_s32(__p0) __extension__ ({ \
- int32x2_t __ret; \
- __ret = (int32x2_t) __builtin_neon_vld1_v(__p0, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vcvt_s32_f32(float32x2_t __p0) {
+ int32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vcvt_s32_v((int8x8_t)__rev0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
-#define vld1_s64(__p0) __extension__ ({ \
- int64x1_t __ret; \
- __ret = (int64x1_t) __builtin_neon_vld1_v(__p0, 3); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vld1_s16(__p0) __extension__ ({ \
- int16x4_t __ret; \
- __ret = (int16x4_t) __builtin_neon_vld1_v(__p0, 1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcvtq_u32_f32(float32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vcvtq_u32_v((int8x16_t)__p0, 50);
+ return __ret;
+}
#else
-#define vld1_s16(__p0) __extension__ ({ \
- int16x4_t __ret; \
- __ret = (int16x4_t) __builtin_neon_vld1_v(__p0, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcvtq_u32_f32(float32x4_t __p0) {
+ uint32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vcvtq_u32_v((int8x16_t)__rev0, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_dup_p8(__p0) __extension__ ({ \
- poly8x8_t __ret; \
- __ret = (poly8x8_t) __builtin_neon_vld1_dup_v(__p0, 4); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcvt_u32_f32(float32x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vcvt_u32_v((int8x8_t)__p0, 18);
+ return __ret;
+}
#else
-#define vld1_dup_p8(__p0) __extension__ ({ \
- poly8x8_t __ret; \
- __ret = (poly8x8_t) __builtin_neon_vld1_dup_v(__p0, 4); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcvt_u32_f32(float32x2_t __p0) {
+ uint32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vcvt_u32_v((int8x8_t)__rev0, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_dup_p16(__p0) __extension__ ({ \
- poly16x4_t __ret; \
- __ret = (poly16x4_t) __builtin_neon_vld1_dup_v(__p0, 5); \
- __ret; \
+#define vdup_lane_p8(__p0_8, __p1_8) __extension__ ({ \
+ poly8x8_t __ret_8; \
+ poly8x8_t __s0_8 = __p0_8; \
+ __ret_8 = splat_lane_p8(__s0_8, __p1_8); \
+ __ret_8; \
})
#else
-#define vld1_dup_p16(__p0) __extension__ ({ \
- poly16x4_t __ret; \
- __ret = (poly16x4_t) __builtin_neon_vld1_dup_v(__p0, 5); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
+#define vdup_lane_p8(__p0_9, __p1_9) __extension__ ({ \
+ poly8x8_t __ret_9; \
+ poly8x8_t __s0_9 = __p0_9; \
+ poly8x8_t __rev0_9; __rev0_9 = __builtin_shufflevector(__s0_9, __s0_9, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_9 = __noswap_splat_lane_p8(__rev0_9, __p1_9); \
+ __ret_9 = __builtin_shufflevector(__ret_9, __ret_9, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_9; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_dup_p8(__p0) __extension__ ({ \
- poly8x16_t __ret; \
- __ret = (poly8x16_t) __builtin_neon_vld1q_dup_v(__p0, 36); \
- __ret; \
+#define vdup_lane_p16(__p0_10, __p1_10) __extension__ ({ \
+ poly16x4_t __ret_10; \
+ poly16x4_t __s0_10 = __p0_10; \
+ __ret_10 = splat_lane_p16(__s0_10, __p1_10); \
+ __ret_10; \
})
#else
-#define vld1q_dup_p8(__p0) __extension__ ({ \
- poly8x16_t __ret; \
- __ret = (poly8x16_t) __builtin_neon_vld1q_dup_v(__p0, 36); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vdup_lane_p16(__p0_11, __p1_11) __extension__ ({ \
+ poly16x4_t __ret_11; \
+ poly16x4_t __s0_11 = __p0_11; \
+ poly16x4_t __rev0_11; __rev0_11 = __builtin_shufflevector(__s0_11, __s0_11, 3, 2, 1, 0); \
+ __ret_11 = __noswap_splat_lane_p16(__rev0_11, __p1_11); \
+ __ret_11 = __builtin_shufflevector(__ret_11, __ret_11, 3, 2, 1, 0); \
+ __ret_11; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_dup_p16(__p0) __extension__ ({ \
- poly16x8_t __ret; \
- __ret = (poly16x8_t) __builtin_neon_vld1q_dup_v(__p0, 37); \
- __ret; \
+#define vdupq_lane_p8(__p0_12, __p1_12) __extension__ ({ \
+ poly8x16_t __ret_12; \
+ poly8x8_t __s0_12 = __p0_12; \
+ __ret_12 = splatq_lane_p8(__s0_12, __p1_12); \
+ __ret_12; \
})
#else
-#define vld1q_dup_p16(__p0) __extension__ ({ \
- poly16x8_t __ret; \
- __ret = (poly16x8_t) __builtin_neon_vld1q_dup_v(__p0, 37); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vdupq_lane_p8(__p0_13, __p1_13) __extension__ ({ \
+ poly8x16_t __ret_13; \
+ poly8x8_t __s0_13 = __p0_13; \
+ poly8x8_t __rev0_13; __rev0_13 = __builtin_shufflevector(__s0_13, __s0_13, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_13 = __noswap_splatq_lane_p8(__rev0_13, __p1_13); \
+ __ret_13 = __builtin_shufflevector(__ret_13, __ret_13, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_13; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_dup_u8(__p0) __extension__ ({ \
- uint8x16_t __ret; \
- __ret = (uint8x16_t) __builtin_neon_vld1q_dup_v(__p0, 48); \
- __ret; \
+#define vdupq_lane_p16(__p0_14, __p1_14) __extension__ ({ \
+ poly16x8_t __ret_14; \
+ poly16x4_t __s0_14 = __p0_14; \
+ __ret_14 = splatq_lane_p16(__s0_14, __p1_14); \
+ __ret_14; \
})
#else
-#define vld1q_dup_u8(__p0) __extension__ ({ \
- uint8x16_t __ret; \
- __ret = (uint8x16_t) __builtin_neon_vld1q_dup_v(__p0, 48); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vdupq_lane_p16(__p0_15, __p1_15) __extension__ ({ \
+ poly16x8_t __ret_15; \
+ poly16x4_t __s0_15 = __p0_15; \
+ poly16x4_t __rev0_15; __rev0_15 = __builtin_shufflevector(__s0_15, __s0_15, 3, 2, 1, 0); \
+ __ret_15 = __noswap_splatq_lane_p16(__rev0_15, __p1_15); \
+ __ret_15 = __builtin_shufflevector(__ret_15, __ret_15, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_15; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_dup_u32(__p0) __extension__ ({ \
- uint32x4_t __ret; \
- __ret = (uint32x4_t) __builtin_neon_vld1q_dup_v(__p0, 50); \
- __ret; \
+#define vdupq_lane_u8(__p0_16, __p1_16) __extension__ ({ \
+ uint8x16_t __ret_16; \
+ uint8x8_t __s0_16 = __p0_16; \
+ __ret_16 = splatq_lane_u8(__s0_16, __p1_16); \
+ __ret_16; \
})
#else
-#define vld1q_dup_u32(__p0) __extension__ ({ \
- uint32x4_t __ret; \
- __ret = (uint32x4_t) __builtin_neon_vld1q_dup_v(__p0, 50); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
+#define vdupq_lane_u8(__p0_17, __p1_17) __extension__ ({ \
+ uint8x16_t __ret_17; \
+ uint8x8_t __s0_17 = __p0_17; \
+ uint8x8_t __rev0_17; __rev0_17 = __builtin_shufflevector(__s0_17, __s0_17, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_17 = __noswap_splatq_lane_u8(__rev0_17, __p1_17); \
+ __ret_17 = __builtin_shufflevector(__ret_17, __ret_17, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_17; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_dup_u64(__p0) __extension__ ({ \
- uint64x2_t __ret; \
- __ret = (uint64x2_t) __builtin_neon_vld1q_dup_v(__p0, 51); \
- __ret; \
+#define vdupq_lane_u32(__p0_18, __p1_18) __extension__ ({ \
+ uint32x4_t __ret_18; \
+ uint32x2_t __s0_18 = __p0_18; \
+ __ret_18 = splatq_lane_u32(__s0_18, __p1_18); \
+ __ret_18; \
})
#else
-#define vld1q_dup_u64(__p0) __extension__ ({ \
- uint64x2_t __ret; \
- __ret = (uint64x2_t) __builtin_neon_vld1q_dup_v(__p0, 51); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
+#define vdupq_lane_u32(__p0_19, __p1_19) __extension__ ({ \
+ uint32x4_t __ret_19; \
+ uint32x2_t __s0_19 = __p0_19; \
+ uint32x2_t __rev0_19; __rev0_19 = __builtin_shufflevector(__s0_19, __s0_19, 1, 0); \
+ __ret_19 = __noswap_splatq_lane_u32(__rev0_19, __p1_19); \
+ __ret_19 = __builtin_shufflevector(__ret_19, __ret_19, 3, 2, 1, 0); \
+ __ret_19; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_dup_u16(__p0) __extension__ ({ \
- uint16x8_t __ret; \
- __ret = (uint16x8_t) __builtin_neon_vld1q_dup_v(__p0, 49); \
- __ret; \
+#define vdupq_lane_u64(__p0_20, __p1_20) __extension__ ({ \
+ uint64x2_t __ret_20; \
+ uint64x1_t __s0_20 = __p0_20; \
+ __ret_20 = splatq_lane_u64(__s0_20, __p1_20); \
+ __ret_20; \
})
#else
-#define vld1q_dup_u16(__p0) __extension__ ({ \
- uint16x8_t __ret; \
- __ret = (uint16x8_t) __builtin_neon_vld1q_dup_v(__p0, 49); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vdupq_lane_u64(__p0_21, __p1_21) __extension__ ({ \
+ uint64x2_t __ret_21; \
+ uint64x1_t __s0_21 = __p0_21; \
+ __ret_21 = __noswap_splatq_lane_u64(__s0_21, __p1_21); \
+ __ret_21 = __builtin_shufflevector(__ret_21, __ret_21, 1, 0); \
+ __ret_21; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_dup_s8(__p0) __extension__ ({ \
- int8x16_t __ret; \
- __ret = (int8x16_t) __builtin_neon_vld1q_dup_v(__p0, 32); \
- __ret; \
+#define vdupq_lane_u16(__p0_22, __p1_22) __extension__ ({ \
+ uint16x8_t __ret_22; \
+ uint16x4_t __s0_22 = __p0_22; \
+ __ret_22 = splatq_lane_u16(__s0_22, __p1_22); \
+ __ret_22; \
})
#else
-#define vld1q_dup_s8(__p0) __extension__ ({ \
- int8x16_t __ret; \
- __ret = (int8x16_t) __builtin_neon_vld1q_dup_v(__p0, 32); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vdupq_lane_u16(__p0_23, __p1_23) __extension__ ({ \
+ uint16x8_t __ret_23; \
+ uint16x4_t __s0_23 = __p0_23; \
+ uint16x4_t __rev0_23; __rev0_23 = __builtin_shufflevector(__s0_23, __s0_23, 3, 2, 1, 0); \
+ __ret_23 = __noswap_splatq_lane_u16(__rev0_23, __p1_23); \
+ __ret_23 = __builtin_shufflevector(__ret_23, __ret_23, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_23; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_dup_f32(__p0) __extension__ ({ \
- float32x4_t __ret; \
- __ret = (float32x4_t) __builtin_neon_vld1q_dup_v(__p0, 41); \
- __ret; \
+#define vdupq_lane_s8(__p0_24, __p1_24) __extension__ ({ \
+ int8x16_t __ret_24; \
+ int8x8_t __s0_24 = __p0_24; \
+ __ret_24 = splatq_lane_s8(__s0_24, __p1_24); \
+ __ret_24; \
})
#else
-#define vld1q_dup_f32(__p0) __extension__ ({ \
- float32x4_t __ret; \
- __ret = (float32x4_t) __builtin_neon_vld1q_dup_v(__p0, 41); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
+#define vdupq_lane_s8(__p0_25, __p1_25) __extension__ ({ \
+ int8x16_t __ret_25; \
+ int8x8_t __s0_25 = __p0_25; \
+ int8x8_t __rev0_25; __rev0_25 = __builtin_shufflevector(__s0_25, __s0_25, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_25 = __noswap_splatq_lane_s8(__rev0_25, __p1_25); \
+ __ret_25 = __builtin_shufflevector(__ret_25, __ret_25, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_25; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_dup_s32(__p0) __extension__ ({ \
- int32x4_t __ret; \
- __ret = (int32x4_t) __builtin_neon_vld1q_dup_v(__p0, 34); \
- __ret; \
+#define vdupq_lane_f32(__p0_26, __p1_26) __extension__ ({ \
+ float32x4_t __ret_26; \
+ float32x2_t __s0_26 = __p0_26; \
+ __ret_26 = splatq_lane_f32(__s0_26, __p1_26); \
+ __ret_26; \
})
#else
-#define vld1q_dup_s32(__p0) __extension__ ({ \
- int32x4_t __ret; \
- __ret = (int32x4_t) __builtin_neon_vld1q_dup_v(__p0, 34); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
+#define vdupq_lane_f32(__p0_27, __p1_27) __extension__ ({ \
+ float32x4_t __ret_27; \
+ float32x2_t __s0_27 = __p0_27; \
+ float32x2_t __rev0_27; __rev0_27 = __builtin_shufflevector(__s0_27, __s0_27, 1, 0); \
+ __ret_27 = __noswap_splatq_lane_f32(__rev0_27, __p1_27); \
+ __ret_27 = __builtin_shufflevector(__ret_27, __ret_27, 3, 2, 1, 0); \
+ __ret_27; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_dup_s64(__p0) __extension__ ({ \
- int64x2_t __ret; \
- __ret = (int64x2_t) __builtin_neon_vld1q_dup_v(__p0, 35); \
- __ret; \
+#define vdupq_lane_f16(__p0_28, __p1_28) __extension__ ({ \
+ float16x8_t __ret_28; \
+ float16x4_t __s0_28 = __p0_28; \
+ __ret_28 = splatq_lane_f16(__s0_28, __p1_28); \
+ __ret_28; \
})
#else
-#define vld1q_dup_s64(__p0) __extension__ ({ \
- int64x2_t __ret; \
- __ret = (int64x2_t) __builtin_neon_vld1q_dup_v(__p0, 35); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
+#define vdupq_lane_f16(__p0_29, __p1_29) __extension__ ({ \
+ float16x8_t __ret_29; \
+ float16x4_t __s0_29 = __p0_29; \
+ float16x4_t __rev0_29; __rev0_29 = __builtin_shufflevector(__s0_29, __s0_29, 3, 2, 1, 0); \
+ __ret_29 = __noswap_splatq_lane_f16(__rev0_29, __p1_29); \
+ __ret_29 = __builtin_shufflevector(__ret_29, __ret_29, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_29; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_dup_s16(__p0) __extension__ ({ \
- int16x8_t __ret; \
- __ret = (int16x8_t) __builtin_neon_vld1q_dup_v(__p0, 33); \
- __ret; \
+#define vdupq_lane_s32(__p0_30, __p1_30) __extension__ ({ \
+ int32x4_t __ret_30; \
+ int32x2_t __s0_30 = __p0_30; \
+ __ret_30 = splatq_lane_s32(__s0_30, __p1_30); \
+ __ret_30; \
})
#else
-#define vld1q_dup_s16(__p0) __extension__ ({ \
- int16x8_t __ret; \
- __ret = (int16x8_t) __builtin_neon_vld1q_dup_v(__p0, 33); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vdupq_lane_s32(__p0_31, __p1_31) __extension__ ({ \
+ int32x4_t __ret_31; \
+ int32x2_t __s0_31 = __p0_31; \
+ int32x2_t __rev0_31; __rev0_31 = __builtin_shufflevector(__s0_31, __s0_31, 1, 0); \
+ __ret_31 = __noswap_splatq_lane_s32(__rev0_31, __p1_31); \
+ __ret_31 = __builtin_shufflevector(__ret_31, __ret_31, 3, 2, 1, 0); \
+ __ret_31; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_dup_u8(__p0) __extension__ ({ \
- uint8x8_t __ret; \
- __ret = (uint8x8_t) __builtin_neon_vld1_dup_v(__p0, 16); \
- __ret; \
+#define vdupq_lane_s64(__p0_32, __p1_32) __extension__ ({ \
+ int64x2_t __ret_32; \
+ int64x1_t __s0_32 = __p0_32; \
+ __ret_32 = splatq_lane_s64(__s0_32, __p1_32); \
+ __ret_32; \
})
#else
-#define vld1_dup_u8(__p0) __extension__ ({ \
- uint8x8_t __ret; \
- __ret = (uint8x8_t) __builtin_neon_vld1_dup_v(__p0, 16); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vdupq_lane_s64(__p0_33, __p1_33) __extension__ ({ \
+ int64x2_t __ret_33; \
+ int64x1_t __s0_33 = __p0_33; \
+ __ret_33 = __noswap_splatq_lane_s64(__s0_33, __p1_33); \
+ __ret_33 = __builtin_shufflevector(__ret_33, __ret_33, 1, 0); \
+ __ret_33; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_dup_u32(__p0) __extension__ ({ \
- uint32x2_t __ret; \
- __ret = (uint32x2_t) __builtin_neon_vld1_dup_v(__p0, 18); \
- __ret; \
+#define vdupq_lane_s16(__p0_34, __p1_34) __extension__ ({ \
+ int16x8_t __ret_34; \
+ int16x4_t __s0_34 = __p0_34; \
+ __ret_34 = splatq_lane_s16(__s0_34, __p1_34); \
+ __ret_34; \
})
#else
-#define vld1_dup_u32(__p0) __extension__ ({ \
- uint32x2_t __ret; \
- __ret = (uint32x2_t) __builtin_neon_vld1_dup_v(__p0, 18); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
+#define vdupq_lane_s16(__p0_35, __p1_35) __extension__ ({ \
+ int16x8_t __ret_35; \
+ int16x4_t __s0_35 = __p0_35; \
+ int16x4_t __rev0_35; __rev0_35 = __builtin_shufflevector(__s0_35, __s0_35, 3, 2, 1, 0); \
+ __ret_35 = __noswap_splatq_lane_s16(__rev0_35, __p1_35); \
+ __ret_35 = __builtin_shufflevector(__ret_35, __ret_35, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_35; \
})
#endif
-#define vld1_dup_u64(__p0) __extension__ ({ \
- uint64x1_t __ret; \
- __ret = (uint64x1_t) __builtin_neon_vld1_dup_v(__p0, 19); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vld1_dup_u16(__p0) __extension__ ({ \
- uint16x4_t __ret; \
- __ret = (uint16x4_t) __builtin_neon_vld1_dup_v(__p0, 17); \
- __ret; \
+#define vdup_lane_u8(__p0_36, __p1_36) __extension__ ({ \
+ uint8x8_t __ret_36; \
+ uint8x8_t __s0_36 = __p0_36; \
+ __ret_36 = splat_lane_u8(__s0_36, __p1_36); \
+ __ret_36; \
})
#else
-#define vld1_dup_u16(__p0) __extension__ ({ \
- uint16x4_t __ret; \
- __ret = (uint16x4_t) __builtin_neon_vld1_dup_v(__p0, 17); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
+#define vdup_lane_u8(__p0_37, __p1_37) __extension__ ({ \
+ uint8x8_t __ret_37; \
+ uint8x8_t __s0_37 = __p0_37; \
+ uint8x8_t __rev0_37; __rev0_37 = __builtin_shufflevector(__s0_37, __s0_37, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_37 = __noswap_splat_lane_u8(__rev0_37, __p1_37); \
+ __ret_37 = __builtin_shufflevector(__ret_37, __ret_37, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_37; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_dup_s8(__p0) __extension__ ({ \
- int8x8_t __ret; \
- __ret = (int8x8_t) __builtin_neon_vld1_dup_v(__p0, 0); \
- __ret; \
+#define vdup_lane_u32(__p0_38, __p1_38) __extension__ ({ \
+ uint32x2_t __ret_38; \
+ uint32x2_t __s0_38 = __p0_38; \
+ __ret_38 = splat_lane_u32(__s0_38, __p1_38); \
+ __ret_38; \
})
#else
-#define vld1_dup_s8(__p0) __extension__ ({ \
- int8x8_t __ret; \
- __ret = (int8x8_t) __builtin_neon_vld1_dup_v(__p0, 0); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vdup_lane_u32(__p0_39, __p1_39) __extension__ ({ \
+ uint32x2_t __ret_39; \
+ uint32x2_t __s0_39 = __p0_39; \
+ uint32x2_t __rev0_39; __rev0_39 = __builtin_shufflevector(__s0_39, __s0_39, 1, 0); \
+ __ret_39 = __noswap_splat_lane_u32(__rev0_39, __p1_39); \
+ __ret_39 = __builtin_shufflevector(__ret_39, __ret_39, 1, 0); \
+ __ret_39; \
})
#endif
+#define vdup_lane_u64(__p0_40, __p1_40) __extension__ ({ \
+ uint64x1_t __ret_40; \
+ uint64x1_t __s0_40 = __p0_40; \
+ __ret_40 = splat_lane_u64(__s0_40, __p1_40); \
+ __ret_40; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vld1_dup_f32(__p0) __extension__ ({ \
- float32x2_t __ret; \
- __ret = (float32x2_t) __builtin_neon_vld1_dup_v(__p0, 9); \
- __ret; \
+#define vdup_lane_u16(__p0_41, __p1_41) __extension__ ({ \
+ uint16x4_t __ret_41; \
+ uint16x4_t __s0_41 = __p0_41; \
+ __ret_41 = splat_lane_u16(__s0_41, __p1_41); \
+ __ret_41; \
})
#else
-#define vld1_dup_f32(__p0) __extension__ ({ \
- float32x2_t __ret; \
- __ret = (float32x2_t) __builtin_neon_vld1_dup_v(__p0, 9); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
+#define vdup_lane_u16(__p0_42, __p1_42) __extension__ ({ \
+ uint16x4_t __ret_42; \
+ uint16x4_t __s0_42 = __p0_42; \
+ uint16x4_t __rev0_42; __rev0_42 = __builtin_shufflevector(__s0_42, __s0_42, 3, 2, 1, 0); \
+ __ret_42 = __noswap_splat_lane_u16(__rev0_42, __p1_42); \
+ __ret_42 = __builtin_shufflevector(__ret_42, __ret_42, 3, 2, 1, 0); \
+ __ret_42; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_dup_s32(__p0) __extension__ ({ \
- int32x2_t __ret; \
- __ret = (int32x2_t) __builtin_neon_vld1_dup_v(__p0, 2); \
- __ret; \
+#define vdup_lane_s8(__p0_43, __p1_43) __extension__ ({ \
+ int8x8_t __ret_43; \
+ int8x8_t __s0_43 = __p0_43; \
+ __ret_43 = splat_lane_s8(__s0_43, __p1_43); \
+ __ret_43; \
})
#else
-#define vld1_dup_s32(__p0) __extension__ ({ \
- int32x2_t __ret; \
- __ret = (int32x2_t) __builtin_neon_vld1_dup_v(__p0, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
+#define vdup_lane_s8(__p0_44, __p1_44) __extension__ ({ \
+ int8x8_t __ret_44; \
+ int8x8_t __s0_44 = __p0_44; \
+ int8x8_t __rev0_44; __rev0_44 = __builtin_shufflevector(__s0_44, __s0_44, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_44 = __noswap_splat_lane_s8(__rev0_44, __p1_44); \
+ __ret_44 = __builtin_shufflevector(__ret_44, __ret_44, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_44; \
})
#endif
-#define vld1_dup_s64(__p0) __extension__ ({ \
- int64x1_t __ret; \
- __ret = (int64x1_t) __builtin_neon_vld1_dup_v(__p0, 3); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vld1_dup_s16(__p0) __extension__ ({ \
- int16x4_t __ret; \
- __ret = (int16x4_t) __builtin_neon_vld1_dup_v(__p0, 1); \
- __ret; \
+#define vdup_lane_f32(__p0_45, __p1_45) __extension__ ({ \
+ float32x2_t __ret_45; \
+ float32x2_t __s0_45 = __p0_45; \
+ __ret_45 = splat_lane_f32(__s0_45, __p1_45); \
+ __ret_45; \
})
#else
-#define vld1_dup_s16(__p0) __extension__ ({ \
- int16x4_t __ret; \
- __ret = (int16x4_t) __builtin_neon_vld1_dup_v(__p0, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
+#define vdup_lane_f32(__p0_46, __p1_46) __extension__ ({ \
+ float32x2_t __ret_46; \
+ float32x2_t __s0_46 = __p0_46; \
+ float32x2_t __rev0_46; __rev0_46 = __builtin_shufflevector(__s0_46, __s0_46, 1, 0); \
+ __ret_46 = __noswap_splat_lane_f32(__rev0_46, __p1_46); \
+ __ret_46 = __builtin_shufflevector(__ret_46, __ret_46, 1, 0); \
+ __ret_46; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8_t __ret; \
- poly8x8_t __s1 = __p1; \
- __ret = (poly8x8_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 4); \
- __ret; \
+#define vdup_lane_f16(__p0_47, __p1_47) __extension__ ({ \
+ float16x4_t __ret_47; \
+ float16x4_t __s0_47 = __p0_47; \
+ __ret_47 = splat_lane_f16(__s0_47, __p1_47); \
+ __ret_47; \
})
#else
-#define vld1_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8_t __ret; \
- poly8x8_t __s1 = __p1; \
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly8x8_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 4); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vdup_lane_f16(__p0_48, __p1_48) __extension__ ({ \
+ float16x4_t __ret_48; \
+ float16x4_t __s0_48 = __p0_48; \
+ float16x4_t __rev0_48; __rev0_48 = __builtin_shufflevector(__s0_48, __s0_48, 3, 2, 1, 0); \
+ __ret_48 = __noswap_splat_lane_f16(__rev0_48, __p1_48); \
+ __ret_48 = __builtin_shufflevector(__ret_48, __ret_48, 3, 2, 1, 0); \
+ __ret_48; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4_t __ret; \
- poly16x4_t __s1 = __p1; \
- __ret = (poly16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 5); \
- __ret; \
+#define vdup_lane_s32(__p0_49, __p1_49) __extension__ ({ \
+ int32x2_t __ret_49; \
+ int32x2_t __s0_49 = __p0_49; \
+ __ret_49 = splat_lane_s32(__s0_49, __p1_49); \
+ __ret_49; \
})
#else
-#define vld1_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4_t __ret; \
- poly16x4_t __s1 = __p1; \
- poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (poly16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 5); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
+#define vdup_lane_s32(__p0_50, __p1_50) __extension__ ({ \
+ int32x2_t __ret_50; \
+ int32x2_t __s0_50 = __p0_50; \
+ int32x2_t __rev0_50; __rev0_50 = __builtin_shufflevector(__s0_50, __s0_50, 1, 0); \
+ __ret_50 = __noswap_splat_lane_s32(__rev0_50, __p1_50); \
+ __ret_50 = __builtin_shufflevector(__ret_50, __ret_50, 1, 0); \
+ __ret_50; \
})
#endif
+#define vdup_lane_s64(__p0_51, __p1_51) __extension__ ({ \
+ int64x1_t __ret_51; \
+ int64x1_t __s0_51 = __p0_51; \
+ __ret_51 = splat_lane_s64(__s0_51, __p1_51); \
+ __ret_51; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vld1q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16_t __ret; \
- poly8x16_t __s1 = __p1; \
- __ret = (poly8x16_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 36); \
- __ret; \
+#define vdup_lane_s16(__p0_52, __p1_52) __extension__ ({ \
+ int16x4_t __ret_52; \
+ int16x4_t __s0_52 = __p0_52; \
+ __ret_52 = splat_lane_s16(__s0_52, __p1_52); \
+ __ret_52; \
})
#else
-#define vld1q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16_t __ret; \
- poly8x16_t __s1 = __p1; \
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly8x16_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 36); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vdup_lane_s16(__p0_53, __p1_53) __extension__ ({ \
+ int16x4_t __ret_53; \
+ int16x4_t __s0_53 = __p0_53; \
+ int16x4_t __rev0_53; __rev0_53 = __builtin_shufflevector(__s0_53, __s0_53, 3, 2, 1, 0); \
+ __ret_53 = __noswap_splat_lane_s16(__rev0_53, __p1_53); \
+ __ret_53 = __builtin_shufflevector(__ret_53, __ret_53, 3, 2, 1, 0); \
+ __ret_53; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8_t __ret; \
- poly16x8_t __s1 = __p1; \
- __ret = (poly16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 37); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x8_t vdup_n_p8(poly8_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ return __ret;
+}
#else
-#define vld1q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8_t __ret; \
- poly16x8_t __s1 = __p1; \
- poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 37); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x8_t vdup_n_p8(poly8_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16_t __ret; \
- uint8x16_t __s1 = __p1; \
- __ret = (uint8x16_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 48); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x4_t vdup_n_p16(poly16_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t) {__p0, __p0, __p0, __p0};
+ return __ret;
+}
#else
-#define vld1q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16_t __ret; \
- uint8x16_t __s1 = __p1; \
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x16_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 48); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x4_t vdup_n_p16(poly16_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t) {__p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4_t __ret; \
- uint32x4_t __s1 = __p1; \
- __ret = (uint32x4_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 50); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x16_t vdupq_n_p8(poly8_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ return __ret;
+}
#else
-#define vld1q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4_t __ret; \
- uint32x4_t __s1 = __p1; \
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (uint32x4_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 50); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x16_t vdupq_n_p8(poly8_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2_t __ret; \
- uint64x2_t __s1 = __p1; \
- __ret = (uint64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 51); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x8_t vdupq_n_p16(poly16_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ return __ret;
+}
#else
-#define vld1q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2_t __ret; \
- uint64x2_t __s1 = __p1; \
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (uint64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 51); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x8_t vdupq_n_p16(poly16_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8_t __ret; \
- uint16x8_t __s1 = __p1; \
- __ret = (uint16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 49); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vdupq_n_u8(uint8_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ return __ret;
+}
#else
-#define vld1q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8_t __ret; \
- uint16x8_t __s1 = __p1; \
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 49); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vdupq_n_u8(uint8_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16_t __ret; \
- int8x16_t __s1 = __p1; \
- __ret = (int8x16_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 32); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vdupq_n_u32(uint32_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) {__p0, __p0, __p0, __p0};
+ return __ret;
+}
#else
-#define vld1q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16_t __ret; \
- int8x16_t __s1 = __p1; \
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x16_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 32); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vdupq_n_u32(uint32_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) {__p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x4_t __ret; \
- float32x4_t __s1 = __p1; \
- __ret = (float32x4_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 41); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vdupq_n_u64(uint64_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) {__p0, __p0};
+ return __ret;
+}
#else
-#define vld1q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x4_t __ret; \
- float32x4_t __s1 = __p1; \
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (float32x4_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 41); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vdupq_n_u64(uint64_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) {__p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s1 = __p1; \
- __ret = (int32x4_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 34); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vdupq_n_u16(uint16_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ return __ret;
+}
#else
-#define vld1q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s1 = __p1; \
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 34); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vdupq_n_u16(uint16_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2_t __ret; \
- int64x2_t __s1 = __p1; \
- __ret = (int64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 35); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vdupq_n_s8(int8_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ return __ret;
+}
#else
-#define vld1q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2_t __ret; \
- int64x2_t __s1 = __p1; \
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (int64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 35); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vdupq_n_s8(int8_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s1 = __p1; \
- __ret = (int16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 33); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vdupq_n_f32(float32_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) {__p0, __p0, __p0, __p0};
+ return __ret;
+}
#else
-#define vld1q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s1 = __p1; \
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 33); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vdupq_n_f32(float32_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) {__p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8_t __ret; \
- uint8x8_t __s1 = __p1; \
- __ret = (uint8x8_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 16); \
+#define vdupq_n_f16(__p0) __extension__ ({ \
+ float16x8_t __ret; \
+ float16_t __s0 = __p0; \
+ __ret = (float16x8_t) {__s0, __s0, __s0, __s0, __s0, __s0, __s0, __s0}; \
__ret; \
})
#else
-#define vld1_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8_t __ret; \
- uint8x8_t __s1 = __p1; \
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 16); \
+#define vdupq_n_f16(__p0) __extension__ ({ \
+ float16x8_t __ret; \
+ float16_t __s0 = __p0; \
+ __ret = (float16x8_t) {__s0, __s0, __s0, __s0, __s0, __s0, __s0, __s0}; \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2_t __ret; \
- uint32x2_t __s1 = __p1; \
- __ret = (uint32x2_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 18); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vdupq_n_s32(int32_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) {__p0, __p0, __p0, __p0};
+ return __ret;
+}
#else
-#define vld1_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2_t __ret; \
- uint32x2_t __s1 = __p1; \
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 18); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vdupq_n_s32(int32_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) {__p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vld1_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x1_t __ret; \
- uint64x1_t __s1 = __p1; \
- __ret = (uint64x1_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 19); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vld1_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4_t __ret; \
- uint16x4_t __s1 = __p1; \
- __ret = (uint16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 17); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vdupq_n_s64(int64_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) {__p0, __p0};
+ return __ret;
+}
#else
-#define vld1_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4_t __ret; \
- uint16x4_t __s1 = __p1; \
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 17); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vdupq_n_s64(int64_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) {__p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8_t __ret; \
- int8x8_t __s1 = __p1; \
- __ret = (int8x8_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vdupq_n_s16(int16_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ return __ret;
+}
#else
-#define vld1_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8_t __ret; \
- int8x8_t __s1 = __p1; \
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x8_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 0); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vld1_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x2_t __ret; \
- float32x2_t __s1 = __p1; \
- __ret = (float32x2_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 9); \
- __ret; \
-})
-#else
-#define vld1_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x2_t __ret; \
- float32x2_t __s1 = __p1; \
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (float32x2_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 9); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vdupq_n_s16(int16_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s1 = __p1; \
- __ret = (int32x2_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vdup_n_u8(uint8_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ return __ret;
+}
#else
-#define vld1_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s1 = __p1; \
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vdup_n_u8(uint8_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vld1_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x1_t __ret; \
- int64x1_t __s1 = __p1; \
- __ret = (int64x1_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 3); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vld1_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s1 = __p1; \
- __ret = (int16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vdup_n_u32(uint32_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) {__p0, __p0};
+ return __ret;
+}
#else
-#define vld1_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s1 = __p1; \
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vdup_n_u32(uint32_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) {__p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vdup_n_u64(uint64_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) {__p0};
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vld1_p8_x2(__p0) __extension__ ({ \
- poly8x8x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 4); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vdup_n_u16(uint16_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) {__p0, __p0, __p0, __p0};
+ return __ret;
+}
#else
-#define vld1_p8_x2(__p0) __extension__ ({ \
- poly8x8x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 4); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vdup_n_u16(uint16_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) {__p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_p16_x2(__p0) __extension__ ({ \
- poly16x4x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 5); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vdup_n_s8(int8_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ return __ret;
+}
#else
-#define vld1_p16_x2(__p0) __extension__ ({ \
- poly16x4x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 5); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vdup_n_s8(int8_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_p8_x2(__p0) __extension__ ({ \
- poly8x16x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 36); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vdup_n_f32(float32_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) {__p0, __p0};
+ return __ret;
+}
#else
-#define vld1q_p8_x2(__p0) __extension__ ({ \
- poly8x16x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 36); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vdup_n_f32(float32_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) {__p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_p16_x2(__p0) __extension__ ({ \
- poly16x8x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 37); \
+#define vdup_n_f16(__p0) __extension__ ({ \
+ float16x4_t __ret; \
+ float16_t __s0 = __p0; \
+ __ret = (float16x4_t) {__s0, __s0, __s0, __s0}; \
__ret; \
})
#else
-#define vld1q_p16_x2(__p0) __extension__ ({ \
- poly16x8x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 37); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vdup_n_f16(__p0) __extension__ ({ \
+ float16x4_t __ret; \
+ float16_t __s0 = __p0; \
+ __ret = (float16x4_t) {__s0, __s0, __s0, __s0}; \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_u8_x2(__p0) __extension__ ({ \
- uint8x16x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 48); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vdup_n_s32(int32_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) {__p0, __p0};
+ return __ret;
+}
#else
-#define vld1q_u8_x2(__p0) __extension__ ({ \
- uint8x16x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 48); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vdup_n_s32(int32_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) {__p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) int64x1_t vdup_n_s64(int64_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t) {__p0};
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vld1q_u32_x2(__p0) __extension__ ({ \
- uint32x4x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 50); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vdup_n_s16(int16_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) {__p0, __p0, __p0, __p0};
+ return __ret;
+}
#else
-#define vld1q_u32_x2(__p0) __extension__ ({ \
- uint32x4x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 50); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vdup_n_s16(int16_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) {__p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_u64_x2(__p0) __extension__ ({ \
- uint64x2x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 51); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t veorq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = __p0 ^ __p1;
+ return __ret;
+}
#else
-#define vld1q_u64_x2(__p0) __extension__ ({ \
- uint64x2x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 51); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t veorq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 ^ __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_u16_x2(__p0) __extension__ ({ \
- uint16x8x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 49); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t veorq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = __p0 ^ __p1;
+ return __ret;
+}
#else
-#define vld1q_u16_x2(__p0) __extension__ ({ \
- uint16x8x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 49); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t veorq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 ^ __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_s8_x2(__p0) __extension__ ({ \
- int8x16x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 32); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t veorq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = __p0 ^ __p1;
+ return __ret;
+}
#else
-#define vld1q_s8_x2(__p0) __extension__ ({ \
- int8x16x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 32); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t veorq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 ^ __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_f32_x2(__p0) __extension__ ({ \
- float32x4x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 41); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t veorq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = __p0 ^ __p1;
+ return __ret;
+}
#else
-#define vld1q_f32_x2(__p0) __extension__ ({ \
- float32x4x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 41); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t veorq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 ^ __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_s32_x2(__p0) __extension__ ({ \
- int32x4x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 34); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t veorq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = __p0 ^ __p1;
+ return __ret;
+}
#else
-#define vld1q_s32_x2(__p0) __extension__ ({ \
- int32x4x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 34); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t veorq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 ^ __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_s64_x2(__p0) __extension__ ({ \
- int64x2x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 35); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t veorq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = __p0 ^ __p1;
+ return __ret;
+}
#else
-#define vld1q_s64_x2(__p0) __extension__ ({ \
- int64x2x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 35); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t veorq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 ^ __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_s16_x2(__p0) __extension__ ({ \
- int16x8x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 33); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x2_t veorq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ __ret = __p0 ^ __p1;
+ return __ret;
+}
#else
-#define vld1q_s16_x2(__p0) __extension__ ({ \
- int16x8x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 33); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x2_t veorq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 ^ __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_u8_x2(__p0) __extension__ ({ \
- uint8x8x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 16); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t veorq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = __p0 ^ __p1;
+ return __ret;
+}
#else
-#define vld1_u8_x2(__p0) __extension__ ({ \
- uint8x8x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 16); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t veorq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 ^ __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_u32_x2(__p0) __extension__ ({ \
- uint32x2x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 18); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t veor_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = __p0 ^ __p1;
+ return __ret;
+}
#else
-#define vld1_u32_x2(__p0) __extension__ ({ \
- uint32x2x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 18); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t veor_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 ^ __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vld1_u64_x2(__p0) __extension__ ({ \
- uint64x1x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 19); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vld1_u16_x2(__p0) __extension__ ({ \
- uint16x4x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 17); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t veor_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = __p0 ^ __p1;
+ return __ret;
+}
#else
-#define vld1_u16_x2(__p0) __extension__ ({ \
- uint16x4x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 17); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t veor_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 ^ __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t veor_u64(uint64x1_t __p0, uint64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = __p0 ^ __p1;
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vld1_s8_x2(__p0) __extension__ ({ \
- int8x8x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t veor_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = __p0 ^ __p1;
+ return __ret;
+}
#else
-#define vld1_s8_x2(__p0) __extension__ ({ \
- int8x8x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 0); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t veor_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 ^ __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_f32_x2(__p0) __extension__ ({ \
- float32x2x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 9); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t veor_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = __p0 ^ __p1;
+ return __ret;
+}
#else
-#define vld1_f32_x2(__p0) __extension__ ({ \
- float32x2x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 9); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t veor_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 ^ __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_s32_x2(__p0) __extension__ ({ \
- int32x2x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t veor_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = __p0 ^ __p1;
+ return __ret;
+}
#else
-#define vld1_s32_x2(__p0) __extension__ ({ \
- int32x2x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 2); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t veor_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 ^ __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
-#define vld1_s64_x2(__p0) __extension__ ({ \
- int64x1x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 3); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x1_t veor_s64(int64x1_t __p0, int64x1_t __p1) {
+ int64x1_t __ret;
+ __ret = __p0 ^ __p1;
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vld1_s16_x2(__p0) __extension__ ({ \
- int16x4x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t veor_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = __p0 ^ __p1;
+ return __ret;
+}
#else
-#define vld1_s16_x2(__p0) __extension__ ({ \
- int16x4x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 1); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t veor_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 ^ __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_p8_x3(__p0) __extension__ ({ \
- poly8x8x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 4); \
+#define vext_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8_t __ret; \
+ poly8x8_t __s0 = __p0; \
+ poly8x8_t __s1 = __p1; \
+ __ret = (poly8x8_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 4); \
__ret; \
})
#else
-#define vld1_p8_x3(__p0) __extension__ ({ \
- poly8x8x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 4); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vext_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8_t __ret; \
+ poly8x8_t __s0 = __p0; \
+ poly8x8_t __s1 = __p1; \
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly8x8_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 4); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_p16_x3(__p0) __extension__ ({ \
- poly16x4x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 5); \
+#define vext_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4_t __ret; \
+ poly16x4_t __s0 = __p0; \
+ poly16x4_t __s1 = __p1; \
+ __ret = (poly16x4_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 5); \
__ret; \
})
#else
-#define vld1_p16_x3(__p0) __extension__ ({ \
- poly16x4x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 5); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vext_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4_t __ret; \
+ poly16x4_t __s0 = __p0; \
+ poly16x4_t __s1 = __p1; \
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (poly16x4_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 5); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_p8_x3(__p0) __extension__ ({ \
- poly8x16x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 36); \
+#define vextq_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16_t __ret; \
+ poly8x16_t __s0 = __p0; \
+ poly8x16_t __s1 = __p1; \
+ __ret = (poly8x16_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 36); \
__ret; \
})
#else
-#define vld1q_p8_x3(__p0) __extension__ ({ \
- poly8x16x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 36); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vextq_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16_t __ret; \
+ poly8x16_t __s0 = __p0; \
+ poly8x16_t __s1 = __p1; \
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly8x16_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 36); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_p16_x3(__p0) __extension__ ({ \
- poly16x8x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 37); \
+#define vextq_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8_t __ret; \
+ poly16x8_t __s0 = __p0; \
+ poly16x8_t __s1 = __p1; \
+ __ret = (poly16x8_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 37); \
__ret; \
})
#else
-#define vld1q_p16_x3(__p0) __extension__ ({ \
- poly16x8x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 37); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vextq_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8_t __ret; \
+ poly16x8_t __s0 = __p0; \
+ poly16x8_t __s1 = __p1; \
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly16x8_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 37); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_u8_x3(__p0) __extension__ ({ \
- uint8x16x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 48); \
+#define vextq_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ uint8x16_t __s1 = __p1; \
+ __ret = (uint8x16_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 48); \
__ret; \
})
#else
-#define vld1q_u8_x3(__p0) __extension__ ({ \
- uint8x16x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 48); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vextq_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ uint8x16_t __s1 = __p1; \
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x16_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 48); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_u32_x3(__p0) __extension__ ({ \
- uint32x4x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 50); \
+#define vextq_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ uint32x4_t __s1 = __p1; \
+ __ret = (uint32x4_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 50); \
__ret; \
})
#else
-#define vld1q_u32_x3(__p0) __extension__ ({ \
- uint32x4x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 50); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vextq_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ uint32x4_t __s1 = __p1; \
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (uint32x4_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 50); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_u64_x3(__p0) __extension__ ({ \
- uint64x2x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 51); \
+#define vextq_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ uint64x2_t __s1 = __p1; \
+ __ret = (uint64x2_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 51); \
__ret; \
})
#else
-#define vld1q_u64_x3(__p0) __extension__ ({ \
- uint64x2x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 51); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+#define vextq_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ uint64x2_t __s1 = __p1; \
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (uint64x2_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 51); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_u16_x3(__p0) __extension__ ({ \
- uint16x8x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 49); \
+#define vextq_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ uint16x8_t __s1 = __p1; \
+ __ret = (uint16x8_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 49); \
__ret; \
})
#else
-#define vld1q_u16_x3(__p0) __extension__ ({ \
- uint16x8x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 49); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vextq_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ uint16x8_t __s1 = __p1; \
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint16x8_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 49); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_s8_x3(__p0) __extension__ ({ \
- int8x16x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 32); \
+#define vextq_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x16_t __s0 = __p0; \
+ int8x16_t __s1 = __p1; \
+ __ret = (int8x16_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 32); \
__ret; \
})
#else
-#define vld1q_s8_x3(__p0) __extension__ ({ \
- int8x16x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 32); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vextq_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x16_t __s0 = __p0; \
+ int8x16_t __s1 = __p1; \
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x16_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 32); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_f32_x3(__p0) __extension__ ({ \
- float32x4x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 41); \
+#define vextq_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4_t __ret; \
+ float32x4_t __s0 = __p0; \
+ float32x4_t __s1 = __p1; \
+ __ret = (float32x4_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 41); \
__ret; \
})
#else
-#define vld1q_f32_x3(__p0) __extension__ ({ \
- float32x4x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 41); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vextq_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4_t __ret; \
+ float32x4_t __s0 = __p0; \
+ float32x4_t __s1 = __p1; \
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (float32x4_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 41); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_s32_x3(__p0) __extension__ ({ \
- int32x4x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 34); \
+#define vextq_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __s1 = __p1; \
+ __ret = (int32x4_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
__ret; \
})
#else
-#define vld1q_s32_x3(__p0) __extension__ ({ \
- int32x4x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 34); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vextq_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __s1 = __p1; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (int32x4_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_s64_x3(__p0) __extension__ ({ \
- int64x2x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 35); \
+#define vextq_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __s1 = __p1; \
+ __ret = (int64x2_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 35); \
__ret; \
})
#else
-#define vld1q_s64_x3(__p0) __extension__ ({ \
- int64x2x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 35); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+#define vextq_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __s1 = __p1; \
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (int64x2_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 35); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_s16_x3(__p0) __extension__ ({ \
- int16x8x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 33); \
+#define vextq_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __s1 = __p1; \
+ __ret = (int16x8_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
__ret; \
})
#else
-#define vld1q_s16_x3(__p0) __extension__ ({ \
- int16x8x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 33); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vextq_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __s1 = __p1; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int16x8_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_u8_x3(__p0) __extension__ ({ \
- uint8x8x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 16); \
+#define vext_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ uint8x8_t __s1 = __p1; \
+ __ret = (uint8x8_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 16); \
__ret; \
})
#else
-#define vld1_u8_x3(__p0) __extension__ ({ \
- uint8x8x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 16); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vext_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ uint8x8_t __s1 = __p1; \
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x8_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 16); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_u32_x3(__p0) __extension__ ({ \
- uint32x2x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 18); \
+#define vext_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ uint32x2_t __s1 = __p1; \
+ __ret = (uint32x2_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 18); \
__ret; \
})
#else
-#define vld1_u32_x3(__p0) __extension__ ({ \
- uint32x2x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 18); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+#define vext_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ uint32x2_t __s1 = __p1; \
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (uint32x2_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 18); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
-#define vld1_u64_x3(__p0) __extension__ ({ \
- uint64x1x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 19); \
+#define vext_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x1_t __ret; \
+ uint64x1_t __s0 = __p0; \
+ uint64x1_t __s1 = __p1; \
+ __ret = (uint64x1_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 19); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vld1_u16_x3(__p0) __extension__ ({ \
- uint16x4x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 17); \
+#define vext_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ uint16x4_t __s1 = __p1; \
+ __ret = (uint16x4_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 17); \
__ret; \
})
#else
-#define vld1_u16_x3(__p0) __extension__ ({ \
- uint16x4x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 17); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vext_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ uint16x4_t __s1 = __p1; \
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (uint16x4_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_s8_x3(__p0) __extension__ ({ \
- int8x8x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 0); \
+#define vext_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ int8x8_t __s1 = __p1; \
+ __ret = (int8x8_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 0); \
__ret; \
})
#else
-#define vld1_s8_x3(__p0) __extension__ ({ \
- int8x8x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 0); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vext_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ int8x8_t __s1 = __p1; \
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 0); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_f32_x3(__p0) __extension__ ({ \
- float32x2x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 9); \
+#define vext_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2_t __ret; \
+ float32x2_t __s0 = __p0; \
+ float32x2_t __s1 = __p1; \
+ __ret = (float32x2_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 9); \
__ret; \
})
#else
-#define vld1_f32_x3(__p0) __extension__ ({ \
- float32x2x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 9); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+#define vext_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2_t __ret; \
+ float32x2_t __s0 = __p0; \
+ float32x2_t __s1 = __p1; \
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (float32x2_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 9); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_s32_x3(__p0) __extension__ ({ \
- int32x2x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 2); \
+#define vext_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __s1 = __p1; \
+ __ret = (int32x2_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
__ret; \
})
#else
-#define vld1_s32_x3(__p0) __extension__ ({ \
- int32x2x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 2); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+#define vext_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __s1 = __p1; \
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (int32x2_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
-#define vld1_s64_x3(__p0) __extension__ ({ \
- int64x1x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 3); \
+#define vext_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x1_t __ret; \
+ int64x1_t __s0 = __p0; \
+ int64x1_t __s1 = __p1; \
+ __ret = (int64x1_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 3); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vld1_s16_x3(__p0) __extension__ ({ \
- int16x4x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 1); \
- __ret; \
-})
-#else
-#define vld1_s16_x3(__p0) __extension__ ({ \
- int16x4x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 1); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vext_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __s1 = __p1; \
+ __ret = (int16x4_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
+ __ret; \
+})
+#else
+#define vext_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __s1 = __p1; \
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (int16x4_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_p8_x4(__p0) __extension__ ({ \
- poly8x8x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 4); \
+#define vextq_f16(__p0, __p1, __p2) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __s1 = __p1; \
+ __ret = (float16x8_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 40); \
__ret; \
})
#else
-#define vld1_p8_x4(__p0) __extension__ ({ \
- poly8x8x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 4); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vextq_f16(__p0, __p1, __p2) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __s1 = __p1; \
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (float16x8_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 40); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_p16_x4(__p0) __extension__ ({ \
- poly16x4x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 5); \
+#define vext_f16(__p0, __p1, __p2) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __s1 = __p1; \
+ __ret = (float16x4_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 8); \
__ret; \
})
#else
-#define vld1_p16_x4(__p0) __extension__ ({ \
- poly16x4x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 5); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+#define vext_f16(__p0, __p1, __p2) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __s1 = __p1; \
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (float16x4_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 8); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_p8_x4(__p0) __extension__ ({ \
- poly8x16x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 36); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x8_t vget_high_p8(poly8x16_t __p0) {
+ poly8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 8, 9, 10, 11, 12, 13, 14, 15);
+ return __ret;
+}
#else
-#define vld1q_p8_x4(__p0) __extension__ ({ \
- poly8x16x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 36); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x8_t vget_high_p8(poly8x16_t __p0) {
+ poly8x8_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 8, 9, 10, 11, 12, 13, 14, 15);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t __noswap_vget_high_p8(poly8x16_t __p0) {
+ poly8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 8, 9, 10, 11, 12, 13, 14, 15);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_p16_x4(__p0) __extension__ ({ \
- poly16x8x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 37); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x4_t vget_high_p16(poly16x8_t __p0) {
+ poly16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+ return __ret;
+}
#else
-#define vld1q_p16_x4(__p0) __extension__ ({ \
- poly16x8x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 37); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x4_t vget_high_p16(poly16x8_t __p0) {
+ poly16x4_t __ret;
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 4, 5, 6, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_u8_x4(__p0) __extension__ ({ \
- uint8x16x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 48); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vget_high_u8(uint8x16_t __p0) {
+ uint8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 8, 9, 10, 11, 12, 13, 14, 15);
+ return __ret;
+}
#else
-#define vld1q_u8_x4(__p0) __extension__ ({ \
- uint8x16x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 48); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vget_high_u8(uint8x16_t __p0) {
+ uint8x8_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 8, 9, 10, 11, 12, 13, 14, 15);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t __noswap_vget_high_u8(uint8x16_t __p0) {
+ uint8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 8, 9, 10, 11, 12, 13, 14, 15);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_u32_x4(__p0) __extension__ ({ \
- uint32x4x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 50); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vget_high_u32(uint32x4_t __p0) {
+ uint32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 2, 3);
+ return __ret;
+}
#else
-#define vld1q_u32_x4(__p0) __extension__ ({ \
- uint32x4x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 50); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vget_high_u32(uint32x4_t __p0) {
+ uint32x2_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 2, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t __noswap_vget_high_u32(uint32x4_t __p0) {
+ uint32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 2, 3);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_u64_x4(__p0) __extension__ ({ \
- uint64x2x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 51); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x1_t vget_high_u64(uint64x2_t __p0) {
+ uint64x1_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1);
+ return __ret;
+}
#else
-#define vld1q_u64_x4(__p0) __extension__ ({ \
- uint64x2x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 51); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x1_t vget_high_u64(uint64x2_t __p0) {
+ uint64x1_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_u16_x4(__p0) __extension__ ({ \
- uint16x8x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 49); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vget_high_u16(uint16x8_t __p0) {
+ uint16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+ return __ret;
+}
#else
-#define vld1q_u16_x4(__p0) __extension__ ({ \
- uint16x8x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 49); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vget_high_u16(uint16x8_t __p0) {
+ uint16x4_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 4, 5, 6, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t __noswap_vget_high_u16(uint16x8_t __p0) {
+ uint16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_s8_x4(__p0) __extension__ ({ \
- int8x16x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 32); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vget_high_s8(int8x16_t __p0) {
+ int8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 8, 9, 10, 11, 12, 13, 14, 15);
+ return __ret;
+}
#else
-#define vld1q_s8_x4(__p0) __extension__ ({ \
- int8x16x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 32); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vget_high_s8(int8x16_t __p0) {
+ int8x8_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 8, 9, 10, 11, 12, 13, 14, 15);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t __noswap_vget_high_s8(int8x16_t __p0) {
+ int8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 8, 9, 10, 11, 12, 13, 14, 15);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_f32_x4(__p0) __extension__ ({ \
- float32x4x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 41); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vget_high_f32(float32x4_t __p0) {
+ float32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 2, 3);
+ return __ret;
+}
#else
-#define vld1q_f32_x4(__p0) __extension__ ({ \
- float32x4x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 41); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vget_high_f32(float32x4_t __p0) {
+ float32x2_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 2, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t __noswap_vget_high_f32(float32x4_t __p0) {
+ float32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 2, 3);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_s32_x4(__p0) __extension__ ({ \
- int32x4x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 34); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float16x4_t vget_high_f16(float16x8_t __p0) {
+ float16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+ return __ret;
+}
#else
-#define vld1q_s32_x4(__p0) __extension__ ({ \
- int32x4x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 34); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float16x4_t vget_high_f16(float16x8_t __p0) {
+ float16x4_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 4, 5, 6, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t __noswap_vget_high_f16(float16x8_t __p0) {
+ float16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_s64_x4(__p0) __extension__ ({ \
- int64x2x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 35); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vget_high_s32(int32x4_t __p0) {
+ int32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 2, 3);
+ return __ret;
+}
#else
-#define vld1q_s64_x4(__p0) __extension__ ({ \
- int64x2x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 35); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vget_high_s32(int32x4_t __p0) {
+ int32x2_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 2, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vget_high_s32(int32x4_t __p0) {
+ int32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 2, 3);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_s16_x4(__p0) __extension__ ({ \
- int16x8x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 33); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x1_t vget_high_s64(int64x2_t __p0) {
+ int64x1_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1);
+ return __ret;
+}
#else
-#define vld1q_s16_x4(__p0) __extension__ ({ \
- int16x8x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 33); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x1_t vget_high_s64(int64x2_t __p0) {
+ int64x1_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_u8_x4(__p0) __extension__ ({ \
- uint8x8x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 16); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vget_high_s16(int16x8_t __p0) {
+ int16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+ return __ret;
+}
#else
-#define vld1_u8_x4(__p0) __extension__ ({ \
- uint8x8x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 16); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vget_high_s16(int16x8_t __p0) {
+ int16x4_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 4, 5, 6, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vget_high_s16(int16x8_t __p0) {
+ int16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_u32_x4(__p0) __extension__ ({ \
- uint32x2x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 18); \
+#define vget_lane_p8(__p0, __p1) __extension__ ({ \
+ poly8_t __ret; \
+ poly8x8_t __s0 = __p0; \
+ __ret = (poly8_t) __builtin_neon_vget_lane_i8((poly8x8_t)__s0, __p1); \
__ret; \
})
#else
-#define vld1_u32_x4(__p0) __extension__ ({ \
- uint32x2x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 18); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+#define vget_lane_p8(__p0, __p1) __extension__ ({ \
+ poly8_t __ret; \
+ poly8x8_t __s0 = __p0; \
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly8_t) __builtin_neon_vget_lane_i8((poly8x8_t)__rev0, __p1); \
__ret; \
})
-#endif
-
-#define vld1_u64_x4(__p0) __extension__ ({ \
- uint64x1x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 19); \
+#define __noswap_vget_lane_p8(__p0, __p1) __extension__ ({ \
+ poly8_t __ret; \
+ poly8x8_t __s0 = __p0; \
+ __ret = (poly8_t) __builtin_neon_vget_lane_i8((poly8x8_t)__s0, __p1); \
__ret; \
})
+#endif
+
#ifdef __LITTLE_ENDIAN__
-#define vld1_u16_x4(__p0) __extension__ ({ \
- uint16x4x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 17); \
+#define vget_lane_p16(__p0, __p1) __extension__ ({ \
+ poly16_t __ret; \
+ poly16x4_t __s0 = __p0; \
+ __ret = (poly16_t) __builtin_neon_vget_lane_i16((poly16x4_t)__s0, __p1); \
__ret; \
})
#else
-#define vld1_u16_x4(__p0) __extension__ ({ \
- uint16x4x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 17); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+#define vget_lane_p16(__p0, __p1) __extension__ ({ \
+ poly16_t __ret; \
+ poly16x4_t __s0 = __p0; \
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (poly16_t) __builtin_neon_vget_lane_i16((poly16x4_t)__rev0, __p1); \
+ __ret; \
+})
+#define __noswap_vget_lane_p16(__p0, __p1) __extension__ ({ \
+ poly16_t __ret; \
+ poly16x4_t __s0 = __p0; \
+ __ret = (poly16_t) __builtin_neon_vget_lane_i16((poly16x4_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_s8_x4(__p0) __extension__ ({ \
- int8x8x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 0); \
+#define vgetq_lane_p8(__p0, __p1) __extension__ ({ \
+ poly8_t __ret; \
+ poly8x16_t __s0 = __p0; \
+ __ret = (poly8_t) __builtin_neon_vgetq_lane_i8((poly8x16_t)__s0, __p1); \
__ret; \
})
#else
-#define vld1_s8_x4(__p0) __extension__ ({ \
- int8x8x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 0); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vgetq_lane_p8(__p0, __p1) __extension__ ({ \
+ poly8_t __ret; \
+ poly8x16_t __s0 = __p0; \
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly8_t) __builtin_neon_vgetq_lane_i8((poly8x16_t)__rev0, __p1); \
+ __ret; \
+})
+#define __noswap_vgetq_lane_p8(__p0, __p1) __extension__ ({ \
+ poly8_t __ret; \
+ poly8x16_t __s0 = __p0; \
+ __ret = (poly8_t) __builtin_neon_vgetq_lane_i8((poly8x16_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_f32_x4(__p0) __extension__ ({ \
- float32x2x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 9); \
+#define vgetq_lane_p16(__p0, __p1) __extension__ ({ \
+ poly16_t __ret; \
+ poly16x8_t __s0 = __p0; \
+ __ret = (poly16_t) __builtin_neon_vgetq_lane_i16((poly16x8_t)__s0, __p1); \
__ret; \
})
#else
-#define vld1_f32_x4(__p0) __extension__ ({ \
- float32x2x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 9); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+#define vgetq_lane_p16(__p0, __p1) __extension__ ({ \
+ poly16_t __ret; \
+ poly16x8_t __s0 = __p0; \
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly16_t) __builtin_neon_vgetq_lane_i16((poly16x8_t)__rev0, __p1); \
+ __ret; \
+})
+#define __noswap_vgetq_lane_p16(__p0, __p1) __extension__ ({ \
+ poly16_t __ret; \
+ poly16x8_t __s0 = __p0; \
+ __ret = (poly16_t) __builtin_neon_vgetq_lane_i16((poly16x8_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_s32_x4(__p0) __extension__ ({ \
- int32x2x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 2); \
+#define vgetq_lane_u8(__p0, __p1) __extension__ ({ \
+ uint8_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ __ret = (uint8_t) __builtin_neon_vgetq_lane_i8((int8x16_t)__s0, __p1); \
__ret; \
})
#else
-#define vld1_s32_x4(__p0) __extension__ ({ \
- int32x2x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 2); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
- __ret; \
-})
-#endif
-
-#define vld1_s64_x4(__p0) __extension__ ({ \
- int64x1x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 3); \
- __ret; \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vld1_s16_x4(__p0) __extension__ ({ \
- int16x4x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 1); \
+#define vgetq_lane_u8(__p0, __p1) __extension__ ({ \
+ uint8_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8_t) __builtin_neon_vgetq_lane_i8((int8x16_t)__rev0, __p1); \
__ret; \
})
-#else
-#define vld1_s16_x4(__p0) __extension__ ({ \
- int16x4x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 1); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+#define __noswap_vgetq_lane_u8(__p0, __p1) __extension__ ({ \
+ uint8_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ __ret = (uint8_t) __builtin_neon_vgetq_lane_i8((int8x16_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_p8(__p0) __extension__ ({ \
- poly8x8x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 4); \
+#define vgetq_lane_u32(__p0, __p1) __extension__ ({ \
+ uint32_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ __ret = (uint32_t) __builtin_neon_vgetq_lane_i32((int32x4_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2_p8(__p0) __extension__ ({ \
- poly8x8x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 4); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vld2_p16(__p0) __extension__ ({ \
- poly16x4x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 5); \
+#define vgetq_lane_u32(__p0, __p1) __extension__ ({ \
+ uint32_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint32_t) __builtin_neon_vgetq_lane_i32((int32x4_t)__rev0, __p1); \
__ret; \
})
-#else
-#define vld2_p16(__p0) __extension__ ({ \
- poly16x4x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 5); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+#define __noswap_vgetq_lane_u32(__p0, __p1) __extension__ ({ \
+ uint32_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ __ret = (uint32_t) __builtin_neon_vgetq_lane_i32((int32x4_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_p8(__p0) __extension__ ({ \
- poly8x16x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 36); \
+#define vgetq_lane_u64(__p0, __p1) __extension__ ({ \
+ uint64_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ __ret = (uint64_t) __builtin_neon_vgetq_lane_i64((int64x2_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2q_p8(__p0) __extension__ ({ \
- poly8x16x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 36); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vld2q_p16(__p0) __extension__ ({ \
- poly16x8x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 37); \
+#define vgetq_lane_u64(__p0, __p1) __extension__ ({ \
+ uint64_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint64_t) __builtin_neon_vgetq_lane_i64((int64x2_t)__rev0, __p1); \
__ret; \
})
-#else
-#define vld2q_p16(__p0) __extension__ ({ \
- poly16x8x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 37); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define __noswap_vgetq_lane_u64(__p0, __p1) __extension__ ({ \
+ uint64_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ __ret = (uint64_t) __builtin_neon_vgetq_lane_i64((int64x2_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_u8(__p0) __extension__ ({ \
- uint8x16x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 48); \
+#define vgetq_lane_u16(__p0, __p1) __extension__ ({ \
+ uint16_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ __ret = (uint16_t) __builtin_neon_vgetq_lane_i16((int16x8_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2q_u8(__p0) __extension__ ({ \
- uint8x16x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 48); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vld2q_u32(__p0) __extension__ ({ \
- uint32x4x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 50); \
+#define vgetq_lane_u16(__p0, __p1) __extension__ ({ \
+ uint16_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint16_t) __builtin_neon_vgetq_lane_i16((int16x8_t)__rev0, __p1); \
__ret; \
})
-#else
-#define vld2q_u32(__p0) __extension__ ({ \
- uint32x4x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 50); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+#define __noswap_vgetq_lane_u16(__p0, __p1) __extension__ ({ \
+ uint16_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ __ret = (uint16_t) __builtin_neon_vgetq_lane_i16((int16x8_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_u16(__p0) __extension__ ({ \
- uint16x8x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 49); \
+#define vgetq_lane_s8(__p0, __p1) __extension__ ({ \
+ int8_t __ret; \
+ int8x16_t __s0 = __p0; \
+ __ret = (int8_t) __builtin_neon_vgetq_lane_i8((int8x16_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2q_u16(__p0) __extension__ ({ \
- uint16x8x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 49); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vgetq_lane_s8(__p0, __p1) __extension__ ({ \
+ int8_t __ret; \
+ int8x16_t __s0 = __p0; \
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8_t) __builtin_neon_vgetq_lane_i8((int8x16_t)__rev0, __p1); \
+ __ret; \
+})
+#define __noswap_vgetq_lane_s8(__p0, __p1) __extension__ ({ \
+ int8_t __ret; \
+ int8x16_t __s0 = __p0; \
+ __ret = (int8_t) __builtin_neon_vgetq_lane_i8((int8x16_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_s8(__p0) __extension__ ({ \
- int8x16x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 32); \
+#define vgetq_lane_f32(__p0, __p1) __extension__ ({ \
+ float32_t __ret; \
+ float32x4_t __s0 = __p0; \
+ __ret = (float32_t) __builtin_neon_vgetq_lane_f32((float32x4_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2q_s8(__p0) __extension__ ({ \
- int8x16x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 32); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vgetq_lane_f32(__p0, __p1) __extension__ ({ \
+ float32_t __ret; \
+ float32x4_t __s0 = __p0; \
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (float32_t) __builtin_neon_vgetq_lane_f32((float32x4_t)__rev0, __p1); \
+ __ret; \
+})
+#define __noswap_vgetq_lane_f32(__p0, __p1) __extension__ ({ \
+ float32_t __ret; \
+ float32x4_t __s0 = __p0; \
+ __ret = (float32_t) __builtin_neon_vgetq_lane_f32((float32x4_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_f32(__p0) __extension__ ({ \
- float32x4x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 41); \
+#define vgetq_lane_s32(__p0, __p1) __extension__ ({ \
+ int32_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (int32_t) __builtin_neon_vgetq_lane_i32((int32x4_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2q_f32(__p0) __extension__ ({ \
- float32x4x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 41); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+#define vgetq_lane_s32(__p0, __p1) __extension__ ({ \
+ int32_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (int32_t) __builtin_neon_vgetq_lane_i32((int32x4_t)__rev0, __p1); \
+ __ret; \
+})
+#define __noswap_vgetq_lane_s32(__p0, __p1) __extension__ ({ \
+ int32_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (int32_t) __builtin_neon_vgetq_lane_i32((int32x4_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_s32(__p0) __extension__ ({ \
- int32x4x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 34); \
+#define vgetq_lane_s64(__p0, __p1) __extension__ ({ \
+ int64_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (int64_t) __builtin_neon_vgetq_lane_i64((int64x2_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2q_s32(__p0) __extension__ ({ \
- int32x4x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 34); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+#define vgetq_lane_s64(__p0, __p1) __extension__ ({ \
+ int64_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (int64_t) __builtin_neon_vgetq_lane_i64((int64x2_t)__rev0, __p1); \
+ __ret; \
+})
+#define __noswap_vgetq_lane_s64(__p0, __p1) __extension__ ({ \
+ int64_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (int64_t) __builtin_neon_vgetq_lane_i64((int64x2_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_s16(__p0) __extension__ ({ \
- int16x8x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 33); \
+#define vgetq_lane_s16(__p0, __p1) __extension__ ({ \
+ int16_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (int16_t) __builtin_neon_vgetq_lane_i16((int16x8_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2q_s16(__p0) __extension__ ({ \
- int16x8x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 33); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vgetq_lane_s16(__p0, __p1) __extension__ ({ \
+ int16_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int16_t) __builtin_neon_vgetq_lane_i16((int16x8_t)__rev0, __p1); \
+ __ret; \
+})
+#define __noswap_vgetq_lane_s16(__p0, __p1) __extension__ ({ \
+ int16_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (int16_t) __builtin_neon_vgetq_lane_i16((int16x8_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_u8(__p0) __extension__ ({ \
- uint8x8x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 16); \
+#define vget_lane_u8(__p0, __p1) __extension__ ({ \
+ uint8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ __ret = (uint8_t) __builtin_neon_vget_lane_i8((int8x8_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2_u8(__p0) __extension__ ({ \
- uint8x8x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 16); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vget_lane_u8(__p0, __p1) __extension__ ({ \
+ uint8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8_t) __builtin_neon_vget_lane_i8((int8x8_t)__rev0, __p1); \
+ __ret; \
+})
+#define __noswap_vget_lane_u8(__p0, __p1) __extension__ ({ \
+ uint8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ __ret = (uint8_t) __builtin_neon_vget_lane_i8((int8x8_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_u32(__p0) __extension__ ({ \
- uint32x2x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 18); \
+#define vget_lane_u32(__p0, __p1) __extension__ ({ \
+ uint32_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ __ret = (uint32_t) __builtin_neon_vget_lane_i32((int32x2_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2_u32(__p0) __extension__ ({ \
- uint32x2x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 18); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+#define vget_lane_u32(__p0, __p1) __extension__ ({ \
+ uint32_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint32_t) __builtin_neon_vget_lane_i32((int32x2_t)__rev0, __p1); \
+ __ret; \
+})
+#define __noswap_vget_lane_u32(__p0, __p1) __extension__ ({ \
+ uint32_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ __ret = (uint32_t) __builtin_neon_vget_lane_i32((int32x2_t)__s0, __p1); \
__ret; \
})
#endif
-#define vld2_u64(__p0) __extension__ ({ \
- uint64x1x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 19); \
+#define vget_lane_u64(__p0, __p1) __extension__ ({ \
+ uint64_t __ret; \
+ uint64x1_t __s0 = __p0; \
+ __ret = (uint64_t) __builtin_neon_vget_lane_i64((int64x1_t)__s0, __p1); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vld2_u16(__p0) __extension__ ({ \
- uint16x4x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 17); \
+#define vget_lane_u16(__p0, __p1) __extension__ ({ \
+ uint16_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ __ret = (uint16_t) __builtin_neon_vget_lane_i16((int16x4_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2_u16(__p0) __extension__ ({ \
- uint16x4x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 17); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+#define vget_lane_u16(__p0, __p1) __extension__ ({ \
+ uint16_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint16_t) __builtin_neon_vget_lane_i16((int16x4_t)__rev0, __p1); \
+ __ret; \
+})
+#define __noswap_vget_lane_u16(__p0, __p1) __extension__ ({ \
+ uint16_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ __ret = (uint16_t) __builtin_neon_vget_lane_i16((int16x4_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_s8(__p0) __extension__ ({ \
- int8x8x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 0); \
+#define vget_lane_s8(__p0, __p1) __extension__ ({ \
+ int8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ __ret = (int8_t) __builtin_neon_vget_lane_i8((int8x8_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2_s8(__p0) __extension__ ({ \
- int8x8x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 0); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vget_lane_s8(__p0, __p1) __extension__ ({ \
+ int8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8_t) __builtin_neon_vget_lane_i8((int8x8_t)__rev0, __p1); \
+ __ret; \
+})
+#define __noswap_vget_lane_s8(__p0, __p1) __extension__ ({ \
+ int8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ __ret = (int8_t) __builtin_neon_vget_lane_i8((int8x8_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_f32(__p0) __extension__ ({ \
- float32x2x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 9); \
+#define vget_lane_f32(__p0, __p1) __extension__ ({ \
+ float32_t __ret; \
+ float32x2_t __s0 = __p0; \
+ __ret = (float32_t) __builtin_neon_vget_lane_f32((float32x2_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2_f32(__p0) __extension__ ({ \
- float32x2x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 9); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+#define vget_lane_f32(__p0, __p1) __extension__ ({ \
+ float32_t __ret; \
+ float32x2_t __s0 = __p0; \
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (float32_t) __builtin_neon_vget_lane_f32((float32x2_t)__rev0, __p1); \
+ __ret; \
+})
+#define __noswap_vget_lane_f32(__p0, __p1) __extension__ ({ \
+ float32_t __ret; \
+ float32x2_t __s0 = __p0; \
+ __ret = (float32_t) __builtin_neon_vget_lane_f32((float32x2_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_s32(__p0) __extension__ ({ \
- int32x2x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 2); \
+#define vget_lane_s32(__p0, __p1) __extension__ ({ \
+ int32_t __ret; \
+ int32x2_t __s0 = __p0; \
+ __ret = (int32_t) __builtin_neon_vget_lane_i32((int32x2_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2_s32(__p0) __extension__ ({ \
- int32x2x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 2); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+#define vget_lane_s32(__p0, __p1) __extension__ ({ \
+ int32_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (int32_t) __builtin_neon_vget_lane_i32((int32x2_t)__rev0, __p1); \
+ __ret; \
+})
+#define __noswap_vget_lane_s32(__p0, __p1) __extension__ ({ \
+ int32_t __ret; \
+ int32x2_t __s0 = __p0; \
+ __ret = (int32_t) __builtin_neon_vget_lane_i32((int32x2_t)__s0, __p1); \
__ret; \
})
#endif
-#define vld2_s64(__p0) __extension__ ({ \
- int64x1x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 3); \
+#define vget_lane_s64(__p0, __p1) __extension__ ({ \
+ int64_t __ret; \
+ int64x1_t __s0 = __p0; \
+ __ret = (int64_t) __builtin_neon_vget_lane_i64((int64x1_t)__s0, __p1); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vld2_s16(__p0) __extension__ ({ \
- int16x4x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 1); \
+#define vget_lane_s16(__p0, __p1) __extension__ ({ \
+ int16_t __ret; \
+ int16x4_t __s0 = __p0; \
+ __ret = (int16_t) __builtin_neon_vget_lane_i16((int16x4_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2_s16(__p0) __extension__ ({ \
- int16x4x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 1); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+#define vget_lane_s16(__p0, __p1) __extension__ ({ \
+ int16_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (int16_t) __builtin_neon_vget_lane_i16((int16x4_t)__rev0, __p1); \
+ __ret; \
+})
+#define __noswap_vget_lane_s16(__p0, __p1) __extension__ ({ \
+ int16_t __ret; \
+ int16x4_t __s0 = __p0; \
+ __ret = (int16_t) __builtin_neon_vget_lane_i16((int16x4_t)__s0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_dup_p8(__p0) __extension__ ({ \
- poly8x8x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 4); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x8_t vget_low_p8(poly8x16_t __p0) {
+ poly8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3, 4, 5, 6, 7);
+ return __ret;
+}
#else
-#define vld2_dup_p8(__p0) __extension__ ({ \
- poly8x8x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 4); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x8_t vget_low_p8(poly8x16_t __p0) {
+ poly8x8_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3, 4, 5, 6, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_dup_p16(__p0) __extension__ ({ \
- poly16x4x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 5); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x4_t vget_low_p16(poly16x8_t __p0) {
+ poly16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3);
+ return __ret;
+}
#else
-#define vld2_dup_p16(__p0) __extension__ ({ \
- poly16x4x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 5); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x4_t vget_low_p16(poly16x8_t __p0) {
+ poly16x4_t __ret;
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_dup_p8(__p0) __extension__ ({ \
- poly8x16x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 36); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vget_low_u8(uint8x16_t __p0) {
+ uint8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3, 4, 5, 6, 7);
+ return __ret;
+}
#else
-#define vld2q_dup_p8(__p0) __extension__ ({ \
- poly8x16x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 36); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vget_low_u8(uint8x16_t __p0) {
+ uint8x8_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3, 4, 5, 6, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_dup_p16(__p0) __extension__ ({ \
- poly16x8x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 37); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vget_low_u32(uint32x4_t __p0) {
+ uint32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 0, 1);
+ return __ret;
+}
#else
-#define vld2q_dup_p16(__p0) __extension__ ({ \
- poly16x8x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 37); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vget_low_u32(uint32x4_t __p0) {
+ uint32x2_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_dup_u8(__p0) __extension__ ({ \
- uint8x16x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 48); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x1_t vget_low_u64(uint64x2_t __p0) {
+ uint64x1_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 0);
+ return __ret;
+}
#else
-#define vld2q_dup_u8(__p0) __extension__ ({ \
- uint8x16x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 48); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x1_t vget_low_u64(uint64x2_t __p0) {
+ uint64x1_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_dup_u32(__p0) __extension__ ({ \
- uint32x4x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 50); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vget_low_u16(uint16x8_t __p0) {
+ uint16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3);
+ return __ret;
+}
#else
-#define vld2q_dup_u32(__p0) __extension__ ({ \
- uint32x4x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 50); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vget_low_u16(uint16x8_t __p0) {
+ uint16x4_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_dup_u64(__p0) __extension__ ({ \
- uint64x2x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 51); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vget_low_s8(int8x16_t __p0) {
+ int8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3, 4, 5, 6, 7);
+ return __ret;
+}
#else
-#define vld2q_dup_u64(__p0) __extension__ ({ \
- uint64x2x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 51); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vget_low_s8(int8x16_t __p0) {
+ int8x8_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3, 4, 5, 6, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_dup_u16(__p0) __extension__ ({ \
- uint16x8x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 49); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vget_low_f32(float32x4_t __p0) {
+ float32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 0, 1);
+ return __ret;
+}
#else
-#define vld2q_dup_u16(__p0) __extension__ ({ \
- uint16x8x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 49); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vget_low_f32(float32x4_t __p0) {
+ float32x2_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_dup_s8(__p0) __extension__ ({ \
- int8x16x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 32); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float16x4_t vget_low_f16(float16x8_t __p0) {
+ float16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3);
+ return __ret;
+}
#else
-#define vld2q_dup_s8(__p0) __extension__ ({ \
- int8x16x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 32); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float16x4_t vget_low_f16(float16x8_t __p0) {
+ float16x4_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_dup_f32(__p0) __extension__ ({ \
- float32x4x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 41); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vget_low_s32(int32x4_t __p0) {
+ int32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 0, 1);
+ return __ret;
+}
#else
-#define vld2q_dup_f32(__p0) __extension__ ({ \
- float32x4x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 41); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vget_low_s32(int32x4_t __p0) {
+ int32x2_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_dup_s32(__p0) __extension__ ({ \
- int32x4x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 34); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x1_t vget_low_s64(int64x2_t __p0) {
+ int64x1_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 0);
+ return __ret;
+}
#else
-#define vld2q_dup_s32(__p0) __extension__ ({ \
- int32x4x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 34); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x1_t vget_low_s64(int64x2_t __p0) {
+ int64x1_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_dup_s64(__p0) __extension__ ({ \
- int64x2x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 35); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vget_low_s16(int16x8_t __p0) {
+ int16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3);
+ return __ret;
+}
#else
-#define vld2q_dup_s64(__p0) __extension__ ({ \
- int64x2x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 35); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vget_low_s16(int16x8_t __p0) {
+ int16x4_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_dup_s16(__p0) __extension__ ({ \
- int16x8x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 33); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vhaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ return __ret;
+}
#else
-#define vld2q_dup_s16(__p0) __extension__ ({ \
- int16x8x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 33); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vhaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_dup_u8(__p0) __extension__ ({ \
- uint8x8x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 16); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vhaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+ return __ret;
+}
#else
-#define vld2_dup_u8(__p0) __extension__ ({ \
- uint8x8x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 16); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vhaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_dup_u32(__p0) __extension__ ({ \
- uint32x2x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 18); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vhaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ return __ret;
+}
#else
-#define vld2_dup_u32(__p0) __extension__ ({ \
- uint32x2x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 18); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vhaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vld2_dup_u64(__p0) __extension__ ({ \
- uint64x1x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 19); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vld2_dup_u16(__p0) __extension__ ({ \
- uint16x4x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 17); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vhaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+ return __ret;
+}
#else
-#define vld2_dup_u16(__p0) __extension__ ({ \
- uint16x4x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 17); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vhaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_dup_s8(__p0) __extension__ ({ \
- int8x8x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vhaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+ return __ret;
+}
#else
-#define vld2_dup_s8(__p0) __extension__ ({ \
- int8x8x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 0); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vhaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_dup_f32(__p0) __extension__ ({ \
- float32x2x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 9); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vhaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ return __ret;
+}
#else
-#define vld2_dup_f32(__p0) __extension__ ({ \
- float32x2x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 9); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vhaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_dup_s32(__p0) __extension__ ({ \
- int32x2x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vhadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ return __ret;
+}
#else
-#define vld2_dup_s32(__p0) __extension__ ({ \
- int32x2x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 2); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vhadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vld2_dup_s64(__p0) __extension__ ({ \
- int64x1x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 3); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vld2_dup_s16(__p0) __extension__ ({ \
- int16x4x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vhadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ return __ret;
+}
#else
-#define vld2_dup_s16(__p0) __extension__ ({ \
- int16x4x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 1); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vhadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8x2_t __ret; \
- poly8x8x2_t __s1 = __p1; \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 4); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vhadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ return __ret;
+}
#else
-#define vld2_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8x2_t __ret; \
- poly8x8x2_t __s1 = __p1; \
- poly8x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 4); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vhadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4x2_t __ret; \
- poly16x4x2_t __s1 = __p1; \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 5); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vhadd_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+ return __ret;
+}
#else
-#define vld2_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4x2_t __ret; \
- poly16x4x2_t __s1 = __p1; \
- poly16x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 5); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vhadd_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8x2_t __ret; \
- poly16x8x2_t __s1 = __p1; \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 37); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vhadd_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+ return __ret;
+}
#else
-#define vld2q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8x2_t __ret; \
- poly16x8x2_t __s1 = __p1; \
- poly16x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 37); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vhadd_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4x2_t __ret; \
- uint32x4x2_t __s1 = __p1; \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 50); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vhadd_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ return __ret;
+}
#else
-#define vld2q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4x2_t __ret; \
- uint32x4x2_t __s1 = __p1; \
- uint32x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 50); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vhadd_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8x2_t __ret; \
- uint16x8x2_t __s1 = __p1; \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 49); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vhsubq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vhsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ return __ret;
+}
#else
-#define vld2q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8x2_t __ret; \
- uint16x8x2_t __s1 = __p1; \
- uint16x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 49); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vhsubq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vhsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x4x2_t __ret; \
- float32x4x2_t __s1 = __p1; \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 41); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vhsubq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vhsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+ return __ret;
+}
#else
-#define vld2q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x4x2_t __ret; \
- float32x4x2_t __s1 = __p1; \
- float32x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 41); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vhsubq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vhsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4x2_t __ret; \
- int32x4x2_t __s1 = __p1; \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 34); \
+__ai __attribute__((target("neon"))) uint16x8_t vhsubq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vhsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vhsubq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vhsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vhsubq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vhsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vhsubq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vhsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vhsubq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vhsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vhsubq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vhsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vhsubq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vhsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vhsubq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vhsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vhsub_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vhsub_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vhsub_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vhsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vhsub_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vhsub_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vhsub_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vhsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vhsub_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vhsub_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vhsub_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vhsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vhsub_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vhsub_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vhsub_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vhsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vhsub_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vhsub_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vhsub_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vhsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vhsub_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vhsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_p8(__p0) __extension__ ({ \
+ poly8x8_t __ret; \
+ __ret = (poly8x8_t) __builtin_neon_vld1_v(__p0, 4); \
__ret; \
})
#else
-#define vld2q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4x2_t __ret; \
- int32x4x2_t __s1 = __p1; \
- int32x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 34); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+#define vld1_p8(__p0) __extension__ ({ \
+ poly8x8_t __ret; \
+ __ret = (poly8x8_t) __builtin_neon_vld1_v(__p0, 4); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8x2_t __ret; \
- int16x8x2_t __s1 = __p1; \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 33); \
+#define vld1_p16(__p0) __extension__ ({ \
+ poly16x4_t __ret; \
+ __ret = (poly16x4_t) __builtin_neon_vld1_v(__p0, 5); \
__ret; \
})
#else
-#define vld2q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8x2_t __ret; \
- int16x8x2_t __s1 = __p1; \
- int16x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 33); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1_p16(__p0) __extension__ ({ \
+ poly16x4_t __ret; \
+ __ret = (poly16x4_t) __builtin_neon_vld1_v(__p0, 5); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8x2_t __ret; \
- uint8x8x2_t __s1 = __p1; \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 16); \
+#define vld1q_p8(__p0) __extension__ ({ \
+ poly8x16_t __ret; \
+ __ret = (poly8x16_t) __builtin_neon_vld1q_v(__p0, 36); \
__ret; \
})
#else
-#define vld2_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8x2_t __ret; \
- uint8x8x2_t __s1 = __p1; \
- uint8x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 16); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1q_p8(__p0) __extension__ ({ \
+ poly8x16_t __ret; \
+ __ret = (poly8x16_t) __builtin_neon_vld1q_v(__p0, 36); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2x2_t __ret; \
- uint32x2x2_t __s1 = __p1; \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 18); \
+#define vld1q_p16(__p0) __extension__ ({ \
+ poly16x8_t __ret; \
+ __ret = (poly16x8_t) __builtin_neon_vld1q_v(__p0, 37); \
__ret; \
})
#else
-#define vld2_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2x2_t __ret; \
- uint32x2x2_t __s1 = __p1; \
- uint32x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 18); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+#define vld1q_p16(__p0) __extension__ ({ \
+ poly16x8_t __ret; \
+ __ret = (poly16x8_t) __builtin_neon_vld1q_v(__p0, 37); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4x2_t __ret; \
- uint16x4x2_t __s1 = __p1; \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 17); \
+#define vld1q_u8(__p0) __extension__ ({ \
+ uint8x16_t __ret; \
+ __ret = (uint8x16_t) __builtin_neon_vld1q_v(__p0, 48); \
__ret; \
})
#else
-#define vld2_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4x2_t __ret; \
- uint16x4x2_t __s1 = __p1; \
- uint16x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 17); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+#define vld1q_u8(__p0) __extension__ ({ \
+ uint8x16_t __ret; \
+ __ret = (uint8x16_t) __builtin_neon_vld1q_v(__p0, 48); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8x2_t __ret; \
- int8x8x2_t __s1 = __p1; \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 0); \
+#define vld1q_u32(__p0) __extension__ ({ \
+ uint32x4_t __ret; \
+ __ret = (uint32x4_t) __builtin_neon_vld1q_v(__p0, 50); \
__ret; \
})
#else
-#define vld2_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8x2_t __ret; \
- int8x8x2_t __s1 = __p1; \
- int8x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 0); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1q_u32(__p0) __extension__ ({ \
+ uint32x4_t __ret; \
+ __ret = (uint32x4_t) __builtin_neon_vld1q_v(__p0, 50); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x2x2_t __ret; \
- float32x2x2_t __s1 = __p1; \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 9); \
+#define vld1q_u64(__p0) __extension__ ({ \
+ uint64x2_t __ret; \
+ __ret = (uint64x2_t) __builtin_neon_vld1q_v(__p0, 51); \
__ret; \
})
#else
-#define vld2_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x2x2_t __ret; \
- float32x2x2_t __s1 = __p1; \
- float32x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 9); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+#define vld1q_u64(__p0) __extension__ ({ \
+ uint64x2_t __ret; \
+ __ret = (uint64x2_t) __builtin_neon_vld1q_v(__p0, 51); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2x2_t __ret; \
- int32x2x2_t __s1 = __p1; \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 2); \
+#define vld1q_u16(__p0) __extension__ ({ \
+ uint16x8_t __ret; \
+ __ret = (uint16x8_t) __builtin_neon_vld1q_v(__p0, 49); \
__ret; \
})
#else
-#define vld2_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2x2_t __ret; \
- int32x2x2_t __s1 = __p1; \
- int32x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 2); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+#define vld1q_u16(__p0) __extension__ ({ \
+ uint16x8_t __ret; \
+ __ret = (uint16x8_t) __builtin_neon_vld1q_v(__p0, 49); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4x2_t __ret; \
- int16x4x2_t __s1 = __p1; \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 1); \
+#define vld1q_s8(__p0) __extension__ ({ \
+ int8x16_t __ret; \
+ __ret = (int8x16_t) __builtin_neon_vld1q_v(__p0, 32); \
__ret; \
})
#else
-#define vld2_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4x2_t __ret; \
- int16x4x2_t __s1 = __p1; \
- int16x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 1); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+#define vld1q_s8(__p0) __extension__ ({ \
+ int8x16_t __ret; \
+ __ret = (int8x16_t) __builtin_neon_vld1q_v(__p0, 32); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_p8(__p0) __extension__ ({ \
- poly8x8x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 4); \
+#define vld1q_f32(__p0) __extension__ ({ \
+ float32x4_t __ret; \
+ __ret = (float32x4_t) __builtin_neon_vld1q_v(__p0, 41); \
__ret; \
})
#else
-#define vld3_p8(__p0) __extension__ ({ \
- poly8x8x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 4); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1q_f32(__p0) __extension__ ({ \
+ float32x4_t __ret; \
+ __ret = (float32x4_t) __builtin_neon_vld1q_v(__p0, 41); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_p16(__p0) __extension__ ({ \
- poly16x4x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 5); \
+#define vld1q_s32(__p0) __extension__ ({ \
+ int32x4_t __ret; \
+ __ret = (int32x4_t) __builtin_neon_vld1q_v(__p0, 34); \
__ret; \
})
#else
-#define vld3_p16(__p0) __extension__ ({ \
- poly16x4x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 5); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vld1q_s32(__p0) __extension__ ({ \
+ int32x4_t __ret; \
+ __ret = (int32x4_t) __builtin_neon_vld1q_v(__p0, 34); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_p8(__p0) __extension__ ({ \
- poly8x16x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 36); \
+#define vld1q_s64(__p0) __extension__ ({ \
+ int64x2_t __ret; \
+ __ret = (int64x2_t) __builtin_neon_vld1q_v(__p0, 35); \
__ret; \
})
#else
-#define vld3q_p8(__p0) __extension__ ({ \
- poly8x16x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 36); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1q_s64(__p0) __extension__ ({ \
+ int64x2_t __ret; \
+ __ret = (int64x2_t) __builtin_neon_vld1q_v(__p0, 35); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_p16(__p0) __extension__ ({ \
- poly16x8x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 37); \
+#define vld1q_s16(__p0) __extension__ ({ \
+ int16x8_t __ret; \
+ __ret = (int16x8_t) __builtin_neon_vld1q_v(__p0, 33); \
__ret; \
})
#else
-#define vld3q_p16(__p0) __extension__ ({ \
- poly16x8x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 37); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1q_s16(__p0) __extension__ ({ \
+ int16x8_t __ret; \
+ __ret = (int16x8_t) __builtin_neon_vld1q_v(__p0, 33); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_u8(__p0) __extension__ ({ \
- uint8x16x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 48); \
+#define vld1_u8(__p0) __extension__ ({ \
+ uint8x8_t __ret; \
+ __ret = (uint8x8_t) __builtin_neon_vld1_v(__p0, 16); \
__ret; \
})
#else
-#define vld3q_u8(__p0) __extension__ ({ \
- uint8x16x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 48); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1_u8(__p0) __extension__ ({ \
+ uint8x8_t __ret; \
+ __ret = (uint8x8_t) __builtin_neon_vld1_v(__p0, 16); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_u32(__p0) __extension__ ({ \
- uint32x4x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 50); \
+#define vld1_u32(__p0) __extension__ ({ \
+ uint32x2_t __ret; \
+ __ret = (uint32x2_t) __builtin_neon_vld1_v(__p0, 18); \
__ret; \
})
#else
-#define vld3q_u32(__p0) __extension__ ({ \
- uint32x4x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 50); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vld1_u32(__p0) __extension__ ({ \
+ uint32x2_t __ret; \
+ __ret = (uint32x2_t) __builtin_neon_vld1_v(__p0, 18); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
+#define vld1_u64(__p0) __extension__ ({ \
+ uint64x1_t __ret; \
+ __ret = (uint64x1_t) __builtin_neon_vld1_v(__p0, 19); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vld3q_u16(__p0) __extension__ ({ \
- uint16x8x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 49); \
+#define vld1_u16(__p0) __extension__ ({ \
+ uint16x4_t __ret; \
+ __ret = (uint16x4_t) __builtin_neon_vld1_v(__p0, 17); \
__ret; \
})
#else
-#define vld3q_u16(__p0) __extension__ ({ \
- uint16x8x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 49); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1_u16(__p0) __extension__ ({ \
+ uint16x4_t __ret; \
+ __ret = (uint16x4_t) __builtin_neon_vld1_v(__p0, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_s8(__p0) __extension__ ({ \
- int8x16x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 32); \
+#define vld1_s8(__p0) __extension__ ({ \
+ int8x8_t __ret; \
+ __ret = (int8x8_t) __builtin_neon_vld1_v(__p0, 0); \
__ret; \
})
#else
-#define vld3q_s8(__p0) __extension__ ({ \
- int8x16x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 32); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1_s8(__p0) __extension__ ({ \
+ int8x8_t __ret; \
+ __ret = (int8x8_t) __builtin_neon_vld1_v(__p0, 0); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_f32(__p0) __extension__ ({ \
- float32x4x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 41); \
+#define vld1_f32(__p0) __extension__ ({ \
+ float32x2_t __ret; \
+ __ret = (float32x2_t) __builtin_neon_vld1_v(__p0, 9); \
__ret; \
})
#else
-#define vld3q_f32(__p0) __extension__ ({ \
- float32x4x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 41); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vld1_f32(__p0) __extension__ ({ \
+ float32x2_t __ret; \
+ __ret = (float32x2_t) __builtin_neon_vld1_v(__p0, 9); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_s32(__p0) __extension__ ({ \
- int32x4x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 34); \
+#define vld1_s32(__p0) __extension__ ({ \
+ int32x2_t __ret; \
+ __ret = (int32x2_t) __builtin_neon_vld1_v(__p0, 2); \
__ret; \
})
#else
-#define vld3q_s32(__p0) __extension__ ({ \
- int32x4x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 34); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vld1_s32(__p0) __extension__ ({ \
+ int32x2_t __ret; \
+ __ret = (int32x2_t) __builtin_neon_vld1_v(__p0, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
+#define vld1_s64(__p0) __extension__ ({ \
+ int64x1_t __ret; \
+ __ret = (int64x1_t) __builtin_neon_vld1_v(__p0, 3); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vld3q_s16(__p0) __extension__ ({ \
- int16x8x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 33); \
+#define vld1_s16(__p0) __extension__ ({ \
+ int16x4_t __ret; \
+ __ret = (int16x4_t) __builtin_neon_vld1_v(__p0, 1); \
__ret; \
})
#else
-#define vld3q_s16(__p0) __extension__ ({ \
- int16x8x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 33); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1_s16(__p0) __extension__ ({ \
+ int16x4_t __ret; \
+ __ret = (int16x4_t) __builtin_neon_vld1_v(__p0, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_u8(__p0) __extension__ ({ \
- uint8x8x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 16); \
+#define vld1_dup_p8(__p0) __extension__ ({ \
+ poly8x8_t __ret; \
+ __ret = (poly8x8_t) __builtin_neon_vld1_dup_v(__p0, 4); \
__ret; \
})
#else
-#define vld3_u8(__p0) __extension__ ({ \
- uint8x8x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 16); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1_dup_p8(__p0) __extension__ ({ \
+ poly8x8_t __ret; \
+ __ret = (poly8x8_t) __builtin_neon_vld1_dup_v(__p0, 4); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_u32(__p0) __extension__ ({ \
- uint32x2x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 18); \
+#define vld1_dup_p16(__p0) __extension__ ({ \
+ poly16x4_t __ret; \
+ __ret = (poly16x4_t) __builtin_neon_vld1_dup_v(__p0, 5); \
__ret; \
})
#else
-#define vld3_u32(__p0) __extension__ ({ \
- uint32x2x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 18); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+#define vld1_dup_p16(__p0) __extension__ ({ \
+ poly16x4_t __ret; \
+ __ret = (poly16x4_t) __builtin_neon_vld1_dup_v(__p0, 5); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
-#define vld3_u64(__p0) __extension__ ({ \
- uint64x1x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 19); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vld3_u16(__p0) __extension__ ({ \
- uint16x4x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 17); \
+#define vld1q_dup_p8(__p0) __extension__ ({ \
+ poly8x16_t __ret; \
+ __ret = (poly8x16_t) __builtin_neon_vld1q_dup_v(__p0, 36); \
__ret; \
})
#else
-#define vld3_u16(__p0) __extension__ ({ \
- uint16x4x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 17); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vld1q_dup_p8(__p0) __extension__ ({ \
+ poly8x16_t __ret; \
+ __ret = (poly8x16_t) __builtin_neon_vld1q_dup_v(__p0, 36); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_s8(__p0) __extension__ ({ \
- int8x8x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 0); \
+#define vld1q_dup_p16(__p0) __extension__ ({ \
+ poly16x8_t __ret; \
+ __ret = (poly16x8_t) __builtin_neon_vld1q_dup_v(__p0, 37); \
__ret; \
})
#else
-#define vld3_s8(__p0) __extension__ ({ \
- int8x8x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 0); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1q_dup_p16(__p0) __extension__ ({ \
+ poly16x8_t __ret; \
+ __ret = (poly16x8_t) __builtin_neon_vld1q_dup_v(__p0, 37); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_f32(__p0) __extension__ ({ \
- float32x2x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 9); \
+#define vld1q_dup_u8(__p0) __extension__ ({ \
+ uint8x16_t __ret; \
+ __ret = (uint8x16_t) __builtin_neon_vld1q_dup_v(__p0, 48); \
__ret; \
})
#else
-#define vld3_f32(__p0) __extension__ ({ \
- float32x2x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 9); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+#define vld1q_dup_u8(__p0) __extension__ ({ \
+ uint8x16_t __ret; \
+ __ret = (uint8x16_t) __builtin_neon_vld1q_dup_v(__p0, 48); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_s32(__p0) __extension__ ({ \
- int32x2x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 2); \
+#define vld1q_dup_u32(__p0) __extension__ ({ \
+ uint32x4_t __ret; \
+ __ret = (uint32x4_t) __builtin_neon_vld1q_dup_v(__p0, 50); \
__ret; \
})
#else
-#define vld3_s32(__p0) __extension__ ({ \
- int32x2x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 2); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+#define vld1q_dup_u32(__p0) __extension__ ({ \
+ uint32x4_t __ret; \
+ __ret = (uint32x4_t) __builtin_neon_vld1q_dup_v(__p0, 50); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
-#define vld3_s64(__p0) __extension__ ({ \
- int64x1x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 3); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vld3_s16(__p0) __extension__ ({ \
- int16x4x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 1); \
+#define vld1q_dup_u64(__p0) __extension__ ({ \
+ uint64x2_t __ret; \
+ __ret = (uint64x2_t) __builtin_neon_vld1q_dup_v(__p0, 51); \
__ret; \
})
#else
-#define vld3_s16(__p0) __extension__ ({ \
- int16x4x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 1); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vld1q_dup_u64(__p0) __extension__ ({ \
+ uint64x2_t __ret; \
+ __ret = (uint64x2_t) __builtin_neon_vld1q_dup_v(__p0, 51); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_dup_p8(__p0) __extension__ ({ \
- poly8x8x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 4); \
+#define vld1q_dup_u16(__p0) __extension__ ({ \
+ uint16x8_t __ret; \
+ __ret = (uint16x8_t) __builtin_neon_vld1q_dup_v(__p0, 49); \
__ret; \
})
#else
-#define vld3_dup_p8(__p0) __extension__ ({ \
- poly8x8x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 4); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1q_dup_u16(__p0) __extension__ ({ \
+ uint16x8_t __ret; \
+ __ret = (uint16x8_t) __builtin_neon_vld1q_dup_v(__p0, 49); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_dup_p16(__p0) __extension__ ({ \
- poly16x4x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 5); \
+#define vld1q_dup_s8(__p0) __extension__ ({ \
+ int8x16_t __ret; \
+ __ret = (int8x16_t) __builtin_neon_vld1q_dup_v(__p0, 32); \
__ret; \
})
#else
-#define vld3_dup_p16(__p0) __extension__ ({ \
- poly16x4x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 5); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vld1q_dup_s8(__p0) __extension__ ({ \
+ int8x16_t __ret; \
+ __ret = (int8x16_t) __builtin_neon_vld1q_dup_v(__p0, 32); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_dup_p8(__p0) __extension__ ({ \
- poly8x16x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 36); \
+#define vld1q_dup_f32(__p0) __extension__ ({ \
+ float32x4_t __ret; \
+ __ret = (float32x4_t) __builtin_neon_vld1q_dup_v(__p0, 41); \
__ret; \
})
#else
-#define vld3q_dup_p8(__p0) __extension__ ({ \
- poly8x16x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 36); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1q_dup_f32(__p0) __extension__ ({ \
+ float32x4_t __ret; \
+ __ret = (float32x4_t) __builtin_neon_vld1q_dup_v(__p0, 41); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_dup_p16(__p0) __extension__ ({ \
- poly16x8x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 37); \
+#define vld1q_dup_s32(__p0) __extension__ ({ \
+ int32x4_t __ret; \
+ __ret = (int32x4_t) __builtin_neon_vld1q_dup_v(__p0, 34); \
__ret; \
})
#else
-#define vld3q_dup_p16(__p0) __extension__ ({ \
- poly16x8x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 37); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1q_dup_s32(__p0) __extension__ ({ \
+ int32x4_t __ret; \
+ __ret = (int32x4_t) __builtin_neon_vld1q_dup_v(__p0, 34); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_dup_u8(__p0) __extension__ ({ \
- uint8x16x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 48); \
+#define vld1q_dup_s64(__p0) __extension__ ({ \
+ int64x2_t __ret; \
+ __ret = (int64x2_t) __builtin_neon_vld1q_dup_v(__p0, 35); \
__ret; \
})
#else
-#define vld3q_dup_u8(__p0) __extension__ ({ \
- uint8x16x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 48); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1q_dup_s64(__p0) __extension__ ({ \
+ int64x2_t __ret; \
+ __ret = (int64x2_t) __builtin_neon_vld1q_dup_v(__p0, 35); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_dup_u32(__p0) __extension__ ({ \
- uint32x4x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 50); \
+#define vld1q_dup_s16(__p0) __extension__ ({ \
+ int16x8_t __ret; \
+ __ret = (int16x8_t) __builtin_neon_vld1q_dup_v(__p0, 33); \
__ret; \
})
#else
-#define vld3q_dup_u32(__p0) __extension__ ({ \
- uint32x4x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 50); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vld1q_dup_s16(__p0) __extension__ ({ \
+ int16x8_t __ret; \
+ __ret = (int16x8_t) __builtin_neon_vld1q_dup_v(__p0, 33); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_dup_u64(__p0) __extension__ ({ \
- uint64x2x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 51); \
+#define vld1_dup_u8(__p0) __extension__ ({ \
+ uint8x8_t __ret; \
+ __ret = (uint8x8_t) __builtin_neon_vld1_dup_v(__p0, 16); \
__ret; \
})
#else
-#define vld3q_dup_u64(__p0) __extension__ ({ \
- uint64x2x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 51); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+#define vld1_dup_u8(__p0) __extension__ ({ \
+ uint8x8_t __ret; \
+ __ret = (uint8x8_t) __builtin_neon_vld1_dup_v(__p0, 16); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_dup_u16(__p0) __extension__ ({ \
- uint16x8x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 49); \
+#define vld1_dup_u32(__p0) __extension__ ({ \
+ uint32x2_t __ret; \
+ __ret = (uint32x2_t) __builtin_neon_vld1_dup_v(__p0, 18); \
__ret; \
})
#else
-#define vld3q_dup_u16(__p0) __extension__ ({ \
- uint16x8x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 49); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1_dup_u32(__p0) __extension__ ({ \
+ uint32x2_t __ret; \
+ __ret = (uint32x2_t) __builtin_neon_vld1_dup_v(__p0, 18); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
+#define vld1_dup_u64(__p0) __extension__ ({ \
+ uint64x1_t __ret; \
+ __ret = (uint64x1_t) __builtin_neon_vld1_dup_v(__p0, 19); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vld3q_dup_s8(__p0) __extension__ ({ \
- int8x16x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 32); \
+#define vld1_dup_u16(__p0) __extension__ ({ \
+ uint16x4_t __ret; \
+ __ret = (uint16x4_t) __builtin_neon_vld1_dup_v(__p0, 17); \
__ret; \
})
#else
-#define vld3q_dup_s8(__p0) __extension__ ({ \
- int8x16x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 32); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1_dup_u16(__p0) __extension__ ({ \
+ uint16x4_t __ret; \
+ __ret = (uint16x4_t) __builtin_neon_vld1_dup_v(__p0, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_dup_f32(__p0) __extension__ ({ \
- float32x4x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 41); \
+#define vld1_dup_s8(__p0) __extension__ ({ \
+ int8x8_t __ret; \
+ __ret = (int8x8_t) __builtin_neon_vld1_dup_v(__p0, 0); \
__ret; \
})
#else
-#define vld3q_dup_f32(__p0) __extension__ ({ \
- float32x4x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 41); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vld1_dup_s8(__p0) __extension__ ({ \
+ int8x8_t __ret; \
+ __ret = (int8x8_t) __builtin_neon_vld1_dup_v(__p0, 0); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_dup_s32(__p0) __extension__ ({ \
- int32x4x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 34); \
+#define vld1_dup_f32(__p0) __extension__ ({ \
+ float32x2_t __ret; \
+ __ret = (float32x2_t) __builtin_neon_vld1_dup_v(__p0, 9); \
__ret; \
})
#else
-#define vld3q_dup_s32(__p0) __extension__ ({ \
- int32x4x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 34); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vld1_dup_f32(__p0) __extension__ ({ \
+ float32x2_t __ret; \
+ __ret = (float32x2_t) __builtin_neon_vld1_dup_v(__p0, 9); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_dup_s64(__p0) __extension__ ({ \
- int64x2x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 35); \
+#define vld1_dup_s32(__p0) __extension__ ({ \
+ int32x2_t __ret; \
+ __ret = (int32x2_t) __builtin_neon_vld1_dup_v(__p0, 2); \
__ret; \
})
#else
-#define vld3q_dup_s64(__p0) __extension__ ({ \
- int64x2x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 35); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+#define vld1_dup_s32(__p0) __extension__ ({ \
+ int32x2_t __ret; \
+ __ret = (int32x2_t) __builtin_neon_vld1_dup_v(__p0, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
+#define vld1_dup_s64(__p0) __extension__ ({ \
+ int64x1_t __ret; \
+ __ret = (int64x1_t) __builtin_neon_vld1_dup_v(__p0, 3); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vld3q_dup_s16(__p0) __extension__ ({ \
- int16x8x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 33); \
+#define vld1_dup_s16(__p0) __extension__ ({ \
+ int16x4_t __ret; \
+ __ret = (int16x4_t) __builtin_neon_vld1_dup_v(__p0, 1); \
__ret; \
})
#else
-#define vld3q_dup_s16(__p0) __extension__ ({ \
- int16x8x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 33); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1_dup_s16(__p0) __extension__ ({ \
+ int16x4_t __ret; \
+ __ret = (int16x4_t) __builtin_neon_vld1_dup_v(__p0, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_dup_u8(__p0) __extension__ ({ \
- uint8x8x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 16); \
+#define vld1_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8_t __ret; \
+ poly8x8_t __s1 = __p1; \
+ __ret = (poly8x8_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 4); \
__ret; \
})
#else
-#define vld3_dup_u8(__p0) __extension__ ({ \
- uint8x8x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 16); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8_t __ret; \
+ poly8x8_t __s1 = __p1; \
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly8x8_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 4); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_dup_u32(__p0) __extension__ ({ \
- uint32x2x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 18); \
+#define vld1_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4_t __ret; \
+ poly16x4_t __s1 = __p1; \
+ __ret = (poly16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 5); \
__ret; \
})
#else
-#define vld3_dup_u32(__p0) __extension__ ({ \
- uint32x2x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 18); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+#define vld1_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4_t __ret; \
+ poly16x4_t __s1 = __p1; \
+ poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (poly16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 5); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
-#define vld3_dup_u64(__p0) __extension__ ({ \
- uint64x1x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 19); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vld3_dup_u16(__p0) __extension__ ({ \
- uint16x4x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 17); \
+#define vld1q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16_t __ret; \
+ poly8x16_t __s1 = __p1; \
+ __ret = (poly8x16_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 36); \
__ret; \
})
#else
-#define vld3_dup_u16(__p0) __extension__ ({ \
- uint16x4x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 17); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vld1q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16_t __ret; \
+ poly8x16_t __s1 = __p1; \
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly8x16_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 36); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_dup_s8(__p0) __extension__ ({ \
- int8x8x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 0); \
+#define vld1q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8_t __ret; \
+ poly16x8_t __s1 = __p1; \
+ __ret = (poly16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 37); \
__ret; \
})
#else
-#define vld3_dup_s8(__p0) __extension__ ({ \
- int8x8x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 0); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8_t __ret; \
+ poly16x8_t __s1 = __p1; \
+ poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 37); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_dup_f32(__p0) __extension__ ({ \
- float32x2x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 9); \
+#define vld1q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x16_t __s1 = __p1; \
+ __ret = (uint8x16_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 48); \
__ret; \
})
#else
-#define vld3_dup_f32(__p0) __extension__ ({ \
- float32x2x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 9); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+#define vld1q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x16_t __s1 = __p1; \
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x16_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 48); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_dup_s32(__p0) __extension__ ({ \
- int32x2x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 2); \
+#define vld1q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x4_t __s1 = __p1; \
+ __ret = (uint32x4_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 50); \
__ret; \
})
#else
-#define vld3_dup_s32(__p0) __extension__ ({ \
- int32x2x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 2); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+#define vld1q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x4_t __s1 = __p1; \
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (uint32x4_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 50); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
-#define vld3_dup_s64(__p0) __extension__ ({ \
- int64x1x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 3); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vld3_dup_s16(__p0) __extension__ ({ \
- int16x4x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 1); \
+#define vld1q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x2_t __s1 = __p1; \
+ __ret = (uint64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 51); \
__ret; \
})
#else
-#define vld3_dup_s16(__p0) __extension__ ({ \
- int16x4x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 1); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vld1q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x2_t __s1 = __p1; \
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (uint64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 51); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8x3_t __ret; \
- poly8x8x3_t __s1 = __p1; \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 4); \
+#define vld1q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x8_t __s1 = __p1; \
+ __ret = (uint16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 49); \
__ret; \
})
#else
-#define vld3_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8x3_t __ret; \
- poly8x8x3_t __s1 = __p1; \
- poly8x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 4); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x8_t __s1 = __p1; \
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 49); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4x3_t __ret; \
- poly16x4x3_t __s1 = __p1; \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 5); \
+#define vld1q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x16_t __s1 = __p1; \
+ __ret = (int8x16_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 32); \
__ret; \
})
#else
-#define vld3_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4x3_t __ret; \
- poly16x4x3_t __s1 = __p1; \
- poly16x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 5); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vld1q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x16_t __s1 = __p1; \
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x16_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 32); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8x3_t __ret; \
- poly16x8x3_t __s1 = __p1; \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 37); \
+#define vld1q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4_t __ret; \
+ float32x4_t __s1 = __p1; \
+ __ret = (float32x4_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 41); \
__ret; \
})
#else
-#define vld3q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8x3_t __ret; \
- poly16x8x3_t __s1 = __p1; \
- poly16x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 37); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4_t __ret; \
+ float32x4_t __s1 = __p1; \
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (float32x4_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 41); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4x3_t __ret; \
- uint32x4x3_t __s1 = __p1; \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 50); \
+#define vld1q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s1 = __p1; \
+ __ret = (int32x4_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 34); \
__ret; \
})
#else
-#define vld3q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4x3_t __ret; \
- uint32x4x3_t __s1 = __p1; \
- uint32x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 50); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vld1q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s1 = __p1; \
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (int32x4_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 34); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8x3_t __ret; \
- uint16x8x3_t __s1 = __p1; \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 49); \
+#define vld1q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x2_t __s1 = __p1; \
+ __ret = (int64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 35); \
__ret; \
})
#else
-#define vld3q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8x3_t __ret; \
- uint16x8x3_t __s1 = __p1; \
- uint16x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 49); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x2_t __s1 = __p1; \
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (int64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 35); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x4x3_t __ret; \
- float32x4x3_t __s1 = __p1; \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 41); \
+#define vld1q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s1 = __p1; \
+ __ret = (int16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 33); \
__ret; \
})
#else
-#define vld3q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x4x3_t __ret; \
- float32x4x3_t __s1 = __p1; \
- float32x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 41); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vld1q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s1 = __p1; \
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 33); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4x3_t __ret; \
- int32x4x3_t __s1 = __p1; \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 34); \
+#define vld1_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x8_t __s1 = __p1; \
+ __ret = (uint8x8_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 16); \
__ret; \
})
#else
-#define vld3q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4x3_t __ret; \
- int32x4x3_t __s1 = __p1; \
- int32x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 34); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vld1_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x8_t __s1 = __p1; \
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x8_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 16); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8x3_t __ret; \
- int16x8x3_t __s1 = __p1; \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 33); \
+#define vld1_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x2_t __s1 = __p1; \
+ __ret = (uint32x2_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 18); \
__ret; \
})
#else
-#define vld3q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8x3_t __ret; \
- int16x8x3_t __s1 = __p1; \
- int16x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 33); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x2_t __s1 = __p1; \
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (uint32x2_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 18); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
+#define vld1_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x1_t __ret; \
+ uint64x1_t __s1 = __p1; \
+ __ret = (uint64x1_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 19); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vld3_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8x3_t __ret; \
- uint8x8x3_t __s1 = __p1; \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 16); \
+#define vld1_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x4_t __s1 = __p1; \
+ __ret = (uint16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 17); \
__ret; \
})
#else
-#define vld3_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8x3_t __ret; \
- uint8x8x3_t __s1 = __p1; \
- uint8x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 16); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x4_t __s1 = __p1; \
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (uint16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2x3_t __ret; \
- uint32x2x3_t __s1 = __p1; \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 18); \
+#define vld1_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x8_t __s1 = __p1; \
+ __ret = (int8x8_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 0); \
__ret; \
})
#else
-#define vld3_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2x3_t __ret; \
- uint32x2x3_t __s1 = __p1; \
- uint32x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 18); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+#define vld1_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x8_t __s1 = __p1; \
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 0); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4x3_t __ret; \
- uint16x4x3_t __s1 = __p1; \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 17); \
+#define vld1_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2_t __ret; \
+ float32x2_t __s1 = __p1; \
+ __ret = (float32x2_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 9); \
__ret; \
})
#else
-#define vld3_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4x3_t __ret; \
- uint16x4x3_t __s1 = __p1; \
- uint16x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 17); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+#define vld1_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2_t __ret; \
+ float32x2_t __s1 = __p1; \
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (float32x2_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 9); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8x3_t __ret; \
- int8x8x3_t __s1 = __p1; \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 0); \
+#define vld1_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s1 = __p1; \
+ __ret = (int32x2_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 2); \
__ret; \
})
#else
-#define vld3_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8x3_t __ret; \
- int8x8x3_t __s1 = __p1; \
- int8x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 0); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld1_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s1 = __p1; \
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (int32x2_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
+#define vld1_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x1_t __ret; \
+ int64x1_t __s1 = __p1; \
+ __ret = (int64x1_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 3); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vld3_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x2x3_t __ret; \
- float32x2x3_t __s1 = __p1; \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 9); \
+#define vld1_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s1 = __p1; \
+ __ret = (int16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 1); \
__ret; \
})
#else
-#define vld3_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x2x3_t __ret; \
- float32x2x3_t __s1 = __p1; \
- float32x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 9); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+#define vld1_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s1 = __p1; \
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (int16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2x3_t __ret; \
- int32x2x3_t __s1 = __p1; \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 2); \
+#define vld1_p8_x2(__p0) __extension__ ({ \
+ poly8x8x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 4); \
__ret; \
})
#else
-#define vld3_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2x3_t __ret; \
- int32x2x3_t __s1 = __p1; \
- int32x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 2); \
+#define vld1_p8_x2(__p0) __extension__ ({ \
+ poly8x8x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 4); \
\
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4x3_t __ret; \
- int16x4x3_t __s1 = __p1; \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 1); \
+#define vld1_p16_x2(__p0) __extension__ ({ \
+ poly16x4x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 5); \
__ret; \
})
#else
-#define vld3_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4x3_t __ret; \
- int16x4x3_t __s1 = __p1; \
- int16x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 1); \
+#define vld1_p16_x2(__p0) __extension__ ({ \
+ poly16x4x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 5); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_p8(__p0) __extension__ ({ \
- poly8x8x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 4); \
+#define vld1q_p8_x2(__p0) __extension__ ({ \
+ poly8x16x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 36); \
__ret; \
})
#else
-#define vld4_p8(__p0) __extension__ ({ \
- poly8x8x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 4); \
+#define vld1q_p8_x2(__p0) __extension__ ({ \
+ poly8x16x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 36); \
\
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_p16(__p0) __extension__ ({ \
- poly16x4x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 5); \
+#define vld1q_p16_x2(__p0) __extension__ ({ \
+ poly16x8x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 37); \
__ret; \
})
#else
-#define vld4_p16(__p0) __extension__ ({ \
- poly16x4x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 5); \
+#define vld1q_p16_x2(__p0) __extension__ ({ \
+ poly16x8x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 37); \
\
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_p8(__p0) __extension__ ({ \
- poly8x16x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 36); \
+#define vld1q_u8_x2(__p0) __extension__ ({ \
+ uint8x16x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 48); \
__ret; \
})
#else
-#define vld4q_p8(__p0) __extension__ ({ \
- poly8x16x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 36); \
+#define vld1q_u8_x2(__p0) __extension__ ({ \
+ uint8x16x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 48); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_p16(__p0) __extension__ ({ \
- poly16x8x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 37); \
+#define vld1q_u32_x2(__p0) __extension__ ({ \
+ uint32x4x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 50); \
__ret; \
})
#else
-#define vld4q_p16(__p0) __extension__ ({ \
- poly16x8x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 37); \
+#define vld1q_u32_x2(__p0) __extension__ ({ \
+ uint32x4x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 50); \
\
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_u8(__p0) __extension__ ({ \
- uint8x16x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 48); \
+#define vld1q_u64_x2(__p0) __extension__ ({ \
+ uint64x2x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 51); \
__ret; \
})
#else
-#define vld4q_u8(__p0) __extension__ ({ \
- uint8x16x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 48); \
+#define vld1q_u64_x2(__p0) __extension__ ({ \
+ uint64x2x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 51); \
\
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_u32(__p0) __extension__ ({ \
- uint32x4x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 50); \
+#define vld1q_u16_x2(__p0) __extension__ ({ \
+ uint16x8x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 49); \
__ret; \
})
#else
-#define vld4q_u32(__p0) __extension__ ({ \
- uint32x4x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 50); \
+#define vld1q_u16_x2(__p0) __extension__ ({ \
+ uint16x8x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 49); \
\
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_u16(__p0) __extension__ ({ \
- uint16x8x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 49); \
+#define vld1q_s8_x2(__p0) __extension__ ({ \
+ int8x16x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 32); \
__ret; \
})
#else
-#define vld4q_u16(__p0) __extension__ ({ \
- uint16x8x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 49); \
+#define vld1q_s8_x2(__p0) __extension__ ({ \
+ int8x16x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 32); \
\
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_s8(__p0) __extension__ ({ \
- int8x16x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 32); \
+#define vld1q_f32_x2(__p0) __extension__ ({ \
+ float32x4x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 41); \
__ret; \
})
#else
-#define vld4q_s8(__p0) __extension__ ({ \
- int8x16x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 32); \
+#define vld1q_f32_x2(__p0) __extension__ ({ \
+ float32x4x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 41); \
\
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_f32(__p0) __extension__ ({ \
- float32x4x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 41); \
+#define vld1q_s32_x2(__p0) __extension__ ({ \
+ int32x4x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 34); \
__ret; \
})
#else
-#define vld4q_f32(__p0) __extension__ ({ \
- float32x4x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 41); \
+#define vld1q_s32_x2(__p0) __extension__ ({ \
+ int32x4x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 34); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_s32(__p0) __extension__ ({ \
- int32x4x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 34); \
+#define vld1q_s64_x2(__p0) __extension__ ({ \
+ int64x2x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 35); \
__ret; \
})
#else
-#define vld4q_s32(__p0) __extension__ ({ \
- int32x4x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 34); \
+#define vld1q_s64_x2(__p0) __extension__ ({ \
+ int64x2x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 35); \
\
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_s16(__p0) __extension__ ({ \
- int16x8x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 33); \
+#define vld1q_s16_x2(__p0) __extension__ ({ \
+ int16x8x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 33); \
__ret; \
})
#else
-#define vld4q_s16(__p0) __extension__ ({ \
- int16x8x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 33); \
+#define vld1q_s16_x2(__p0) __extension__ ({ \
+ int16x8x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 33); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_u8(__p0) __extension__ ({ \
- uint8x8x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 16); \
+#define vld1_u8_x2(__p0) __extension__ ({ \
+ uint8x8x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 16); \
__ret; \
})
#else
-#define vld4_u8(__p0) __extension__ ({ \
- uint8x8x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 16); \
+#define vld1_u8_x2(__p0) __extension__ ({ \
+ uint8x8x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 16); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_u32(__p0) __extension__ ({ \
- uint32x2x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 18); \
+#define vld1_u32_x2(__p0) __extension__ ({ \
+ uint32x2x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 18); \
__ret; \
})
#else
-#define vld4_u32(__p0) __extension__ ({ \
- uint32x2x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 18); \
+#define vld1_u32_x2(__p0) __extension__ ({ \
+ uint32x2x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 18); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
__ret; \
})
#endif
-#define vld4_u64(__p0) __extension__ ({ \
- uint64x1x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 19); \
+#define vld1_u64_x2(__p0) __extension__ ({ \
+ uint64x1x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 19); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vld4_u16(__p0) __extension__ ({ \
- uint16x4x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 17); \
+#define vld1_u16_x2(__p0) __extension__ ({ \
+ uint16x4x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 17); \
__ret; \
})
#else
-#define vld4_u16(__p0) __extension__ ({ \
- uint16x4x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 17); \
+#define vld1_u16_x2(__p0) __extension__ ({ \
+ uint16x4x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 17); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_s8(__p0) __extension__ ({ \
- int8x8x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 0); \
+#define vld1_s8_x2(__p0) __extension__ ({ \
+ int8x8x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 0); \
__ret; \
})
#else
-#define vld4_s8(__p0) __extension__ ({ \
- int8x8x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 0); \
+#define vld1_s8_x2(__p0) __extension__ ({ \
+ int8x8x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 0); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_f32(__p0) __extension__ ({ \
- float32x2x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 9); \
+#define vld1_f32_x2(__p0) __extension__ ({ \
+ float32x2x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 9); \
__ret; \
})
#else
-#define vld4_f32(__p0) __extension__ ({ \
- float32x2x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 9); \
+#define vld1_f32_x2(__p0) __extension__ ({ \
+ float32x2x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 9); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_s32(__p0) __extension__ ({ \
- int32x2x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 2); \
+#define vld1_s32_x2(__p0) __extension__ ({ \
+ int32x2x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 2); \
__ret; \
})
#else
-#define vld4_s32(__p0) __extension__ ({ \
- int32x2x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 2); \
+#define vld1_s32_x2(__p0) __extension__ ({ \
+ int32x2x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 2); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
__ret; \
})
#endif
-#define vld4_s64(__p0) __extension__ ({ \
- int64x1x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 3); \
+#define vld1_s64_x2(__p0) __extension__ ({ \
+ int64x1x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 3); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vld4_s16(__p0) __extension__ ({ \
- int16x4x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 1); \
+#define vld1_s16_x2(__p0) __extension__ ({ \
+ int16x4x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 1); \
__ret; \
})
#else
-#define vld4_s16(__p0) __extension__ ({ \
- int16x4x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 1); \
+#define vld1_s16_x2(__p0) __extension__ ({ \
+ int16x4x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 1); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_dup_p8(__p0) __extension__ ({ \
- poly8x8x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 4); \
+#define vld1_p8_x3(__p0) __extension__ ({ \
+ poly8x8x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 4); \
__ret; \
})
#else
-#define vld4_dup_p8(__p0) __extension__ ({ \
- poly8x8x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 4); \
+#define vld1_p8_x3(__p0) __extension__ ({ \
+ poly8x8x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 4); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_dup_p16(__p0) __extension__ ({ \
- poly16x4x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 5); \
+#define vld1_p16_x3(__p0) __extension__ ({ \
+ poly16x4x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 5); \
__ret; \
})
#else
-#define vld4_dup_p16(__p0) __extension__ ({ \
- poly16x4x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 5); \
+#define vld1_p16_x3(__p0) __extension__ ({ \
+ poly16x4x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 5); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_dup_p8(__p0) __extension__ ({ \
- poly8x16x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 36); \
+#define vld1q_p8_x3(__p0) __extension__ ({ \
+ poly8x16x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 36); \
__ret; \
})
#else
-#define vld4q_dup_p8(__p0) __extension__ ({ \
- poly8x16x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 36); \
+#define vld1q_p8_x3(__p0) __extension__ ({ \
+ poly8x16x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 36); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_dup_p16(__p0) __extension__ ({ \
- poly16x8x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 37); \
+#define vld1q_p16_x3(__p0) __extension__ ({ \
+ poly16x8x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 37); \
__ret; \
})
#else
-#define vld4q_dup_p16(__p0) __extension__ ({ \
- poly16x8x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 37); \
+#define vld1q_p16_x3(__p0) __extension__ ({ \
+ poly16x8x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 37); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_dup_u8(__p0) __extension__ ({ \
- uint8x16x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 48); \
+#define vld1q_u8_x3(__p0) __extension__ ({ \
+ uint8x16x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 48); \
__ret; \
})
#else
-#define vld4q_dup_u8(__p0) __extension__ ({ \
- uint8x16x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 48); \
+#define vld1q_u8_x3(__p0) __extension__ ({ \
+ uint8x16x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 48); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_dup_u32(__p0) __extension__ ({ \
- uint32x4x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 50); \
+#define vld1q_u32_x3(__p0) __extension__ ({ \
+ uint32x4x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 50); \
__ret; \
})
#else
-#define vld4q_dup_u32(__p0) __extension__ ({ \
- uint32x4x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 50); \
+#define vld1q_u32_x3(__p0) __extension__ ({ \
+ uint32x4x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 50); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_dup_u64(__p0) __extension__ ({ \
- uint64x2x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 51); \
+#define vld1q_u64_x3(__p0) __extension__ ({ \
+ uint64x2x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 51); \
__ret; \
})
#else
-#define vld4q_dup_u64(__p0) __extension__ ({ \
- uint64x2x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 51); \
+#define vld1q_u64_x3(__p0) __extension__ ({ \
+ uint64x2x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 51); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_dup_u16(__p0) __extension__ ({ \
- uint16x8x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 49); \
+#define vld1q_u16_x3(__p0) __extension__ ({ \
+ uint16x8x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 49); \
__ret; \
})
#else
-#define vld4q_dup_u16(__p0) __extension__ ({ \
- uint16x8x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 49); \
+#define vld1q_u16_x3(__p0) __extension__ ({ \
+ uint16x8x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 49); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_dup_s8(__p0) __extension__ ({ \
- int8x16x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 32); \
+#define vld1q_s8_x3(__p0) __extension__ ({ \
+ int8x16x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 32); \
__ret; \
})
#else
-#define vld4q_dup_s8(__p0) __extension__ ({ \
- int8x16x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 32); \
+#define vld1q_s8_x3(__p0) __extension__ ({ \
+ int8x16x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 32); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_dup_f32(__p0) __extension__ ({ \
- float32x4x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 41); \
+#define vld1q_f32_x3(__p0) __extension__ ({ \
+ float32x4x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 41); \
__ret; \
})
#else
-#define vld4q_dup_f32(__p0) __extension__ ({ \
- float32x4x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 41); \
+#define vld1q_f32_x3(__p0) __extension__ ({ \
+ float32x4x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 41); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_dup_s32(__p0) __extension__ ({ \
- int32x4x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 34); \
+#define vld1q_s32_x3(__p0) __extension__ ({ \
+ int32x4x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 34); \
__ret; \
})
#else
-#define vld4q_dup_s32(__p0) __extension__ ({ \
- int32x4x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 34); \
+#define vld1q_s32_x3(__p0) __extension__ ({ \
+ int32x4x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 34); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_dup_s64(__p0) __extension__ ({ \
- int64x2x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 35); \
+#define vld1q_s64_x3(__p0) __extension__ ({ \
+ int64x2x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 35); \
__ret; \
})
#else
-#define vld4q_dup_s64(__p0) __extension__ ({ \
- int64x2x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 35); \
+#define vld1q_s64_x3(__p0) __extension__ ({ \
+ int64x2x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 35); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_dup_s16(__p0) __extension__ ({ \
- int16x8x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 33); \
+#define vld1q_s16_x3(__p0) __extension__ ({ \
+ int16x8x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 33); \
__ret; \
})
#else
-#define vld4q_dup_s16(__p0) __extension__ ({ \
- int16x8x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 33); \
+#define vld1q_s16_x3(__p0) __extension__ ({ \
+ int16x8x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 33); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_dup_u8(__p0) __extension__ ({ \
- uint8x8x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 16); \
+#define vld1_u8_x3(__p0) __extension__ ({ \
+ uint8x8x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 16); \
__ret; \
})
#else
-#define vld4_dup_u8(__p0) __extension__ ({ \
- uint8x8x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 16); \
+#define vld1_u8_x3(__p0) __extension__ ({ \
+ uint8x8x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 16); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_dup_u32(__p0) __extension__ ({ \
- uint32x2x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 18); \
+#define vld1_u32_x3(__p0) __extension__ ({ \
+ uint32x2x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 18); \
__ret; \
})
#else
-#define vld4_dup_u32(__p0) __extension__ ({ \
- uint32x2x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 18); \
+#define vld1_u32_x3(__p0) __extension__ ({ \
+ uint32x2x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 18); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
__ret; \
})
#endif
-#define vld4_dup_u64(__p0) __extension__ ({ \
- uint64x1x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 19); \
+#define vld1_u64_x3(__p0) __extension__ ({ \
+ uint64x1x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 19); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vld4_dup_u16(__p0) __extension__ ({ \
- uint16x4x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 17); \
+#define vld1_u16_x3(__p0) __extension__ ({ \
+ uint16x4x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 17); \
__ret; \
})
#else
-#define vld4_dup_u16(__p0) __extension__ ({ \
- uint16x4x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 17); \
+#define vld1_u16_x3(__p0) __extension__ ({ \
+ uint16x4x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 17); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_dup_s8(__p0) __extension__ ({ \
- int8x8x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 0); \
+#define vld1_s8_x3(__p0) __extension__ ({ \
+ int8x8x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 0); \
__ret; \
})
#else
-#define vld4_dup_s8(__p0) __extension__ ({ \
- int8x8x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 0); \
+#define vld1_s8_x3(__p0) __extension__ ({ \
+ int8x8x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 0); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_dup_f32(__p0) __extension__ ({ \
- float32x2x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 9); \
- __ret; \
-})
+#define vld1_f32_x3(__p0) __extension__ ({ \
+ float32x2x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 9); \
+ __ret; \
+})
#else
-#define vld4_dup_f32(__p0) __extension__ ({ \
- float32x2x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 9); \
+#define vld1_f32_x3(__p0) __extension__ ({ \
+ float32x2x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 9); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_dup_s32(__p0) __extension__ ({ \
- int32x2x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 2); \
+#define vld1_s32_x3(__p0) __extension__ ({ \
+ int32x2x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 2); \
__ret; \
})
#else
-#define vld4_dup_s32(__p0) __extension__ ({ \
- int32x2x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 2); \
+#define vld1_s32_x3(__p0) __extension__ ({ \
+ int32x2x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 2); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
__ret; \
})
#endif
-#define vld4_dup_s64(__p0) __extension__ ({ \
- int64x1x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 3); \
+#define vld1_s64_x3(__p0) __extension__ ({ \
+ int64x1x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 3); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vld4_dup_s16(__p0) __extension__ ({ \
- int16x4x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 1); \
+#define vld1_s16_x3(__p0) __extension__ ({ \
+ int16x4x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 1); \
__ret; \
})
#else
-#define vld4_dup_s16(__p0) __extension__ ({ \
- int16x4x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 1); \
+#define vld1_s16_x3(__p0) __extension__ ({ \
+ int16x4x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 1); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
__ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+#define vld1_p8_x4(__p0) __extension__ ({ \
poly8x8x4_t __ret; \
- poly8x8x4_t __s1 = __p1; \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 4); \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 4); \
__ret; \
})
#else
-#define vld4_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+#define vld1_p8_x4(__p0) __extension__ ({ \
poly8x8x4_t __ret; \
- poly8x8x4_t __s1 = __p1; \
- poly8x8x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 4); \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 4); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
@@ -13279,22 +13341,15 @@ __ai int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+#define vld1_p16_x4(__p0) __extension__ ({ \
poly16x4x4_t __ret; \
- poly16x4x4_t __s1 = __p1; \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 5); \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 5); \
__ret; \
})
#else
-#define vld4_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+#define vld1_p16_x4(__p0) __extension__ ({ \
poly16x4x4_t __ret; \
- poly16x4x4_t __s1 = __p1; \
- poly16x4x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 5); \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 5); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
@@ -13305,22 +13360,34 @@ __ai int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+#define vld1q_p8_x4(__p0) __extension__ ({ \
+ poly8x16x4_t __ret; \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 36); \
+ __ret; \
+})
+#else
+#define vld1q_p8_x4(__p0) __extension__ ({ \
+ poly8x16x4_t __ret; \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 36); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_p16_x4(__p0) __extension__ ({ \
poly16x8x4_t __ret; \
- poly16x8x4_t __s1 = __p1; \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 37); \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 37); \
__ret; \
})
#else
-#define vld4q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+#define vld1q_p16_x4(__p0) __extension__ ({ \
poly16x8x4_t __ret; \
- poly16x8x4_t __s1 = __p1; \
- poly16x8x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 37); \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 37); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
@@ -13331,22 +13398,34 @@ __ai int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+#define vld1q_u8_x4(__p0) __extension__ ({ \
+ uint8x16x4_t __ret; \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 48); \
+ __ret; \
+})
+#else
+#define vld1q_u8_x4(__p0) __extension__ ({ \
+ uint8x16x4_t __ret; \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 48); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_u32_x4(__p0) __extension__ ({ \
uint32x4x4_t __ret; \
- uint32x4x4_t __s1 = __p1; \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 50); \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 50); \
__ret; \
})
#else
-#define vld4q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+#define vld1q_u32_x4(__p0) __extension__ ({ \
uint32x4x4_t __ret; \
- uint32x4x4_t __s1 = __p1; \
- uint32x4x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 50); \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 50); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
@@ -13357,22 +13436,34 @@ __ai int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+#define vld1q_u64_x4(__p0) __extension__ ({ \
+ uint64x2x4_t __ret; \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 51); \
+ __ret; \
+})
+#else
+#define vld1q_u64_x4(__p0) __extension__ ({ \
+ uint64x2x4_t __ret; \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 51); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_u16_x4(__p0) __extension__ ({ \
uint16x8x4_t __ret; \
- uint16x8x4_t __s1 = __p1; \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 49); \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 49); \
__ret; \
})
#else
-#define vld4q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+#define vld1q_u16_x4(__p0) __extension__ ({ \
uint16x8x4_t __ret; \
- uint16x8x4_t __s1 = __p1; \
- uint16x8x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 49); \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 49); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
@@ -13383,22 +13474,34 @@ __ai int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+#define vld1q_s8_x4(__p0) __extension__ ({ \
+ int8x16x4_t __ret; \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 32); \
+ __ret; \
+})
+#else
+#define vld1q_s8_x4(__p0) __extension__ ({ \
+ int8x16x4_t __ret; \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 32); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_f32_x4(__p0) __extension__ ({ \
float32x4x4_t __ret; \
- float32x4x4_t __s1 = __p1; \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 41); \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 41); \
__ret; \
})
#else
-#define vld4q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+#define vld1q_f32_x4(__p0) __extension__ ({ \
float32x4x4_t __ret; \
- float32x4x4_t __s1 = __p1; \
- float32x4x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 41); \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 41); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
@@ -13409,22 +13512,15 @@ __ai int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+#define vld1q_s32_x4(__p0) __extension__ ({ \
int32x4x4_t __ret; \
- int32x4x4_t __s1 = __p1; \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 34); \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 34); \
__ret; \
})
#else
-#define vld4q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+#define vld1q_s32_x4(__p0) __extension__ ({ \
int32x4x4_t __ret; \
- int32x4x4_t __s1 = __p1; \
- int32x4x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 34); \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 34); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
@@ -13435,22 +13531,34 @@ __ai int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+#define vld1q_s64_x4(__p0) __extension__ ({ \
+ int64x2x4_t __ret; \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 35); \
+ __ret; \
+})
+#else
+#define vld1q_s64_x4(__p0) __extension__ ({ \
+ int64x2x4_t __ret; \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 35); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_s16_x4(__p0) __extension__ ({ \
int16x8x4_t __ret; \
- int16x8x4_t __s1 = __p1; \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 33); \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 33); \
__ret; \
})
#else
-#define vld4q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+#define vld1q_s16_x4(__p0) __extension__ ({ \
int16x8x4_t __ret; \
- int16x8x4_t __s1 = __p1; \
- int16x8x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 33); \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 33); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
@@ -13461,22 +13569,15 @@ __ai int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+#define vld1_u8_x4(__p0) __extension__ ({ \
uint8x8x4_t __ret; \
- uint8x8x4_t __s1 = __p1; \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 16); \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 16); \
__ret; \
})
#else
-#define vld4_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+#define vld1_u8_x4(__p0) __extension__ ({ \
uint8x8x4_t __ret; \
- uint8x8x4_t __s1 = __p1; \
- uint8x8x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 16); \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 16); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
@@ -13487,22 +13588,15 @@ __ai int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+#define vld1_u32_x4(__p0) __extension__ ({ \
uint32x2x4_t __ret; \
- uint32x2x4_t __s1 = __p1; \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 18); \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 18); \
__ret; \
})
#else
-#define vld4_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+#define vld1_u32_x4(__p0) __extension__ ({ \
uint32x2x4_t __ret; \
- uint32x2x4_t __s1 = __p1; \
- uint32x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 18); \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 18); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
@@ -13512,23 +13606,21 @@ __ai int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
})
#endif
+#define vld1_u64_x4(__p0) __extension__ ({ \
+ uint64x1x4_t __ret; \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 19); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vld4_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+#define vld1_u16_x4(__p0) __extension__ ({ \
uint16x4x4_t __ret; \
- uint16x4x4_t __s1 = __p1; \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 17); \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 17); \
__ret; \
})
#else
-#define vld4_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+#define vld1_u16_x4(__p0) __extension__ ({ \
uint16x4x4_t __ret; \
- uint16x4x4_t __s1 = __p1; \
- uint16x4x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 17); \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 17); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
@@ -13539,22 +13631,15 @@ __ai int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+#define vld1_s8_x4(__p0) __extension__ ({ \
int8x8x4_t __ret; \
- int8x8x4_t __s1 = __p1; \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 0); \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 0); \
__ret; \
})
#else
-#define vld4_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+#define vld1_s8_x4(__p0) __extension__ ({ \
int8x8x4_t __ret; \
- int8x8x4_t __s1 = __p1; \
- int8x8x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 0); \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 0); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
@@ -13565,22 +13650,15 @@ __ai int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+#define vld1_f32_x4(__p0) __extension__ ({ \
float32x2x4_t __ret; \
- float32x2x4_t __s1 = __p1; \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 9); \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 9); \
__ret; \
})
#else
-#define vld4_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+#define vld1_f32_x4(__p0) __extension__ ({ \
float32x2x4_t __ret; \
- float32x2x4_t __s1 = __p1; \
- float32x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 9); \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 9); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
@@ -13591,22 +13669,15 @@ __ai int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+#define vld1_s32_x4(__p0) __extension__ ({ \
int32x2x4_t __ret; \
- int32x2x4_t __s1 = __p1; \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 2); \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 2); \
__ret; \
})
#else
-#define vld4_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+#define vld1_s32_x4(__p0) __extension__ ({ \
int32x2x4_t __ret; \
- int32x2x4_t __s1 = __p1; \
- int32x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 2); \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 2); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
@@ -13616,23 +13687,21 @@ __ai int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
})
#endif
+#define vld1_s64_x4(__p0) __extension__ ({ \
+ int64x1x4_t __ret; \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 3); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vld4_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+#define vld1_s16_x4(__p0) __extension__ ({ \
int16x4x4_t __ret; \
- int16x4x4_t __s1 = __p1; \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 1); \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 1); \
__ret; \
})
#else
-#define vld4_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+#define vld1_s16_x4(__p0) __extension__ ({ \
int16x4x4_t __ret; \
- int16x4x4_t __s1 = __p1; \
- int16x4x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 1); \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 1); \
\
__ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
__ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
@@ -13643,25692 +13712,25274 @@ __ai int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vmaxq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
- return __ret;
-}
+#define vld2_p8(__p0) __extension__ ({ \
+ poly8x8x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 4); \
+ __ret; \
+})
#else
-__ai uint8x16_t vmaxq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_p8(__p0) __extension__ ({ \
+ poly8x8x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 4); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmaxq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
- return __ret;
-}
+#define vld2_p16(__p0) __extension__ ({ \
+ poly16x4x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 5); \
+ __ret; \
+})
#else
-__ai uint32x4_t vmaxq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_p16(__p0) __extension__ ({ \
+ poly16x4x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 5); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vmaxq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
- return __ret;
-}
+#define vld2q_p8(__p0) __extension__ ({ \
+ poly8x16x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 36); \
+ __ret; \
+})
#else
-__ai uint16x8_t vmaxq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2q_p8(__p0) __extension__ ({ \
+ poly8x16x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 36); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vmaxq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
- return __ret;
-}
+#define vld2q_p16(__p0) __extension__ ({ \
+ poly16x8x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 37); \
+ __ret; \
+})
#else
-__ai int8x16_t vmaxq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2q_p16(__p0) __extension__ ({ \
+ poly16x8x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 37); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vmaxq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
- return __ret;
-}
+#define vld2q_u8(__p0) __extension__ ({ \
+ uint8x16x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 48); \
+ __ret; \
+})
#else
-__ai float32x4_t vmaxq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2q_u8(__p0) __extension__ ({ \
+ uint8x16x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 48); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmaxq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
- return __ret;
-}
+#define vld2q_u32(__p0) __extension__ ({ \
+ uint32x4x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 50); \
+ __ret; \
+})
#else
-__ai int32x4_t vmaxq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vmaxq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
- return __ret;
-}
-#else
-__ai int16x8_t vmaxq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2q_u32(__p0) __extension__ ({ \
+ uint32x4x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 50); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vmax_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
- return __ret;
-}
+#define vld2q_u16(__p0) __extension__ ({ \
+ uint16x8x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 49); \
+ __ret; \
+})
#else
-__ai uint8x8_t vmax_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2q_u16(__p0) __extension__ ({ \
+ uint16x8x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 49); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vmax_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
- return __ret;
-}
+#define vld2q_s8(__p0) __extension__ ({ \
+ int8x16x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 32); \
+ __ret; \
+})
#else
-__ai uint32x2_t vmax_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld2q_s8(__p0) __extension__ ({ \
+ int8x16x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 32); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vmax_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
- return __ret;
-}
+#define vld2q_f32(__p0) __extension__ ({ \
+ float32x4x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 41); \
+ __ret; \
+})
#else
-__ai uint16x4_t vmax_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2q_f32(__p0) __extension__ ({ \
+ float32x4x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 41); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vmax_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
- return __ret;
-}
+#define vld2q_s32(__p0) __extension__ ({ \
+ int32x4x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 34); \
+ __ret; \
+})
#else
-__ai int8x8_t vmax_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2q_s32(__p0) __extension__ ({ \
+ int32x4x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 34); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vmax_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
- return __ret;
-}
+#define vld2q_s16(__p0) __extension__ ({ \
+ int16x8x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 33); \
+ __ret; \
+})
#else
-__ai float32x2_t vmax_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld2q_s16(__p0) __extension__ ({ \
+ int16x8x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 33); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vmax_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
- return __ret;
-}
+#define vld2_u8(__p0) __extension__ ({ \
+ uint8x8x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 16); \
+ __ret; \
+})
#else
-__ai int32x2_t vmax_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld2_u8(__p0) __extension__ ({ \
+ uint8x8x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 16); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vmax_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
- return __ret;
-}
+#define vld2_u32(__p0) __extension__ ({ \
+ uint32x2x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 18); \
+ __ret; \
+})
#else
-__ai int16x4_t vmax_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_u32(__p0) __extension__ ({ \
+ uint32x2x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 18); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
+})
#endif
+#define vld2_u64(__p0) __extension__ ({ \
+ uint64x1x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 19); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vminq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
- return __ret;
-}
+#define vld2_u16(__p0) __extension__ ({ \
+ uint16x4x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 17); \
+ __ret; \
+})
#else
-__ai uint8x16_t vminq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_u16(__p0) __extension__ ({ \
+ uint16x4x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 17); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vminq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
- return __ret;
-}
+#define vld2_s8(__p0) __extension__ ({ \
+ int8x8x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 0); \
+ __ret; \
+})
#else
-__ai uint32x4_t vminq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_s8(__p0) __extension__ ({ \
+ int8x8x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 0); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vminq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
- return __ret;
-}
+#define vld2_f32(__p0) __extension__ ({ \
+ float32x2x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 9); \
+ __ret; \
+})
#else
-__ai uint16x8_t vminq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_f32(__p0) __extension__ ({ \
+ float32x2x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 9); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vminq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
- return __ret;
-}
+#define vld2_s32(__p0) __extension__ ({ \
+ int32x2x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 2); \
+ __ret; \
+})
#else
-__ai int8x16_t vminq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_s32(__p0) __extension__ ({ \
+ int32x2x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 2); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
+})
#endif
+#define vld2_s64(__p0) __extension__ ({ \
+ int64x1x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 3); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vminq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
- return __ret;
-}
+#define vld2_s16(__p0) __extension__ ({ \
+ int16x4x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 1); \
+ __ret; \
+})
#else
-__ai float32x4_t vminq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_s16(__p0) __extension__ ({ \
+ int16x4x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 1); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vminq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
- return __ret;
-}
+#define vld2_dup_p8(__p0) __extension__ ({ \
+ poly8x8x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 4); \
+ __ret; \
+})
#else
-__ai int32x4_t vminq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_dup_p8(__p0) __extension__ ({ \
+ poly8x8x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 4); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vminq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
- return __ret;
-}
+#define vld2_dup_p16(__p0) __extension__ ({ \
+ poly16x4x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 5); \
+ __ret; \
+})
#else
-__ai int16x8_t vminq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_dup_p16(__p0) __extension__ ({ \
+ poly16x4x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 5); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vmin_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
- return __ret;
-}
+#define vld2q_dup_p8(__p0) __extension__ ({ \
+ poly8x16x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 36); \
+ __ret; \
+})
#else
-__ai uint8x8_t vmin_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2q_dup_p8(__p0) __extension__ ({ \
+ poly8x16x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 36); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vmin_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
- return __ret;
-}
+#define vld2q_dup_p16(__p0) __extension__ ({ \
+ poly16x8x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 37); \
+ __ret; \
+})
#else
-__ai uint32x2_t vmin_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld2q_dup_p16(__p0) __extension__ ({ \
+ poly16x8x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 37); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vmin_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
- return __ret;
-}
+#define vld2q_dup_u8(__p0) __extension__ ({ \
+ uint8x16x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 48); \
+ __ret; \
+})
#else
-__ai uint16x4_t vmin_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2q_dup_u8(__p0) __extension__ ({ \
+ uint8x16x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 48); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vmin_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
- return __ret;
-}
+#define vld2q_dup_u32(__p0) __extension__ ({ \
+ uint32x4x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 50); \
+ __ret; \
+})
#else
-__ai int8x8_t vmin_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2q_dup_u32(__p0) __extension__ ({ \
+ uint32x4x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 50); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vmin_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
- return __ret;
-}
+#define vld2q_dup_u64(__p0) __extension__ ({ \
+ uint64x2x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 51); \
+ __ret; \
+})
#else
-__ai float32x2_t vmin_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld2q_dup_u64(__p0) __extension__ ({ \
+ uint64x2x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 51); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vmin_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
- return __ret;
-}
+#define vld2q_dup_u16(__p0) __extension__ ({ \
+ uint16x8x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 49); \
+ __ret; \
+})
#else
-__ai int32x2_t vmin_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld2q_dup_u16(__p0) __extension__ ({ \
+ uint16x8x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 49); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vmin_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
- return __ret;
-}
-#else
-__ai int16x4_t vmin_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vmlaq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
- uint8x16_t __ret;
- __ret = __p0 + __p1 * __p2;
- return __ret;
-}
-#else
-__ai uint8x16_t vmlaq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 + __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmlaq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
- uint32x4_t __ret;
- __ret = __p0 + __p1 * __p2;
- return __ret;
-}
-#else
-__ai uint32x4_t vmlaq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- uint32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __rev0 + __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vmlaq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
- uint16x8_t __ret;
- __ret = __p0 + __p1 * __p2;
- return __ret;
-}
-#else
-__ai uint16x8_t vmlaq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 + __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vmlaq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
- int8x16_t __ret;
- __ret = __p0 + __p1 * __p2;
- return __ret;
-}
-#else
-__ai int8x16_t vmlaq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 + __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vmlaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
- float32x4_t __ret;
- __ret = __p0 + __p1 * __p2;
- return __ret;
-}
+#define vld2q_dup_s8(__p0) __extension__ ({ \
+ int8x16x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 32); \
+ __ret; \
+})
#else
-__ai float32x4_t vmlaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- float32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __rev0 + __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2q_dup_s8(__p0) __extension__ ({ \
+ int8x16x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 32); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmlaq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int32x4_t __ret;
- __ret = __p0 + __p1 * __p2;
- return __ret;
-}
+#define vld2q_dup_f32(__p0) __extension__ ({ \
+ float32x4x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 41); \
+ __ret; \
+})
#else
-__ai int32x4_t vmlaq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __rev0 + __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2q_dup_f32(__p0) __extension__ ({ \
+ float32x4x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 41); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vmlaq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int16x8_t __ret;
- __ret = __p0 + __p1 * __p2;
- return __ret;
-}
+#define vld2q_dup_s32(__p0) __extension__ ({ \
+ int32x4x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 34); \
+ __ret; \
+})
#else
-__ai int16x8_t vmlaq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 + __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2q_dup_s32(__p0) __extension__ ({ \
+ int32x4x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 34); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vmla_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- __ret = __p0 + __p1 * __p2;
- return __ret;
-}
+#define vld2q_dup_s64(__p0) __extension__ ({ \
+ int64x2x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 35); \
+ __ret; \
+})
#else
-__ai uint8x8_t vmla_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 + __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2q_dup_s64(__p0) __extension__ ({ \
+ int64x2x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 35); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vmla_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
- uint32x2_t __ret;
- __ret = __p0 + __p1 * __p2;
- return __ret;
-}
+#define vld2q_dup_s16(__p0) __extension__ ({ \
+ int16x8x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 33); \
+ __ret; \
+})
#else
-__ai uint32x2_t vmla_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- uint32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = __rev0 + __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld2q_dup_s16(__p0) __extension__ ({ \
+ int16x8x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 33); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vmla_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
- uint16x4_t __ret;
- __ret = __p0 + __p1 * __p2;
- return __ret;
-}
+#define vld2_dup_u8(__p0) __extension__ ({ \
+ uint8x8x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 16); \
+ __ret; \
+})
#else
-__ai uint16x4_t vmla_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- uint16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __rev0 + __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_dup_u8(__p0) __extension__ ({ \
+ uint8x8x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 16); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vmla_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
- int8x8_t __ret;
- __ret = __p0 + __p1 * __p2;
- return __ret;
-}
+#define vld2_dup_u32(__p0) __extension__ ({ \
+ uint32x2x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 18); \
+ __ret; \
+})
#else
-__ai int8x8_t vmla_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 + __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_dup_u32(__p0) __extension__ ({ \
+ uint32x2x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 18); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
+})
#endif
+#define vld2_dup_u64(__p0) __extension__ ({ \
+ uint64x1x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 19); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vmla_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
- float32x2_t __ret;
- __ret = __p0 + __p1 * __p2;
- return __ret;
-}
+#define vld2_dup_u16(__p0) __extension__ ({ \
+ uint16x4x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 17); \
+ __ret; \
+})
#else
-__ai float32x2_t vmla_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- float32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = __rev0 + __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld2_dup_u16(__p0) __extension__ ({ \
+ uint16x4x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 17); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vmla_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
- int32x2_t __ret;
- __ret = __p0 + __p1 * __p2;
- return __ret;
-}
+#define vld2_dup_s8(__p0) __extension__ ({ \
+ int8x8x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 0); \
+ __ret; \
+})
#else
-__ai int32x2_t vmla_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- int32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = __rev0 + __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld2_dup_s8(__p0) __extension__ ({ \
+ int8x8x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 0); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vmla_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
- int16x4_t __ret;
- __ret = __p0 + __p1 * __p2;
- return __ret;
-}
+#define vld2_dup_f32(__p0) __extension__ ({ \
+ float32x2x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 9); \
+ __ret; \
+})
#else
-__ai int16x4_t vmla_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- int16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __rev0 + __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_dup_f32(__p0) __extension__ ({ \
+ float32x2x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 9); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlaq_lane_u32(__p0_46, __p1_46, __p2_46, __p3_46) __extension__ ({ \
- uint32x4_t __ret_46; \
- uint32x4_t __s0_46 = __p0_46; \
- uint32x4_t __s1_46 = __p1_46; \
- uint32x2_t __s2_46 = __p2_46; \
- __ret_46 = __s0_46 + __s1_46 * splatq_lane_u32(__s2_46, __p3_46); \
- __ret_46; \
+#define vld2_dup_s32(__p0) __extension__ ({ \
+ int32x2x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 2); \
+ __ret; \
})
#else
-#define vmlaq_lane_u32(__p0_47, __p1_47, __p2_47, __p3_47) __extension__ ({ \
- uint32x4_t __ret_47; \
- uint32x4_t __s0_47 = __p0_47; \
- uint32x4_t __s1_47 = __p1_47; \
- uint32x2_t __s2_47 = __p2_47; \
- uint32x4_t __rev0_47; __rev0_47 = __builtin_shufflevector(__s0_47, __s0_47, 3, 2, 1, 0); \
- uint32x4_t __rev1_47; __rev1_47 = __builtin_shufflevector(__s1_47, __s1_47, 3, 2, 1, 0); \
- uint32x2_t __rev2_47; __rev2_47 = __builtin_shufflevector(__s2_47, __s2_47, 1, 0); \
- __ret_47 = __rev0_47 + __rev1_47 * __noswap_splatq_lane_u32(__rev2_47, __p3_47); \
- __ret_47 = __builtin_shufflevector(__ret_47, __ret_47, 3, 2, 1, 0); \
- __ret_47; \
+#define vld2_dup_s32(__p0) __extension__ ({ \
+ int32x2x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 2); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
})
#endif
+#define vld2_dup_s64(__p0) __extension__ ({ \
+ int64x1x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 3); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vmlaq_lane_u16(__p0_48, __p1_48, __p2_48, __p3_48) __extension__ ({ \
- uint16x8_t __ret_48; \
- uint16x8_t __s0_48 = __p0_48; \
- uint16x8_t __s1_48 = __p1_48; \
- uint16x4_t __s2_48 = __p2_48; \
- __ret_48 = __s0_48 + __s1_48 * splatq_lane_u16(__s2_48, __p3_48); \
- __ret_48; \
+#define vld2_dup_s16(__p0) __extension__ ({ \
+ int16x4x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 1); \
+ __ret; \
})
#else
-#define vmlaq_lane_u16(__p0_49, __p1_49, __p2_49, __p3_49) __extension__ ({ \
- uint16x8_t __ret_49; \
- uint16x8_t __s0_49 = __p0_49; \
- uint16x8_t __s1_49 = __p1_49; \
- uint16x4_t __s2_49 = __p2_49; \
- uint16x8_t __rev0_49; __rev0_49 = __builtin_shufflevector(__s0_49, __s0_49, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x8_t __rev1_49; __rev1_49 = __builtin_shufflevector(__s1_49, __s1_49, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x4_t __rev2_49; __rev2_49 = __builtin_shufflevector(__s2_49, __s2_49, 3, 2, 1, 0); \
- __ret_49 = __rev0_49 + __rev1_49 * __noswap_splatq_lane_u16(__rev2_49, __p3_49); \
- __ret_49 = __builtin_shufflevector(__ret_49, __ret_49, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_49; \
+#define vld2_dup_s16(__p0) __extension__ ({ \
+ int16x4x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 1); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlaq_lane_f32(__p0_50, __p1_50, __p2_50, __p3_50) __extension__ ({ \
- float32x4_t __ret_50; \
- float32x4_t __s0_50 = __p0_50; \
- float32x4_t __s1_50 = __p1_50; \
- float32x2_t __s2_50 = __p2_50; \
- __ret_50 = __s0_50 + __s1_50 * splatq_lane_f32(__s2_50, __p3_50); \
- __ret_50; \
+#define vld2_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8x2_t __ret; \
+ poly8x8x2_t __s1 = __p1; \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 4); \
+ __ret; \
})
#else
-#define vmlaq_lane_f32(__p0_51, __p1_51, __p2_51, __p3_51) __extension__ ({ \
- float32x4_t __ret_51; \
- float32x4_t __s0_51 = __p0_51; \
- float32x4_t __s1_51 = __p1_51; \
- float32x2_t __s2_51 = __p2_51; \
- float32x4_t __rev0_51; __rev0_51 = __builtin_shufflevector(__s0_51, __s0_51, 3, 2, 1, 0); \
- float32x4_t __rev1_51; __rev1_51 = __builtin_shufflevector(__s1_51, __s1_51, 3, 2, 1, 0); \
- float32x2_t __rev2_51; __rev2_51 = __builtin_shufflevector(__s2_51, __s2_51, 1, 0); \
- __ret_51 = __rev0_51 + __rev1_51 * __noswap_splatq_lane_f32(__rev2_51, __p3_51); \
- __ret_51 = __builtin_shufflevector(__ret_51, __ret_51, 3, 2, 1, 0); \
- __ret_51; \
+#define vld2_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8x2_t __ret; \
+ poly8x8x2_t __s1 = __p1; \
+ poly8x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 4); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlaq_lane_s32(__p0_52, __p1_52, __p2_52, __p3_52) __extension__ ({ \
- int32x4_t __ret_52; \
- int32x4_t __s0_52 = __p0_52; \
- int32x4_t __s1_52 = __p1_52; \
- int32x2_t __s2_52 = __p2_52; \
- __ret_52 = __s0_52 + __s1_52 * splatq_lane_s32(__s2_52, __p3_52); \
- __ret_52; \
+#define vld2_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4x2_t __ret; \
+ poly16x4x2_t __s1 = __p1; \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 5); \
+ __ret; \
})
#else
-#define vmlaq_lane_s32(__p0_53, __p1_53, __p2_53, __p3_53) __extension__ ({ \
- int32x4_t __ret_53; \
- int32x4_t __s0_53 = __p0_53; \
- int32x4_t __s1_53 = __p1_53; \
- int32x2_t __s2_53 = __p2_53; \
- int32x4_t __rev0_53; __rev0_53 = __builtin_shufflevector(__s0_53, __s0_53, 3, 2, 1, 0); \
- int32x4_t __rev1_53; __rev1_53 = __builtin_shufflevector(__s1_53, __s1_53, 3, 2, 1, 0); \
- int32x2_t __rev2_53; __rev2_53 = __builtin_shufflevector(__s2_53, __s2_53, 1, 0); \
- __ret_53 = __rev0_53 + __rev1_53 * __noswap_splatq_lane_s32(__rev2_53, __p3_53); \
- __ret_53 = __builtin_shufflevector(__ret_53, __ret_53, 3, 2, 1, 0); \
- __ret_53; \
+#define vld2_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4x2_t __ret; \
+ poly16x4x2_t __s1 = __p1; \
+ poly16x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 5); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlaq_lane_s16(__p0_54, __p1_54, __p2_54, __p3_54) __extension__ ({ \
- int16x8_t __ret_54; \
- int16x8_t __s0_54 = __p0_54; \
- int16x8_t __s1_54 = __p1_54; \
- int16x4_t __s2_54 = __p2_54; \
- __ret_54 = __s0_54 + __s1_54 * splatq_lane_s16(__s2_54, __p3_54); \
- __ret_54; \
+#define vld2q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8x2_t __ret; \
+ poly16x8x2_t __s1 = __p1; \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 37); \
+ __ret; \
})
#else
-#define vmlaq_lane_s16(__p0_55, __p1_55, __p2_55, __p3_55) __extension__ ({ \
- int16x8_t __ret_55; \
- int16x8_t __s0_55 = __p0_55; \
- int16x8_t __s1_55 = __p1_55; \
- int16x4_t __s2_55 = __p2_55; \
- int16x8_t __rev0_55; __rev0_55 = __builtin_shufflevector(__s0_55, __s0_55, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1_55; __rev1_55 = __builtin_shufflevector(__s1_55, __s1_55, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x4_t __rev2_55; __rev2_55 = __builtin_shufflevector(__s2_55, __s2_55, 3, 2, 1, 0); \
- __ret_55 = __rev0_55 + __rev1_55 * __noswap_splatq_lane_s16(__rev2_55, __p3_55); \
- __ret_55 = __builtin_shufflevector(__ret_55, __ret_55, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_55; \
+#define vld2q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8x2_t __ret; \
+ poly16x8x2_t __s1 = __p1; \
+ poly16x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 37); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmla_lane_u32(__p0_56, __p1_56, __p2_56, __p3_56) __extension__ ({ \
- uint32x2_t __ret_56; \
- uint32x2_t __s0_56 = __p0_56; \
- uint32x2_t __s1_56 = __p1_56; \
- uint32x2_t __s2_56 = __p2_56; \
- __ret_56 = __s0_56 + __s1_56 * splat_lane_u32(__s2_56, __p3_56); \
- __ret_56; \
+#define vld2q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4x2_t __ret; \
+ uint32x4x2_t __s1 = __p1; \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 50); \
+ __ret; \
})
#else
-#define vmla_lane_u32(__p0_57, __p1_57, __p2_57, __p3_57) __extension__ ({ \
- uint32x2_t __ret_57; \
- uint32x2_t __s0_57 = __p0_57; \
- uint32x2_t __s1_57 = __p1_57; \
- uint32x2_t __s2_57 = __p2_57; \
- uint32x2_t __rev0_57; __rev0_57 = __builtin_shufflevector(__s0_57, __s0_57, 1, 0); \
- uint32x2_t __rev1_57; __rev1_57 = __builtin_shufflevector(__s1_57, __s1_57, 1, 0); \
- uint32x2_t __rev2_57; __rev2_57 = __builtin_shufflevector(__s2_57, __s2_57, 1, 0); \
- __ret_57 = __rev0_57 + __rev1_57 * __noswap_splat_lane_u32(__rev2_57, __p3_57); \
- __ret_57 = __builtin_shufflevector(__ret_57, __ret_57, 1, 0); \
- __ret_57; \
+#define vld2q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4x2_t __ret; \
+ uint32x4x2_t __s1 = __p1; \
+ uint32x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 50); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmla_lane_u16(__p0_58, __p1_58, __p2_58, __p3_58) __extension__ ({ \
- uint16x4_t __ret_58; \
- uint16x4_t __s0_58 = __p0_58; \
- uint16x4_t __s1_58 = __p1_58; \
- uint16x4_t __s2_58 = __p2_58; \
- __ret_58 = __s0_58 + __s1_58 * splat_lane_u16(__s2_58, __p3_58); \
- __ret_58; \
+#define vld2q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8x2_t __ret; \
+ uint16x8x2_t __s1 = __p1; \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 49); \
+ __ret; \
})
#else
-#define vmla_lane_u16(__p0_59, __p1_59, __p2_59, __p3_59) __extension__ ({ \
- uint16x4_t __ret_59; \
- uint16x4_t __s0_59 = __p0_59; \
- uint16x4_t __s1_59 = __p1_59; \
- uint16x4_t __s2_59 = __p2_59; \
- uint16x4_t __rev0_59; __rev0_59 = __builtin_shufflevector(__s0_59, __s0_59, 3, 2, 1, 0); \
- uint16x4_t __rev1_59; __rev1_59 = __builtin_shufflevector(__s1_59, __s1_59, 3, 2, 1, 0); \
- uint16x4_t __rev2_59; __rev2_59 = __builtin_shufflevector(__s2_59, __s2_59, 3, 2, 1, 0); \
- __ret_59 = __rev0_59 + __rev1_59 * __noswap_splat_lane_u16(__rev2_59, __p3_59); \
- __ret_59 = __builtin_shufflevector(__ret_59, __ret_59, 3, 2, 1, 0); \
- __ret_59; \
+#define vld2q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8x2_t __ret; \
+ uint16x8x2_t __s1 = __p1; \
+ uint16x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 49); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmla_lane_f32(__p0_60, __p1_60, __p2_60, __p3_60) __extension__ ({ \
- float32x2_t __ret_60; \
- float32x2_t __s0_60 = __p0_60; \
- float32x2_t __s1_60 = __p1_60; \
- float32x2_t __s2_60 = __p2_60; \
- __ret_60 = __s0_60 + __s1_60 * splat_lane_f32(__s2_60, __p3_60); \
- __ret_60; \
+#define vld2q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4x2_t __ret; \
+ float32x4x2_t __s1 = __p1; \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 41); \
+ __ret; \
})
#else
-#define vmla_lane_f32(__p0_61, __p1_61, __p2_61, __p3_61) __extension__ ({ \
- float32x2_t __ret_61; \
- float32x2_t __s0_61 = __p0_61; \
- float32x2_t __s1_61 = __p1_61; \
- float32x2_t __s2_61 = __p2_61; \
- float32x2_t __rev0_61; __rev0_61 = __builtin_shufflevector(__s0_61, __s0_61, 1, 0); \
- float32x2_t __rev1_61; __rev1_61 = __builtin_shufflevector(__s1_61, __s1_61, 1, 0); \
- float32x2_t __rev2_61; __rev2_61 = __builtin_shufflevector(__s2_61, __s2_61, 1, 0); \
- __ret_61 = __rev0_61 + __rev1_61 * __noswap_splat_lane_f32(__rev2_61, __p3_61); \
- __ret_61 = __builtin_shufflevector(__ret_61, __ret_61, 1, 0); \
- __ret_61; \
+#define vld2q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4x2_t __ret; \
+ float32x4x2_t __s1 = __p1; \
+ float32x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 41); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmla_lane_s32(__p0_62, __p1_62, __p2_62, __p3_62) __extension__ ({ \
- int32x2_t __ret_62; \
- int32x2_t __s0_62 = __p0_62; \
- int32x2_t __s1_62 = __p1_62; \
- int32x2_t __s2_62 = __p2_62; \
- __ret_62 = __s0_62 + __s1_62 * splat_lane_s32(__s2_62, __p3_62); \
- __ret_62; \
+#define vld2q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4x2_t __ret; \
+ int32x4x2_t __s1 = __p1; \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 34); \
+ __ret; \
})
#else
-#define vmla_lane_s32(__p0_63, __p1_63, __p2_63, __p3_63) __extension__ ({ \
- int32x2_t __ret_63; \
- int32x2_t __s0_63 = __p0_63; \
- int32x2_t __s1_63 = __p1_63; \
- int32x2_t __s2_63 = __p2_63; \
- int32x2_t __rev0_63; __rev0_63 = __builtin_shufflevector(__s0_63, __s0_63, 1, 0); \
- int32x2_t __rev1_63; __rev1_63 = __builtin_shufflevector(__s1_63, __s1_63, 1, 0); \
- int32x2_t __rev2_63; __rev2_63 = __builtin_shufflevector(__s2_63, __s2_63, 1, 0); \
- __ret_63 = __rev0_63 + __rev1_63 * __noswap_splat_lane_s32(__rev2_63, __p3_63); \
- __ret_63 = __builtin_shufflevector(__ret_63, __ret_63, 1, 0); \
- __ret_63; \
+#define vld2q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4x2_t __ret; \
+ int32x4x2_t __s1 = __p1; \
+ int32x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 34); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmla_lane_s16(__p0_64, __p1_64, __p2_64, __p3_64) __extension__ ({ \
- int16x4_t __ret_64; \
- int16x4_t __s0_64 = __p0_64; \
- int16x4_t __s1_64 = __p1_64; \
- int16x4_t __s2_64 = __p2_64; \
- __ret_64 = __s0_64 + __s1_64 * splat_lane_s16(__s2_64, __p3_64); \
- __ret_64; \
+#define vld2q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8x2_t __ret; \
+ int16x8x2_t __s1 = __p1; \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 33); \
+ __ret; \
})
#else
-#define vmla_lane_s16(__p0_65, __p1_65, __p2_65, __p3_65) __extension__ ({ \
- int16x4_t __ret_65; \
- int16x4_t __s0_65 = __p0_65; \
- int16x4_t __s1_65 = __p1_65; \
- int16x4_t __s2_65 = __p2_65; \
- int16x4_t __rev0_65; __rev0_65 = __builtin_shufflevector(__s0_65, __s0_65, 3, 2, 1, 0); \
- int16x4_t __rev1_65; __rev1_65 = __builtin_shufflevector(__s1_65, __s1_65, 3, 2, 1, 0); \
- int16x4_t __rev2_65; __rev2_65 = __builtin_shufflevector(__s2_65, __s2_65, 3, 2, 1, 0); \
- __ret_65 = __rev0_65 + __rev1_65 * __noswap_splat_lane_s16(__rev2_65, __p3_65); \
- __ret_65 = __builtin_shufflevector(__ret_65, __ret_65, 3, 2, 1, 0); \
- __ret_65; \
+#define vld2q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8x2_t __ret; \
+ int16x8x2_t __s1 = __p1; \
+ int16x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 33); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmlaq_n_u32(uint32x4_t __p0, uint32x4_t __p1, uint32_t __p2) {
- uint32x4_t __ret;
- __ret = __p0 + __p1 * (uint32x4_t) {__p2, __p2, __p2, __p2};
- return __ret;
-}
+#define vld2_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8x2_t __ret; \
+ uint8x8x2_t __s1 = __p1; \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 16); \
+ __ret; \
+})
#else
-__ai uint32x4_t vmlaq_n_u32(uint32x4_t __p0, uint32x4_t __p1, uint32_t __p2) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 + __rev1 * (uint32x4_t) {__p2, __p2, __p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8x2_t __ret; \
+ uint8x8x2_t __s1 = __p1; \
+ uint8x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 16); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vmlaq_n_u16(uint16x8_t __p0, uint16x8_t __p1, uint16_t __p2) {
- uint16x8_t __ret;
- __ret = __p0 + __p1 * (uint16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
- return __ret;
-}
+#define vld2_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2x2_t __ret; \
+ uint32x2x2_t __s1 = __p1; \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 18); \
+ __ret; \
+})
#else
-__ai uint16x8_t vmlaq_n_u16(uint16x8_t __p0, uint16x8_t __p1, uint16_t __p2) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 + __rev1 * (uint16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2x2_t __ret; \
+ uint32x2x2_t __s1 = __p1; \
+ uint32x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 18); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vmlaq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
- float32x4_t __ret;
- __ret = __p0 + __p1 * (float32x4_t) {__p2, __p2, __p2, __p2};
- return __ret;
-}
+#define vld2_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4x2_t __ret; \
+ uint16x4x2_t __s1 = __p1; \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 17); \
+ __ret; \
+})
#else
-__ai float32x4_t vmlaq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 + __rev1 * (float32x4_t) {__p2, __p2, __p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4x2_t __ret; \
+ uint16x4x2_t __s1 = __p1; \
+ uint16x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 17); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmlaq_n_s32(int32x4_t __p0, int32x4_t __p1, int32_t __p2) {
- int32x4_t __ret;
- __ret = __p0 + __p1 * (int32x4_t) {__p2, __p2, __p2, __p2};
- return __ret;
-}
+#define vld2_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8x2_t __ret; \
+ int8x8x2_t __s1 = __p1; \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 0); \
+ __ret; \
+})
#else
-__ai int32x4_t vmlaq_n_s32(int32x4_t __p0, int32x4_t __p1, int32_t __p2) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 + __rev1 * (int32x4_t) {__p2, __p2, __p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8x2_t __ret; \
+ int8x8x2_t __s1 = __p1; \
+ int8x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 0); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vmlaq_n_s16(int16x8_t __p0, int16x8_t __p1, int16_t __p2) {
- int16x8_t __ret;
- __ret = __p0 + __p1 * (int16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
- return __ret;
-}
+#define vld2_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2x2_t __ret; \
+ float32x2x2_t __s1 = __p1; \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 9); \
+ __ret; \
+})
#else
-__ai int16x8_t vmlaq_n_s16(int16x8_t __p0, int16x8_t __p1, int16_t __p2) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 + __rev1 * (int16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2x2_t __ret; \
+ float32x2x2_t __s1 = __p1; \
+ float32x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 9); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vmla_n_u32(uint32x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
- uint32x2_t __ret;
- __ret = __p0 + __p1 * (uint32x2_t) {__p2, __p2};
- return __ret;
-}
+#define vld2_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2x2_t __ret; \
+ int32x2x2_t __s1 = __p1; \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 2); \
+ __ret; \
+})
#else
-__ai uint32x2_t vmla_n_u32(uint32x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 + __rev1 * (uint32x2_t) {__p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld2_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2x2_t __ret; \
+ int32x2x2_t __s1 = __p1; \
+ int32x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 2); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vmla_n_u16(uint16x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
- uint16x4_t __ret;
- __ret = __p0 + __p1 * (uint16x4_t) {__p2, __p2, __p2, __p2};
- return __ret;
-}
+#define vld2_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4x2_t __ret; \
+ int16x4x2_t __s1 = __p1; \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 1); \
+ __ret; \
+})
#else
-__ai uint16x4_t vmla_n_u16(uint16x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 + __rev1 * (uint16x4_t) {__p2, __p2, __p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld2_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4x2_t __ret; \
+ int16x4x2_t __s1 = __p1; \
+ int16x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 1); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vmla_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
- float32x2_t __ret;
- __ret = __p0 + __p1 * (float32x2_t) {__p2, __p2};
- return __ret;
-}
+#define vld3_p8(__p0) __extension__ ({ \
+ poly8x8x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 4); \
+ __ret; \
+})
#else
-__ai float32x2_t vmla_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 + __rev1 * (float32x2_t) {__p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld3_p8(__p0) __extension__ ({ \
+ poly8x8x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 4); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vmla_n_s32(int32x2_t __p0, int32x2_t __p1, int32_t __p2) {
- int32x2_t __ret;
- __ret = __p0 + __p1 * (int32x2_t) {__p2, __p2};
- return __ret;
-}
+#define vld3_p16(__p0) __extension__ ({ \
+ poly16x4x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 5); \
+ __ret; \
+})
#else
-__ai int32x2_t vmla_n_s32(int32x2_t __p0, int32x2_t __p1, int32_t __p2) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 + __rev1 * (int32x2_t) {__p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld3_p16(__p0) __extension__ ({ \
+ poly16x4x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 5); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vmla_n_s16(int16x4_t __p0, int16x4_t __p1, int16_t __p2) {
- int16x4_t __ret;
- __ret = __p0 + __p1 * (int16x4_t) {__p2, __p2, __p2, __p2};
- return __ret;
-}
+#define vld3q_p8(__p0) __extension__ ({ \
+ poly8x16x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 36); \
+ __ret; \
+})
#else
-__ai int16x4_t vmla_n_s16(int16x4_t __p0, int16x4_t __p1, int16_t __p2) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 + __rev1 * (int16x4_t) {__p2, __p2, __p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3q_p8(__p0) __extension__ ({ \
+ poly8x16x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 36); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vmlsq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
- uint8x16_t __ret;
- __ret = __p0 - __p1 * __p2;
- return __ret;
-}
+#define vld3q_p16(__p0) __extension__ ({ \
+ poly16x8x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 37); \
+ __ret; \
+})
#else
-__ai uint8x16_t vmlsq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3q_p16(__p0) __extension__ ({ \
+ poly16x8x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 37); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmlsq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
- uint32x4_t __ret;
- __ret = __p0 - __p1 * __p2;
- return __ret;
-}
+#define vld3q_u8(__p0) __extension__ ({ \
+ uint8x16x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 48); \
+ __ret; \
+})
#else
-__ai uint32x4_t vmlsq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- uint32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __rev0 - __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3q_u8(__p0) __extension__ ({ \
+ uint8x16x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 48); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vmlsq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
- uint16x8_t __ret;
- __ret = __p0 - __p1 * __p2;
- return __ret;
-}
+#define vld3q_u32(__p0) __extension__ ({ \
+ uint32x4x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 50); \
+ __ret; \
+})
#else
-__ai uint16x8_t vmlsq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3q_u32(__p0) __extension__ ({ \
+ uint32x4x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 50); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vmlsq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
- int8x16_t __ret;
- __ret = __p0 - __p1 * __p2;
- return __ret;
-}
+#define vld3q_u16(__p0) __extension__ ({ \
+ uint16x8x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 49); \
+ __ret; \
+})
#else
-__ai int8x16_t vmlsq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3q_u16(__p0) __extension__ ({ \
+ uint16x8x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 49); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vmlsq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
- float32x4_t __ret;
- __ret = __p0 - __p1 * __p2;
- return __ret;
-}
+#define vld3q_s8(__p0) __extension__ ({ \
+ int8x16x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 32); \
+ __ret; \
+})
#else
-__ai float32x4_t vmlsq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- float32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __rev0 - __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3q_s8(__p0) __extension__ ({ \
+ int8x16x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 32); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmlsq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int32x4_t __ret;
- __ret = __p0 - __p1 * __p2;
- return __ret;
-}
+#define vld3q_f32(__p0) __extension__ ({ \
+ float32x4x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 41); \
+ __ret; \
+})
#else
-__ai int32x4_t vmlsq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __rev0 - __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3q_f32(__p0) __extension__ ({ \
+ float32x4x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 41); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vmlsq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int16x8_t __ret;
- __ret = __p0 - __p1 * __p2;
- return __ret;
-}
+#define vld3q_s32(__p0) __extension__ ({ \
+ int32x4x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 34); \
+ __ret; \
+})
#else
-__ai int16x8_t vmlsq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3q_s32(__p0) __extension__ ({ \
+ int32x4x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 34); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vmls_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- __ret = __p0 - __p1 * __p2;
- return __ret;
-}
+#define vld3q_s16(__p0) __extension__ ({ \
+ int16x8x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 33); \
+ __ret; \
+})
#else
-__ai uint8x8_t vmls_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3q_s16(__p0) __extension__ ({ \
+ int16x8x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 33); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vmls_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
- uint32x2_t __ret;
- __ret = __p0 - __p1 * __p2;
- return __ret;
-}
+#define vld3_u8(__p0) __extension__ ({ \
+ uint8x8x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 16); \
+ __ret; \
+})
#else
-__ai uint32x2_t vmls_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- uint32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = __rev0 - __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld3_u8(__p0) __extension__ ({ \
+ uint8x8x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 16); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vmls_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
- uint16x4_t __ret;
- __ret = __p0 - __p1 * __p2;
- return __ret;
-}
+#define vld3_u32(__p0) __extension__ ({ \
+ uint32x2x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 18); \
+ __ret; \
+})
#else
-__ai uint16x4_t vmls_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- uint16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __rev0 - __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3_u32(__p0) __extension__ ({ \
+ uint32x2x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 18); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
+})
#endif
+#define vld3_u64(__p0) __extension__ ({ \
+ uint64x1x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 19); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vmls_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
- int8x8_t __ret;
- __ret = __p0 - __p1 * __p2;
- return __ret;
-}
+#define vld3_u16(__p0) __extension__ ({ \
+ uint16x4x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 17); \
+ __ret; \
+})
#else
-__ai int8x8_t vmls_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3_u16(__p0) __extension__ ({ \
+ uint16x4x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 17); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vmls_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
- float32x2_t __ret;
- __ret = __p0 - __p1 * __p2;
- return __ret;
-}
+#define vld3_s8(__p0) __extension__ ({ \
+ int8x8x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 0); \
+ __ret; \
+})
#else
-__ai float32x2_t vmls_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- float32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = __rev0 - __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld3_s8(__p0) __extension__ ({ \
+ int8x8x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 0); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vmls_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
- int32x2_t __ret;
- __ret = __p0 - __p1 * __p2;
- return __ret;
-}
+#define vld3_f32(__p0) __extension__ ({ \
+ float32x2x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 9); \
+ __ret; \
+})
#else
-__ai int32x2_t vmls_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- int32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = __rev0 - __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld3_f32(__p0) __extension__ ({ \
+ float32x2x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 9); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vmls_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
- int16x4_t __ret;
- __ret = __p0 - __p1 * __p2;
- return __ret;
-}
+#define vld3_s32(__p0) __extension__ ({ \
+ int32x2x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 2); \
+ __ret; \
+})
#else
-__ai int16x4_t vmls_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- int16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __rev0 - __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3_s32(__p0) __extension__ ({ \
+ int32x2x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 2); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
+})
#endif
+#define vld3_s64(__p0) __extension__ ({ \
+ int64x1x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 3); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vmlsq_lane_u32(__p0_66, __p1_66, __p2_66, __p3_66) __extension__ ({ \
- uint32x4_t __ret_66; \
- uint32x4_t __s0_66 = __p0_66; \
- uint32x4_t __s1_66 = __p1_66; \
- uint32x2_t __s2_66 = __p2_66; \
- __ret_66 = __s0_66 - __s1_66 * splatq_lane_u32(__s2_66, __p3_66); \
- __ret_66; \
+#define vld3_s16(__p0) __extension__ ({ \
+ int16x4x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 1); \
+ __ret; \
})
#else
-#define vmlsq_lane_u32(__p0_67, __p1_67, __p2_67, __p3_67) __extension__ ({ \
- uint32x4_t __ret_67; \
- uint32x4_t __s0_67 = __p0_67; \
- uint32x4_t __s1_67 = __p1_67; \
- uint32x2_t __s2_67 = __p2_67; \
- uint32x4_t __rev0_67; __rev0_67 = __builtin_shufflevector(__s0_67, __s0_67, 3, 2, 1, 0); \
- uint32x4_t __rev1_67; __rev1_67 = __builtin_shufflevector(__s1_67, __s1_67, 3, 2, 1, 0); \
- uint32x2_t __rev2_67; __rev2_67 = __builtin_shufflevector(__s2_67, __s2_67, 1, 0); \
- __ret_67 = __rev0_67 - __rev1_67 * __noswap_splatq_lane_u32(__rev2_67, __p3_67); \
- __ret_67 = __builtin_shufflevector(__ret_67, __ret_67, 3, 2, 1, 0); \
- __ret_67; \
+#define vld3_s16(__p0) __extension__ ({ \
+ int16x4x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 1); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsq_lane_u16(__p0_68, __p1_68, __p2_68, __p3_68) __extension__ ({ \
- uint16x8_t __ret_68; \
- uint16x8_t __s0_68 = __p0_68; \
- uint16x8_t __s1_68 = __p1_68; \
- uint16x4_t __s2_68 = __p2_68; \
- __ret_68 = __s0_68 - __s1_68 * splatq_lane_u16(__s2_68, __p3_68); \
- __ret_68; \
+#define vld3_dup_p8(__p0) __extension__ ({ \
+ poly8x8x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 4); \
+ __ret; \
})
#else
-#define vmlsq_lane_u16(__p0_69, __p1_69, __p2_69, __p3_69) __extension__ ({ \
- uint16x8_t __ret_69; \
- uint16x8_t __s0_69 = __p0_69; \
- uint16x8_t __s1_69 = __p1_69; \
- uint16x4_t __s2_69 = __p2_69; \
- uint16x8_t __rev0_69; __rev0_69 = __builtin_shufflevector(__s0_69, __s0_69, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x8_t __rev1_69; __rev1_69 = __builtin_shufflevector(__s1_69, __s1_69, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x4_t __rev2_69; __rev2_69 = __builtin_shufflevector(__s2_69, __s2_69, 3, 2, 1, 0); \
- __ret_69 = __rev0_69 - __rev1_69 * __noswap_splatq_lane_u16(__rev2_69, __p3_69); \
- __ret_69 = __builtin_shufflevector(__ret_69, __ret_69, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_69; \
+#define vld3_dup_p8(__p0) __extension__ ({ \
+ poly8x8x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 4); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsq_lane_f32(__p0_70, __p1_70, __p2_70, __p3_70) __extension__ ({ \
- float32x4_t __ret_70; \
- float32x4_t __s0_70 = __p0_70; \
- float32x4_t __s1_70 = __p1_70; \
- float32x2_t __s2_70 = __p2_70; \
- __ret_70 = __s0_70 - __s1_70 * splatq_lane_f32(__s2_70, __p3_70); \
- __ret_70; \
+#define vld3_dup_p16(__p0) __extension__ ({ \
+ poly16x4x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 5); \
+ __ret; \
})
#else
-#define vmlsq_lane_f32(__p0_71, __p1_71, __p2_71, __p3_71) __extension__ ({ \
- float32x4_t __ret_71; \
- float32x4_t __s0_71 = __p0_71; \
- float32x4_t __s1_71 = __p1_71; \
- float32x2_t __s2_71 = __p2_71; \
- float32x4_t __rev0_71; __rev0_71 = __builtin_shufflevector(__s0_71, __s0_71, 3, 2, 1, 0); \
- float32x4_t __rev1_71; __rev1_71 = __builtin_shufflevector(__s1_71, __s1_71, 3, 2, 1, 0); \
- float32x2_t __rev2_71; __rev2_71 = __builtin_shufflevector(__s2_71, __s2_71, 1, 0); \
- __ret_71 = __rev0_71 - __rev1_71 * __noswap_splatq_lane_f32(__rev2_71, __p3_71); \
- __ret_71 = __builtin_shufflevector(__ret_71, __ret_71, 3, 2, 1, 0); \
- __ret_71; \
+#define vld3_dup_p16(__p0) __extension__ ({ \
+ poly16x4x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 5); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsq_lane_s32(__p0_72, __p1_72, __p2_72, __p3_72) __extension__ ({ \
- int32x4_t __ret_72; \
- int32x4_t __s0_72 = __p0_72; \
- int32x4_t __s1_72 = __p1_72; \
- int32x2_t __s2_72 = __p2_72; \
- __ret_72 = __s0_72 - __s1_72 * splatq_lane_s32(__s2_72, __p3_72); \
- __ret_72; \
+#define vld3q_dup_p8(__p0) __extension__ ({ \
+ poly8x16x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 36); \
+ __ret; \
})
#else
-#define vmlsq_lane_s32(__p0_73, __p1_73, __p2_73, __p3_73) __extension__ ({ \
- int32x4_t __ret_73; \
- int32x4_t __s0_73 = __p0_73; \
- int32x4_t __s1_73 = __p1_73; \
- int32x2_t __s2_73 = __p2_73; \
- int32x4_t __rev0_73; __rev0_73 = __builtin_shufflevector(__s0_73, __s0_73, 3, 2, 1, 0); \
- int32x4_t __rev1_73; __rev1_73 = __builtin_shufflevector(__s1_73, __s1_73, 3, 2, 1, 0); \
- int32x2_t __rev2_73; __rev2_73 = __builtin_shufflevector(__s2_73, __s2_73, 1, 0); \
- __ret_73 = __rev0_73 - __rev1_73 * __noswap_splatq_lane_s32(__rev2_73, __p3_73); \
- __ret_73 = __builtin_shufflevector(__ret_73, __ret_73, 3, 2, 1, 0); \
- __ret_73; \
+#define vld3q_dup_p8(__p0) __extension__ ({ \
+ poly8x16x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 36); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsq_lane_s16(__p0_74, __p1_74, __p2_74, __p3_74) __extension__ ({ \
- int16x8_t __ret_74; \
- int16x8_t __s0_74 = __p0_74; \
- int16x8_t __s1_74 = __p1_74; \
- int16x4_t __s2_74 = __p2_74; \
- __ret_74 = __s0_74 - __s1_74 * splatq_lane_s16(__s2_74, __p3_74); \
- __ret_74; \
+#define vld3q_dup_p16(__p0) __extension__ ({ \
+ poly16x8x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 37); \
+ __ret; \
})
#else
-#define vmlsq_lane_s16(__p0_75, __p1_75, __p2_75, __p3_75) __extension__ ({ \
- int16x8_t __ret_75; \
- int16x8_t __s0_75 = __p0_75; \
- int16x8_t __s1_75 = __p1_75; \
- int16x4_t __s2_75 = __p2_75; \
- int16x8_t __rev0_75; __rev0_75 = __builtin_shufflevector(__s0_75, __s0_75, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1_75; __rev1_75 = __builtin_shufflevector(__s1_75, __s1_75, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x4_t __rev2_75; __rev2_75 = __builtin_shufflevector(__s2_75, __s2_75, 3, 2, 1, 0); \
- __ret_75 = __rev0_75 - __rev1_75 * __noswap_splatq_lane_s16(__rev2_75, __p3_75); \
- __ret_75 = __builtin_shufflevector(__ret_75, __ret_75, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_75; \
+#define vld3q_dup_p16(__p0) __extension__ ({ \
+ poly16x8x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 37); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmls_lane_u32(__p0_76, __p1_76, __p2_76, __p3_76) __extension__ ({ \
- uint32x2_t __ret_76; \
- uint32x2_t __s0_76 = __p0_76; \
- uint32x2_t __s1_76 = __p1_76; \
- uint32x2_t __s2_76 = __p2_76; \
- __ret_76 = __s0_76 - __s1_76 * splat_lane_u32(__s2_76, __p3_76); \
- __ret_76; \
+#define vld3q_dup_u8(__p0) __extension__ ({ \
+ uint8x16x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 48); \
+ __ret; \
})
#else
-#define vmls_lane_u32(__p0_77, __p1_77, __p2_77, __p3_77) __extension__ ({ \
- uint32x2_t __ret_77; \
- uint32x2_t __s0_77 = __p0_77; \
- uint32x2_t __s1_77 = __p1_77; \
- uint32x2_t __s2_77 = __p2_77; \
- uint32x2_t __rev0_77; __rev0_77 = __builtin_shufflevector(__s0_77, __s0_77, 1, 0); \
- uint32x2_t __rev1_77; __rev1_77 = __builtin_shufflevector(__s1_77, __s1_77, 1, 0); \
- uint32x2_t __rev2_77; __rev2_77 = __builtin_shufflevector(__s2_77, __s2_77, 1, 0); \
- __ret_77 = __rev0_77 - __rev1_77 * __noswap_splat_lane_u32(__rev2_77, __p3_77); \
- __ret_77 = __builtin_shufflevector(__ret_77, __ret_77, 1, 0); \
- __ret_77; \
+#define vld3q_dup_u8(__p0) __extension__ ({ \
+ uint8x16x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 48); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmls_lane_u16(__p0_78, __p1_78, __p2_78, __p3_78) __extension__ ({ \
- uint16x4_t __ret_78; \
- uint16x4_t __s0_78 = __p0_78; \
- uint16x4_t __s1_78 = __p1_78; \
- uint16x4_t __s2_78 = __p2_78; \
- __ret_78 = __s0_78 - __s1_78 * splat_lane_u16(__s2_78, __p3_78); \
- __ret_78; \
+#define vld3q_dup_u32(__p0) __extension__ ({ \
+ uint32x4x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 50); \
+ __ret; \
})
#else
-#define vmls_lane_u16(__p0_79, __p1_79, __p2_79, __p3_79) __extension__ ({ \
- uint16x4_t __ret_79; \
- uint16x4_t __s0_79 = __p0_79; \
- uint16x4_t __s1_79 = __p1_79; \
- uint16x4_t __s2_79 = __p2_79; \
- uint16x4_t __rev0_79; __rev0_79 = __builtin_shufflevector(__s0_79, __s0_79, 3, 2, 1, 0); \
- uint16x4_t __rev1_79; __rev1_79 = __builtin_shufflevector(__s1_79, __s1_79, 3, 2, 1, 0); \
- uint16x4_t __rev2_79; __rev2_79 = __builtin_shufflevector(__s2_79, __s2_79, 3, 2, 1, 0); \
- __ret_79 = __rev0_79 - __rev1_79 * __noswap_splat_lane_u16(__rev2_79, __p3_79); \
- __ret_79 = __builtin_shufflevector(__ret_79, __ret_79, 3, 2, 1, 0); \
- __ret_79; \
+#define vld3q_dup_u32(__p0) __extension__ ({ \
+ uint32x4x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 50); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmls_lane_f32(__p0_80, __p1_80, __p2_80, __p3_80) __extension__ ({ \
- float32x2_t __ret_80; \
- float32x2_t __s0_80 = __p0_80; \
- float32x2_t __s1_80 = __p1_80; \
- float32x2_t __s2_80 = __p2_80; \
- __ret_80 = __s0_80 - __s1_80 * splat_lane_f32(__s2_80, __p3_80); \
- __ret_80; \
+#define vld3q_dup_u64(__p0) __extension__ ({ \
+ uint64x2x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 51); \
+ __ret; \
})
#else
-#define vmls_lane_f32(__p0_81, __p1_81, __p2_81, __p3_81) __extension__ ({ \
- float32x2_t __ret_81; \
- float32x2_t __s0_81 = __p0_81; \
- float32x2_t __s1_81 = __p1_81; \
- float32x2_t __s2_81 = __p2_81; \
- float32x2_t __rev0_81; __rev0_81 = __builtin_shufflevector(__s0_81, __s0_81, 1, 0); \
- float32x2_t __rev1_81; __rev1_81 = __builtin_shufflevector(__s1_81, __s1_81, 1, 0); \
- float32x2_t __rev2_81; __rev2_81 = __builtin_shufflevector(__s2_81, __s2_81, 1, 0); \
- __ret_81 = __rev0_81 - __rev1_81 * __noswap_splat_lane_f32(__rev2_81, __p3_81); \
- __ret_81 = __builtin_shufflevector(__ret_81, __ret_81, 1, 0); \
- __ret_81; \
+#define vld3q_dup_u64(__p0) __extension__ ({ \
+ uint64x2x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 51); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmls_lane_s32(__p0_82, __p1_82, __p2_82, __p3_82) __extension__ ({ \
- int32x2_t __ret_82; \
- int32x2_t __s0_82 = __p0_82; \
- int32x2_t __s1_82 = __p1_82; \
- int32x2_t __s2_82 = __p2_82; \
- __ret_82 = __s0_82 - __s1_82 * splat_lane_s32(__s2_82, __p3_82); \
- __ret_82; \
+#define vld3q_dup_u16(__p0) __extension__ ({ \
+ uint16x8x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 49); \
+ __ret; \
})
#else
-#define vmls_lane_s32(__p0_83, __p1_83, __p2_83, __p3_83) __extension__ ({ \
- int32x2_t __ret_83; \
- int32x2_t __s0_83 = __p0_83; \
- int32x2_t __s1_83 = __p1_83; \
- int32x2_t __s2_83 = __p2_83; \
- int32x2_t __rev0_83; __rev0_83 = __builtin_shufflevector(__s0_83, __s0_83, 1, 0); \
- int32x2_t __rev1_83; __rev1_83 = __builtin_shufflevector(__s1_83, __s1_83, 1, 0); \
- int32x2_t __rev2_83; __rev2_83 = __builtin_shufflevector(__s2_83, __s2_83, 1, 0); \
- __ret_83 = __rev0_83 - __rev1_83 * __noswap_splat_lane_s32(__rev2_83, __p3_83); \
- __ret_83 = __builtin_shufflevector(__ret_83, __ret_83, 1, 0); \
- __ret_83; \
+#define vld3q_dup_u16(__p0) __extension__ ({ \
+ uint16x8x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 49); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmls_lane_s16(__p0_84, __p1_84, __p2_84, __p3_84) __extension__ ({ \
- int16x4_t __ret_84; \
- int16x4_t __s0_84 = __p0_84; \
- int16x4_t __s1_84 = __p1_84; \
- int16x4_t __s2_84 = __p2_84; \
- __ret_84 = __s0_84 - __s1_84 * splat_lane_s16(__s2_84, __p3_84); \
- __ret_84; \
+#define vld3q_dup_s8(__p0) __extension__ ({ \
+ int8x16x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 32); \
+ __ret; \
})
#else
-#define vmls_lane_s16(__p0_85, __p1_85, __p2_85, __p3_85) __extension__ ({ \
- int16x4_t __ret_85; \
- int16x4_t __s0_85 = __p0_85; \
- int16x4_t __s1_85 = __p1_85; \
- int16x4_t __s2_85 = __p2_85; \
- int16x4_t __rev0_85; __rev0_85 = __builtin_shufflevector(__s0_85, __s0_85, 3, 2, 1, 0); \
- int16x4_t __rev1_85; __rev1_85 = __builtin_shufflevector(__s1_85, __s1_85, 3, 2, 1, 0); \
- int16x4_t __rev2_85; __rev2_85 = __builtin_shufflevector(__s2_85, __s2_85, 3, 2, 1, 0); \
- __ret_85 = __rev0_85 - __rev1_85 * __noswap_splat_lane_s16(__rev2_85, __p3_85); \
- __ret_85 = __builtin_shufflevector(__ret_85, __ret_85, 3, 2, 1, 0); \
- __ret_85; \
+#define vld3q_dup_s8(__p0) __extension__ ({ \
+ int8x16x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 32); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmlsq_n_u32(uint32x4_t __p0, uint32x4_t __p1, uint32_t __p2) {
- uint32x4_t __ret;
- __ret = __p0 - __p1 * (uint32x4_t) {__p2, __p2, __p2, __p2};
- return __ret;
-}
+#define vld3q_dup_f32(__p0) __extension__ ({ \
+ float32x4x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 41); \
+ __ret; \
+})
#else
-__ai uint32x4_t vmlsq_n_u32(uint32x4_t __p0, uint32x4_t __p1, uint32_t __p2) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 - __rev1 * (uint32x4_t) {__p2, __p2, __p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3q_dup_f32(__p0) __extension__ ({ \
+ float32x4x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 41); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vmlsq_n_u16(uint16x8_t __p0, uint16x8_t __p1, uint16_t __p2) {
- uint16x8_t __ret;
- __ret = __p0 - __p1 * (uint16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
- return __ret;
-}
+#define vld3q_dup_s32(__p0) __extension__ ({ \
+ int32x4x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 34); \
+ __ret; \
+})
#else
-__ai uint16x8_t vmlsq_n_u16(uint16x8_t __p0, uint16x8_t __p1, uint16_t __p2) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __rev1 * (uint16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3q_dup_s32(__p0) __extension__ ({ \
+ int32x4x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 34); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vmlsq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
- float32x4_t __ret;
- __ret = __p0 - __p1 * (float32x4_t) {__p2, __p2, __p2, __p2};
- return __ret;
-}
+#define vld3q_dup_s64(__p0) __extension__ ({ \
+ int64x2x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 35); \
+ __ret; \
+})
#else
-__ai float32x4_t vmlsq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 - __rev1 * (float32x4_t) {__p2, __p2, __p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3q_dup_s64(__p0) __extension__ ({ \
+ int64x2x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 35); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmlsq_n_s32(int32x4_t __p0, int32x4_t __p1, int32_t __p2) {
- int32x4_t __ret;
- __ret = __p0 - __p1 * (int32x4_t) {__p2, __p2, __p2, __p2};
- return __ret;
-}
+#define vld3q_dup_s16(__p0) __extension__ ({ \
+ int16x8x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 33); \
+ __ret; \
+})
#else
-__ai int32x4_t vmlsq_n_s32(int32x4_t __p0, int32x4_t __p1, int32_t __p2) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 - __rev1 * (int32x4_t) {__p2, __p2, __p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3q_dup_s16(__p0) __extension__ ({ \
+ int16x8x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 33); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vmlsq_n_s16(int16x8_t __p0, int16x8_t __p1, int16_t __p2) {
- int16x8_t __ret;
- __ret = __p0 - __p1 * (int16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
- return __ret;
-}
+#define vld3_dup_u8(__p0) __extension__ ({ \
+ uint8x8x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 16); \
+ __ret; \
+})
#else
-__ai int16x8_t vmlsq_n_s16(int16x8_t __p0, int16x8_t __p1, int16_t __p2) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __rev1 * (int16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3_dup_u8(__p0) __extension__ ({ \
+ uint8x8x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 16); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vmls_n_u32(uint32x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
- uint32x2_t __ret;
- __ret = __p0 - __p1 * (uint32x2_t) {__p2, __p2};
- return __ret;
-}
+#define vld3_dup_u32(__p0) __extension__ ({ \
+ uint32x2x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 18); \
+ __ret; \
+})
#else
-__ai uint32x2_t vmls_n_u32(uint32x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 - __rev1 * (uint32x2_t) {__p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld3_dup_u32(__p0) __extension__ ({ \
+ uint32x2x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 18); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
+})
#endif
+#define vld3_dup_u64(__p0) __extension__ ({ \
+ uint64x1x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 19); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vmls_n_u16(uint16x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
- uint16x4_t __ret;
- __ret = __p0 - __p1 * (uint16x4_t) {__p2, __p2, __p2, __p2};
- return __ret;
-}
+#define vld3_dup_u16(__p0) __extension__ ({ \
+ uint16x4x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 17); \
+ __ret; \
+})
#else
-__ai uint16x4_t vmls_n_u16(uint16x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 - __rev1 * (uint16x4_t) {__p2, __p2, __p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3_dup_u16(__p0) __extension__ ({ \
+ uint16x4x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 17); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vmls_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
- float32x2_t __ret;
- __ret = __p0 - __p1 * (float32x2_t) {__p2, __p2};
- return __ret;
-}
+#define vld3_dup_s8(__p0) __extension__ ({ \
+ int8x8x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 0); \
+ __ret; \
+})
#else
-__ai float32x2_t vmls_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 - __rev1 * (float32x2_t) {__p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld3_dup_s8(__p0) __extension__ ({ \
+ int8x8x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 0); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vmls_n_s32(int32x2_t __p0, int32x2_t __p1, int32_t __p2) {
- int32x2_t __ret;
- __ret = __p0 - __p1 * (int32x2_t) {__p2, __p2};
- return __ret;
-}
+#define vld3_dup_f32(__p0) __extension__ ({ \
+ float32x2x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 9); \
+ __ret; \
+})
#else
-__ai int32x2_t vmls_n_s32(int32x2_t __p0, int32x2_t __p1, int32_t __p2) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 - __rev1 * (int32x2_t) {__p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld3_dup_f32(__p0) __extension__ ({ \
+ float32x2x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 9); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vmls_n_s16(int16x4_t __p0, int16x4_t __p1, int16_t __p2) {
- int16x4_t __ret;
- __ret = __p0 - __p1 * (int16x4_t) {__p2, __p2, __p2, __p2};
- return __ret;
-}
+#define vld3_dup_s32(__p0) __extension__ ({ \
+ int32x2x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 2); \
+ __ret; \
+})
#else
-__ai int16x4_t vmls_n_s16(int16x4_t __p0, int16x4_t __p1, int16_t __p2) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 - __rev1 * (int16x4_t) {__p2, __p2, __p2, __p2};
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3_dup_s32(__p0) __extension__ ({ \
+ int32x2x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 2); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
+})
#endif
+#define vld3_dup_s64(__p0) __extension__ ({ \
+ int64x1x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 3); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vmov_n_p8(poly8_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- return __ret;
-}
+#define vld3_dup_s16(__p0) __extension__ ({ \
+ int16x4x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 1); \
+ __ret; \
+})
#else
-__ai poly8x8_t vmov_n_p8(poly8_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3_dup_s16(__p0) __extension__ ({ \
+ int16x4x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 1); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x4_t vmov_n_p16(poly16_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t) {__p0, __p0, __p0, __p0};
- return __ret;
-}
+#define vld3_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8x3_t __ret; \
+ poly8x8x3_t __s1 = __p1; \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 4); \
+ __ret; \
+})
#else
-__ai poly16x4_t vmov_n_p16(poly16_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t) {__p0, __p0, __p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8x3_t __ret; \
+ poly8x8x3_t __s1 = __p1; \
+ poly8x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 4); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vmovq_n_p8(poly8_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- return __ret;
-}
+#define vld3_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4x3_t __ret; \
+ poly16x4x3_t __s1 = __p1; \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 5); \
+ __ret; \
+})
#else
-__ai poly8x16_t vmovq_n_p8(poly8_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4x3_t __ret; \
+ poly16x4x3_t __s1 = __p1; \
+ poly16x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 5); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x8_t vmovq_n_p16(poly16_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- return __ret;
-}
+#define vld3q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8x3_t __ret; \
+ poly16x8x3_t __s1 = __p1; \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 37); \
+ __ret; \
+})
#else
-__ai poly16x8_t vmovq_n_p16(poly16_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8x3_t __ret; \
+ poly16x8x3_t __s1 = __p1; \
+ poly16x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 37); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vmovq_n_u8(uint8_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- return __ret;
-}
+#define vld3q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4x3_t __ret; \
+ uint32x4x3_t __s1 = __p1; \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 50); \
+ __ret; \
+})
#else
-__ai uint8x16_t vmovq_n_u8(uint8_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4x3_t __ret; \
+ uint32x4x3_t __s1 = __p1; \
+ uint32x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 50); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmovq_n_u32(uint32_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) {__p0, __p0, __p0, __p0};
- return __ret;
-}
+#define vld3q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8x3_t __ret; \
+ uint16x8x3_t __s1 = __p1; \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 49); \
+ __ret; \
+})
#else
-__ai uint32x4_t vmovq_n_u32(uint32_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) {__p0, __p0, __p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8x3_t __ret; \
+ uint16x8x3_t __s1 = __p1; \
+ uint16x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 49); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vmovq_n_u64(uint64_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) {__p0, __p0};
- return __ret;
-}
+#define vld3q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4x3_t __ret; \
+ float32x4x3_t __s1 = __p1; \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 41); \
+ __ret; \
+})
#else
-__ai uint64x2_t vmovq_n_u64(uint64_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) {__p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld3q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4x3_t __ret; \
+ float32x4x3_t __s1 = __p1; \
+ float32x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 41); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vmovq_n_u16(uint16_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- return __ret;
-}
+#define vld3q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4x3_t __ret; \
+ int32x4x3_t __s1 = __p1; \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 34); \
+ __ret; \
+})
#else
-__ai uint16x8_t vmovq_n_u16(uint16_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4x3_t __ret; \
+ int32x4x3_t __s1 = __p1; \
+ int32x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 34); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vmovq_n_s8(int8_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- return __ret;
-}
+#define vld3q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8x3_t __ret; \
+ int16x8x3_t __s1 = __p1; \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 33); \
+ __ret; \
+})
#else
-__ai int8x16_t vmovq_n_s8(int8_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8x3_t __ret; \
+ int16x8x3_t __s1 = __p1; \
+ int16x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 33); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vmovq_n_f32(float32_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t) {__p0, __p0, __p0, __p0};
- return __ret;
-}
+#define vld3_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8x3_t __ret; \
+ uint8x8x3_t __s1 = __p1; \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 16); \
+ __ret; \
+})
#else
-__ai float32x4_t vmovq_n_f32(float32_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t) {__p0, __p0, __p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8x3_t __ret; \
+ uint8x8x3_t __s1 = __p1; \
+ uint8x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 16); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmovq_n_f16(__p0) __extension__ ({ \
- float16x8_t __ret; \
- float16_t __s0 = __p0; \
- __ret = (float16x8_t) {__s0, __s0, __s0, __s0, __s0, __s0, __s0, __s0}; \
+#define vld3_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2x3_t __ret; \
+ uint32x2x3_t __s1 = __p1; \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 18); \
__ret; \
})
#else
-#define vmovq_n_f16(__p0) __extension__ ({ \
- float16x8_t __ret; \
- float16_t __s0 = __p0; \
- __ret = (float16x8_t) {__s0, __s0, __s0, __s0, __s0, __s0, __s0, __s0}; \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vld3_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2x3_t __ret; \
+ uint32x2x3_t __s1 = __p1; \
+ uint32x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 18); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmovq_n_s32(int32_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t) {__p0, __p0, __p0, __p0};
- return __ret;
-}
+#define vld3_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4x3_t __ret; \
+ uint16x4x3_t __s1 = __p1; \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 17); \
+ __ret; \
+})
#else
-__ai int32x4_t vmovq_n_s32(int32_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t) {__p0, __p0, __p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4x3_t __ret; \
+ uint16x4x3_t __s1 = __p1; \
+ uint16x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 17); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vmovq_n_s64(int64_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t) {__p0, __p0};
- return __ret;
-}
+#define vld3_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8x3_t __ret; \
+ int8x8x3_t __s1 = __p1; \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 0); \
+ __ret; \
+})
#else
-__ai int64x2_t vmovq_n_s64(int64_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t) {__p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld3_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8x3_t __ret; \
+ int8x8x3_t __s1 = __p1; \
+ int8x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 0); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vmovq_n_s16(int16_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- return __ret;
-}
+#define vld3_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2x3_t __ret; \
+ float32x2x3_t __s1 = __p1; \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 9); \
+ __ret; \
+})
#else
-__ai int16x8_t vmovq_n_s16(int16_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2x3_t __ret; \
+ float32x2x3_t __s1 = __p1; \
+ float32x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 9); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vmov_n_u8(uint8_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- return __ret;
-}
+#define vld3_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2x3_t __ret; \
+ int32x2x3_t __s1 = __p1; \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 2); \
+ __ret; \
+})
#else
-__ai uint8x8_t vmov_n_u8(uint8_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld3_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2x3_t __ret; \
+ int32x2x3_t __s1 = __p1; \
+ int32x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 2); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vmov_n_u32(uint32_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) {__p0, __p0};
- return __ret;
-}
+#define vld3_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4x3_t __ret; \
+ int16x4x3_t __s1 = __p1; \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 1); \
+ __ret; \
+})
#else
-__ai uint32x2_t vmov_n_u32(uint32_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) {__p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld3_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4x3_t __ret; \
+ int16x4x3_t __s1 = __p1; \
+ int16x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 1); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
-__ai uint64x1_t vmov_n_u64(uint64_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) {__p0};
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vmov_n_u16(uint16_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) {__p0, __p0, __p0, __p0};
- return __ret;
-}
+#define vld4_p8(__p0) __extension__ ({ \
+ poly8x8x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 4); \
+ __ret; \
+})
#else
-__ai uint16x4_t vmov_n_u16(uint16_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) {__p0, __p0, __p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld4_p8(__p0) __extension__ ({ \
+ poly8x8x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 4); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vmov_n_s8(int8_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- return __ret;
-}
+#define vld4_p16(__p0) __extension__ ({ \
+ poly16x4x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 5); \
+ __ret; \
+})
#else
-__ai int8x8_t vmov_n_s8(int8_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld4_p16(__p0) __extension__ ({ \
+ poly16x4x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 5); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vmov_n_f32(float32_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t) {__p0, __p0};
- return __ret;
-}
+#define vld4q_p8(__p0) __extension__ ({ \
+ poly8x16x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 36); \
+ __ret; \
+})
#else
-__ai float32x2_t vmov_n_f32(float32_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t) {__p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld4q_p8(__p0) __extension__ ({ \
+ poly8x16x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 36); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmov_n_f16(__p0) __extension__ ({ \
- float16x4_t __ret; \
- float16_t __s0 = __p0; \
- __ret = (float16x4_t) {__s0, __s0, __s0, __s0}; \
+#define vld4q_p16(__p0) __extension__ ({ \
+ poly16x8x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 37); \
__ret; \
})
#else
-#define vmov_n_f16(__p0) __extension__ ({ \
- float16x4_t __ret; \
- float16_t __s0 = __p0; \
- __ret = (float16x4_t) {__s0, __s0, __s0, __s0}; \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+#define vld4q_p16(__p0) __extension__ ({ \
+ poly16x8x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 37); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vmov_n_s32(int32_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t) {__p0, __p0};
- return __ret;
-}
+#define vld4q_u8(__p0) __extension__ ({ \
+ uint8x16x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 48); \
+ __ret; \
+})
#else
-__ai int32x2_t vmov_n_s32(int32_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t) {__p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld4q_u8(__p0) __extension__ ({ \
+ uint8x16x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 48); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
-__ai int64x1_t vmov_n_s64(int64_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t) {__p0};
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vmov_n_s16(int16_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t) {__p0, __p0, __p0, __p0};
- return __ret;
-}
+#define vld4q_u32(__p0) __extension__ ({ \
+ uint32x4x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 50); \
+ __ret; \
+})
#else
-__ai int16x4_t vmov_n_s16(int16_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t) {__p0, __p0, __p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld4q_u32(__p0) __extension__ ({ \
+ uint32x4x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 50); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vmovl_u8(uint8x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 49);
- return __ret;
-}
+#define vld4q_u16(__p0) __extension__ ({ \
+ uint16x8x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 49); \
+ __ret; \
+})
#else
-__ai uint16x8_t vmovl_u8(uint8x8_t __p0) {
- uint16x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vmovl_v((int8x8_t)__rev0, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-__ai uint16x8_t __noswap_vmovl_u8(uint8x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 49);
- return __ret;
-}
+#define vld4q_u16(__p0) __extension__ ({ \
+ uint16x8x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 49); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vmovl_u32(uint32x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 51);
- return __ret;
-}
+#define vld4q_s8(__p0) __extension__ ({ \
+ int8x16x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 32); \
+ __ret; \
+})
#else
-__ai uint64x2_t vmovl_u32(uint32x2_t __p0) {
- uint64x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vmovl_v((int8x8_t)__rev0, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai uint64x2_t __noswap_vmovl_u32(uint32x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 51);
- return __ret;
-}
+#define vld4q_s8(__p0) __extension__ ({ \
+ int8x16x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 32); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmovl_u16(uint16x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 50);
- return __ret;
-}
+#define vld4q_f32(__p0) __extension__ ({ \
+ float32x4x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 41); \
+ __ret; \
+})
#else
-__ai uint32x4_t vmovl_u16(uint16x4_t __p0) {
- uint32x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vmovl_v((int8x8_t)__rev0, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai uint32x4_t __noswap_vmovl_u16(uint16x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 50);
- return __ret;
-}
+#define vld4q_f32(__p0) __extension__ ({ \
+ float32x4x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 41); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vmovl_s8(int8x8_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 33);
- return __ret;
-}
+#define vld4q_s32(__p0) __extension__ ({ \
+ int32x4x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 34); \
+ __ret; \
+})
#else
-__ai int16x8_t vmovl_s8(int8x8_t __p0) {
- int16x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vmovl_v((int8x8_t)__rev0, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-__ai int16x8_t __noswap_vmovl_s8(int8x8_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 33);
- return __ret;
-}
+#define vld4q_s32(__p0) __extension__ ({ \
+ int32x4x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 34); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vmovl_s32(int32x2_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 35);
- return __ret;
-}
+#define vld4q_s16(__p0) __extension__ ({ \
+ int16x8x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 33); \
+ __ret; \
+})
#else
-__ai int64x2_t vmovl_s32(int32x2_t __p0) {
- int64x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vmovl_v((int8x8_t)__rev0, 35);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai int64x2_t __noswap_vmovl_s32(int32x2_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 35);
- return __ret;
-}
+#define vld4q_s16(__p0) __extension__ ({ \
+ int16x8x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 33); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmovl_s16(int16x4_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 34);
- return __ret;
-}
+#define vld4_u8(__p0) __extension__ ({ \
+ uint8x8x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 16); \
+ __ret; \
+})
#else
-__ai int32x4_t vmovl_s16(int16x4_t __p0) {
- int32x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vmovl_v((int8x8_t)__rev0, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai int32x4_t __noswap_vmovl_s16(int16x4_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 34);
- return __ret;
-}
+#define vld4_u8(__p0) __extension__ ({ \
+ uint8x8x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 16); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vmovn_u32(uint32x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 17);
- return __ret;
-}
+#define vld4_u32(__p0) __extension__ ({ \
+ uint32x2x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 18); \
+ __ret; \
+})
#else
-__ai uint16x4_t vmovn_u32(uint32x4_t __p0) {
- uint16x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vmovn_v((int8x16_t)__rev0, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai uint16x4_t __noswap_vmovn_u32(uint32x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 17);
- return __ret;
-}
+#define vld4_u32(__p0) __extension__ ({ \
+ uint32x2x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 18); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
+})
#endif
+#define vld4_u64(__p0) __extension__ ({ \
+ uint64x1x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 19); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vmovn_u64(uint64x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 18);
- return __ret;
-}
+#define vld4_u16(__p0) __extension__ ({ \
+ uint16x4x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 17); \
+ __ret; \
+})
#else
-__ai uint32x2_t vmovn_u64(uint64x2_t __p0) {
- uint32x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vmovn_v((int8x16_t)__rev0, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai uint32x2_t __noswap_vmovn_u64(uint64x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 18);
- return __ret;
-}
+#define vld4_u16(__p0) __extension__ ({ \
+ uint16x4x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 17); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vmovn_u16(uint16x8_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 16);
- return __ret;
-}
+#define vld4_s8(__p0) __extension__ ({ \
+ int8x8x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 0); \
+ __ret; \
+})
#else
-__ai uint8x8_t vmovn_u16(uint16x8_t __p0) {
- uint8x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vmovn_v((int8x16_t)__rev0, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-__ai uint8x8_t __noswap_vmovn_u16(uint16x8_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 16);
- return __ret;
-}
+#define vld4_s8(__p0) __extension__ ({ \
+ int8x8x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 0); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vmovn_s32(int32x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 1);
- return __ret;
-}
+#define vld4_f32(__p0) __extension__ ({ \
+ float32x2x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 9); \
+ __ret; \
+})
#else
-__ai int16x4_t vmovn_s32(int32x4_t __p0) {
- int16x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vmovn_v((int8x16_t)__rev0, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai int16x4_t __noswap_vmovn_s32(int32x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 1);
- return __ret;
-}
+#define vld4_f32(__p0) __extension__ ({ \
+ float32x2x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 9); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vmovn_s64(int64x2_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 2);
- return __ret;
-}
+#define vld4_s32(__p0) __extension__ ({ \
+ int32x2x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 2); \
+ __ret; \
+})
#else
-__ai int32x2_t vmovn_s64(int64x2_t __p0) {
- int32x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vmovn_v((int8x16_t)__rev0, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai int32x2_t __noswap_vmovn_s64(int64x2_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 2);
- return __ret;
-}
+#define vld4_s32(__p0) __extension__ ({ \
+ int32x2x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 2); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
+})
#endif
+#define vld4_s64(__p0) __extension__ ({ \
+ int64x1x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 3); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vmovn_s16(int16x8_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 0);
- return __ret;
-}
+#define vld4_s16(__p0) __extension__ ({ \
+ int16x4x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 1); \
+ __ret; \
+})
#else
-__ai int8x8_t vmovn_s16(int16x8_t __p0) {
- int8x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vmovn_v((int8x16_t)__rev0, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-__ai int8x8_t __noswap_vmovn_s16(int16x8_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 0);
- return __ret;
-}
+#define vld4_s16(__p0) __extension__ ({ \
+ int16x4x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 1); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vmulq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = __p0 * __p1;
- return __ret;
-}
+#define vld4_dup_p8(__p0) __extension__ ({ \
+ poly8x8x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 4); \
+ __ret; \
+})
#else
-__ai uint8x16_t vmulq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 * __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld4_dup_p8(__p0) __extension__ ({ \
+ poly8x8x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 4); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmulq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = __p0 * __p1;
- return __ret;
-}
+#define vld4_dup_p16(__p0) __extension__ ({ \
+ poly16x4x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 5); \
+ __ret; \
+})
#else
-__ai uint32x4_t vmulq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 * __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vmulq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = __p0 * __p1;
- return __ret;
-}
-#else
-__ai uint16x8_t vmulq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 * __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vmulq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = __p0 * __p1;
- return __ret;
-}
-#else
-__ai int8x16_t vmulq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 * __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vmulq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = __p0 * __p1;
- return __ret;
-}
-#else
-__ai float32x4_t vmulq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 * __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld4_dup_p16(__p0) __extension__ ({ \
+ poly16x4x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 5); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmulq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = __p0 * __p1;
- return __ret;
-}
+#define vld4q_dup_p8(__p0) __extension__ ({ \
+ poly8x16x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 36); \
+ __ret; \
+})
#else
-__ai int32x4_t vmulq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 * __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld4q_dup_p8(__p0) __extension__ ({ \
+ poly8x16x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 36); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vmulq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = __p0 * __p1;
- return __ret;
-}
+#define vld4q_dup_p16(__p0) __extension__ ({ \
+ poly16x8x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 37); \
+ __ret; \
+})
#else
-__ai int16x8_t vmulq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 * __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld4q_dup_p16(__p0) __extension__ ({ \
+ poly16x8x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 37); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vmul_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = __p0 * __p1;
- return __ret;
-}
+#define vld4q_dup_u8(__p0) __extension__ ({ \
+ uint8x16x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 48); \
+ __ret; \
+})
#else
-__ai uint8x8_t vmul_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 * __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld4q_dup_u8(__p0) __extension__ ({ \
+ uint8x16x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 48); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vmul_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = __p0 * __p1;
- return __ret;
-}
+#define vld4q_dup_u32(__p0) __extension__ ({ \
+ uint32x4x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 50); \
+ __ret; \
+})
#else
-__ai uint32x2_t vmul_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 * __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld4q_dup_u32(__p0) __extension__ ({ \
+ uint32x4x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 50); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vmul_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = __p0 * __p1;
- return __ret;
-}
+#define vld4q_dup_u64(__p0) __extension__ ({ \
+ uint64x2x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 51); \
+ __ret; \
+})
#else
-__ai uint16x4_t vmul_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 * __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld4q_dup_u64(__p0) __extension__ ({ \
+ uint64x2x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 51); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vmul_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = __p0 * __p1;
- return __ret;
-}
+#define vld4q_dup_u16(__p0) __extension__ ({ \
+ uint16x8x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 49); \
+ __ret; \
+})
#else
-__ai int8x8_t vmul_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 * __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld4q_dup_u16(__p0) __extension__ ({ \
+ uint16x8x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 49); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vmul_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = __p0 * __p1;
- return __ret;
-}
+#define vld4q_dup_s8(__p0) __extension__ ({ \
+ int8x16x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 32); \
+ __ret; \
+})
#else
-__ai float32x2_t vmul_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 * __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld4q_dup_s8(__p0) __extension__ ({ \
+ int8x16x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 32); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vmul_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = __p0 * __p1;
- return __ret;
-}
+#define vld4q_dup_f32(__p0) __extension__ ({ \
+ float32x4x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 41); \
+ __ret; \
+})
#else
-__ai int32x2_t vmul_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 * __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld4q_dup_f32(__p0) __extension__ ({ \
+ float32x4x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 41); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vmul_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = __p0 * __p1;
- return __ret;
-}
+#define vld4q_dup_s32(__p0) __extension__ ({ \
+ int32x4x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 34); \
+ __ret; \
+})
#else
-__ai int16x4_t vmul_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 * __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vld4q_dup_s32(__p0) __extension__ ({ \
+ int32x4x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 34); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vmul_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vmul_v((int8x8_t)__p0, (int8x8_t)__p1, 4);
- return __ret;
-}
+#define vld4q_dup_s64(__p0) __extension__ ({ \
+ int64x2x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 35); \
+ __ret; \
+})
#else
-__ai poly8x8_t vmul_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vmul_v((int8x8_t)__rev0, (int8x8_t)__rev1, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld4q_dup_s64(__p0) __extension__ ({ \
+ int64x2x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 35); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vmulq_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly8x16_t __ret;
- __ret = (poly8x16_t) __builtin_neon_vmulq_v((int8x16_t)__p0, (int8x16_t)__p1, 36);
- return __ret;
-}
+#define vld4q_dup_s16(__p0) __extension__ ({ \
+ int16x8x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 33); \
+ __ret; \
+})
#else
-__ai poly8x16_t vmulq_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x16_t) __builtin_neon_vmulq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 36);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vld4q_dup_s16(__p0) __extension__ ({ \
+ int16x8x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 33); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulq_lane_u32(__p0_86, __p1_86, __p2_86) __extension__ ({ \
- uint32x4_t __ret_86; \
- uint32x4_t __s0_86 = __p0_86; \
- uint32x2_t __s1_86 = __p1_86; \
- __ret_86 = __s0_86 * splatq_lane_u32(__s1_86, __p2_86); \
- __ret_86; \
+#define vld4_dup_u8(__p0) __extension__ ({ \
+ uint8x8x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 16); \
+ __ret; \
})
#else
-#define vmulq_lane_u32(__p0_87, __p1_87, __p2_87) __extension__ ({ \
- uint32x4_t __ret_87; \
- uint32x4_t __s0_87 = __p0_87; \
- uint32x2_t __s1_87 = __p1_87; \
- uint32x4_t __rev0_87; __rev0_87 = __builtin_shufflevector(__s0_87, __s0_87, 3, 2, 1, 0); \
- uint32x2_t __rev1_87; __rev1_87 = __builtin_shufflevector(__s1_87, __s1_87, 1, 0); \
- __ret_87 = __rev0_87 * __noswap_splatq_lane_u32(__rev1_87, __p2_87); \
- __ret_87 = __builtin_shufflevector(__ret_87, __ret_87, 3, 2, 1, 0); \
- __ret_87; \
+#define vld4_dup_u8(__p0) __extension__ ({ \
+ uint8x8x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 16); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulq_lane_u16(__p0_88, __p1_88, __p2_88) __extension__ ({ \
- uint16x8_t __ret_88; \
- uint16x8_t __s0_88 = __p0_88; \
- uint16x4_t __s1_88 = __p1_88; \
- __ret_88 = __s0_88 * splatq_lane_u16(__s1_88, __p2_88); \
- __ret_88; \
+#define vld4_dup_u32(__p0) __extension__ ({ \
+ uint32x2x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 18); \
+ __ret; \
})
#else
-#define vmulq_lane_u16(__p0_89, __p1_89, __p2_89) __extension__ ({ \
- uint16x8_t __ret_89; \
- uint16x8_t __s0_89 = __p0_89; \
- uint16x4_t __s1_89 = __p1_89; \
- uint16x8_t __rev0_89; __rev0_89 = __builtin_shufflevector(__s0_89, __s0_89, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x4_t __rev1_89; __rev1_89 = __builtin_shufflevector(__s1_89, __s1_89, 3, 2, 1, 0); \
- __ret_89 = __rev0_89 * __noswap_splatq_lane_u16(__rev1_89, __p2_89); \
- __ret_89 = __builtin_shufflevector(__ret_89, __ret_89, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_89; \
+#define vld4_dup_u32(__p0) __extension__ ({ \
+ uint32x2x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 18); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
})
#endif
+#define vld4_dup_u64(__p0) __extension__ ({ \
+ uint64x1x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 19); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vmulq_lane_f32(__p0_90, __p1_90, __p2_90) __extension__ ({ \
- float32x4_t __ret_90; \
- float32x4_t __s0_90 = __p0_90; \
- float32x2_t __s1_90 = __p1_90; \
- __ret_90 = __s0_90 * splatq_lane_f32(__s1_90, __p2_90); \
- __ret_90; \
+#define vld4_dup_u16(__p0) __extension__ ({ \
+ uint16x4x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 17); \
+ __ret; \
})
#else
-#define vmulq_lane_f32(__p0_91, __p1_91, __p2_91) __extension__ ({ \
- float32x4_t __ret_91; \
- float32x4_t __s0_91 = __p0_91; \
- float32x2_t __s1_91 = __p1_91; \
- float32x4_t __rev0_91; __rev0_91 = __builtin_shufflevector(__s0_91, __s0_91, 3, 2, 1, 0); \
- float32x2_t __rev1_91; __rev1_91 = __builtin_shufflevector(__s1_91, __s1_91, 1, 0); \
- __ret_91 = __rev0_91 * __noswap_splatq_lane_f32(__rev1_91, __p2_91); \
- __ret_91 = __builtin_shufflevector(__ret_91, __ret_91, 3, 2, 1, 0); \
- __ret_91; \
+#define vld4_dup_u16(__p0) __extension__ ({ \
+ uint16x4x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 17); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulq_lane_s32(__p0_92, __p1_92, __p2_92) __extension__ ({ \
- int32x4_t __ret_92; \
- int32x4_t __s0_92 = __p0_92; \
- int32x2_t __s1_92 = __p1_92; \
- __ret_92 = __s0_92 * splatq_lane_s32(__s1_92, __p2_92); \
- __ret_92; \
+#define vld4_dup_s8(__p0) __extension__ ({ \
+ int8x8x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 0); \
+ __ret; \
})
#else
-#define vmulq_lane_s32(__p0_93, __p1_93, __p2_93) __extension__ ({ \
- int32x4_t __ret_93; \
- int32x4_t __s0_93 = __p0_93; \
- int32x2_t __s1_93 = __p1_93; \
- int32x4_t __rev0_93; __rev0_93 = __builtin_shufflevector(__s0_93, __s0_93, 3, 2, 1, 0); \
- int32x2_t __rev1_93; __rev1_93 = __builtin_shufflevector(__s1_93, __s1_93, 1, 0); \
- __ret_93 = __rev0_93 * __noswap_splatq_lane_s32(__rev1_93, __p2_93); \
- __ret_93 = __builtin_shufflevector(__ret_93, __ret_93, 3, 2, 1, 0); \
- __ret_93; \
+#define vld4_dup_s8(__p0) __extension__ ({ \
+ int8x8x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 0); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulq_lane_s16(__p0_94, __p1_94, __p2_94) __extension__ ({ \
- int16x8_t __ret_94; \
- int16x8_t __s0_94 = __p0_94; \
- int16x4_t __s1_94 = __p1_94; \
- __ret_94 = __s0_94 * splatq_lane_s16(__s1_94, __p2_94); \
- __ret_94; \
+#define vld4_dup_f32(__p0) __extension__ ({ \
+ float32x2x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 9); \
+ __ret; \
})
#else
-#define vmulq_lane_s16(__p0_95, __p1_95, __p2_95) __extension__ ({ \
- int16x8_t __ret_95; \
- int16x8_t __s0_95 = __p0_95; \
- int16x4_t __s1_95 = __p1_95; \
- int16x8_t __rev0_95; __rev0_95 = __builtin_shufflevector(__s0_95, __s0_95, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x4_t __rev1_95; __rev1_95 = __builtin_shufflevector(__s1_95, __s1_95, 3, 2, 1, 0); \
- __ret_95 = __rev0_95 * __noswap_splatq_lane_s16(__rev1_95, __p2_95); \
- __ret_95 = __builtin_shufflevector(__ret_95, __ret_95, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_95; \
+#define vld4_dup_f32(__p0) __extension__ ({ \
+ float32x2x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 9); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmul_lane_u32(__p0_96, __p1_96, __p2_96) __extension__ ({ \
- uint32x2_t __ret_96; \
- uint32x2_t __s0_96 = __p0_96; \
- uint32x2_t __s1_96 = __p1_96; \
- __ret_96 = __s0_96 * splat_lane_u32(__s1_96, __p2_96); \
- __ret_96; \
+#define vld4_dup_s32(__p0) __extension__ ({ \
+ int32x2x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 2); \
+ __ret; \
})
#else
-#define vmul_lane_u32(__p0_97, __p1_97, __p2_97) __extension__ ({ \
- uint32x2_t __ret_97; \
- uint32x2_t __s0_97 = __p0_97; \
- uint32x2_t __s1_97 = __p1_97; \
- uint32x2_t __rev0_97; __rev0_97 = __builtin_shufflevector(__s0_97, __s0_97, 1, 0); \
- uint32x2_t __rev1_97; __rev1_97 = __builtin_shufflevector(__s1_97, __s1_97, 1, 0); \
- __ret_97 = __rev0_97 * __noswap_splat_lane_u32(__rev1_97, __p2_97); \
- __ret_97 = __builtin_shufflevector(__ret_97, __ret_97, 1, 0); \
- __ret_97; \
+#define vld4_dup_s32(__p0) __extension__ ({ \
+ int32x2x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 2); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
})
#endif
+#define vld4_dup_s64(__p0) __extension__ ({ \
+ int64x1x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 3); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vmul_lane_u16(__p0_98, __p1_98, __p2_98) __extension__ ({ \
- uint16x4_t __ret_98; \
- uint16x4_t __s0_98 = __p0_98; \
- uint16x4_t __s1_98 = __p1_98; \
- __ret_98 = __s0_98 * splat_lane_u16(__s1_98, __p2_98); \
- __ret_98; \
+#define vld4_dup_s16(__p0) __extension__ ({ \
+ int16x4x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 1); \
+ __ret; \
})
#else
-#define vmul_lane_u16(__p0_99, __p1_99, __p2_99) __extension__ ({ \
- uint16x4_t __ret_99; \
- uint16x4_t __s0_99 = __p0_99; \
- uint16x4_t __s1_99 = __p1_99; \
- uint16x4_t __rev0_99; __rev0_99 = __builtin_shufflevector(__s0_99, __s0_99, 3, 2, 1, 0); \
- uint16x4_t __rev1_99; __rev1_99 = __builtin_shufflevector(__s1_99, __s1_99, 3, 2, 1, 0); \
- __ret_99 = __rev0_99 * __noswap_splat_lane_u16(__rev1_99, __p2_99); \
- __ret_99 = __builtin_shufflevector(__ret_99, __ret_99, 3, 2, 1, 0); \
- __ret_99; \
+#define vld4_dup_s16(__p0) __extension__ ({ \
+ int16x4x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 1); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmul_lane_f32(__p0_100, __p1_100, __p2_100) __extension__ ({ \
- float32x2_t __ret_100; \
- float32x2_t __s0_100 = __p0_100; \
- float32x2_t __s1_100 = __p1_100; \
- __ret_100 = __s0_100 * splat_lane_f32(__s1_100, __p2_100); \
- __ret_100; \
+#define vld4_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8x4_t __ret; \
+ poly8x8x4_t __s1 = __p1; \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 4); \
+ __ret; \
})
#else
-#define vmul_lane_f32(__p0_101, __p1_101, __p2_101) __extension__ ({ \
- float32x2_t __ret_101; \
- float32x2_t __s0_101 = __p0_101; \
- float32x2_t __s1_101 = __p1_101; \
- float32x2_t __rev0_101; __rev0_101 = __builtin_shufflevector(__s0_101, __s0_101, 1, 0); \
- float32x2_t __rev1_101; __rev1_101 = __builtin_shufflevector(__s1_101, __s1_101, 1, 0); \
- __ret_101 = __rev0_101 * __noswap_splat_lane_f32(__rev1_101, __p2_101); \
- __ret_101 = __builtin_shufflevector(__ret_101, __ret_101, 1, 0); \
- __ret_101; \
+#define vld4_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8x4_t __ret; \
+ poly8x8x4_t __s1 = __p1; \
+ poly8x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 4); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmul_lane_s32(__p0_102, __p1_102, __p2_102) __extension__ ({ \
- int32x2_t __ret_102; \
- int32x2_t __s0_102 = __p0_102; \
- int32x2_t __s1_102 = __p1_102; \
- __ret_102 = __s0_102 * splat_lane_s32(__s1_102, __p2_102); \
- __ret_102; \
+#define vld4_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4x4_t __ret; \
+ poly16x4x4_t __s1 = __p1; \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 5); \
+ __ret; \
})
#else
-#define vmul_lane_s32(__p0_103, __p1_103, __p2_103) __extension__ ({ \
- int32x2_t __ret_103; \
- int32x2_t __s0_103 = __p0_103; \
- int32x2_t __s1_103 = __p1_103; \
- int32x2_t __rev0_103; __rev0_103 = __builtin_shufflevector(__s0_103, __s0_103, 1, 0); \
- int32x2_t __rev1_103; __rev1_103 = __builtin_shufflevector(__s1_103, __s1_103, 1, 0); \
- __ret_103 = __rev0_103 * __noswap_splat_lane_s32(__rev1_103, __p2_103); \
- __ret_103 = __builtin_shufflevector(__ret_103, __ret_103, 1, 0); \
- __ret_103; \
+#define vld4_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4x4_t __ret; \
+ poly16x4x4_t __s1 = __p1; \
+ poly16x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 5); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmul_lane_s16(__p0_104, __p1_104, __p2_104) __extension__ ({ \
- int16x4_t __ret_104; \
- int16x4_t __s0_104 = __p0_104; \
- int16x4_t __s1_104 = __p1_104; \
- __ret_104 = __s0_104 * splat_lane_s16(__s1_104, __p2_104); \
- __ret_104; \
-})
+#define vld4q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8x4_t __ret; \
+ poly16x8x4_t __s1 = __p1; \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 37); \
+ __ret; \
+})
#else
-#define vmul_lane_s16(__p0_105, __p1_105, __p2_105) __extension__ ({ \
- int16x4_t __ret_105; \
- int16x4_t __s0_105 = __p0_105; \
- int16x4_t __s1_105 = __p1_105; \
- int16x4_t __rev0_105; __rev0_105 = __builtin_shufflevector(__s0_105, __s0_105, 3, 2, 1, 0); \
- int16x4_t __rev1_105; __rev1_105 = __builtin_shufflevector(__s1_105, __s1_105, 3, 2, 1, 0); \
- __ret_105 = __rev0_105 * __noswap_splat_lane_s16(__rev1_105, __p2_105); \
- __ret_105 = __builtin_shufflevector(__ret_105, __ret_105, 3, 2, 1, 0); \
- __ret_105; \
+#define vld4q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8x4_t __ret; \
+ poly16x8x4_t __s1 = __p1; \
+ poly16x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 37); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4x4_t __ret; \
+ uint32x4x4_t __s1 = __p1; \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 50); \
+ __ret; \
+})
+#else
+#define vld4q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4x4_t __ret; \
+ uint32x4x4_t __s1 = __p1; \
+ uint32x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 50); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8x4_t __ret; \
+ uint16x8x4_t __s1 = __p1; \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 49); \
+ __ret; \
+})
+#else
+#define vld4q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8x4_t __ret; \
+ uint16x8x4_t __s1 = __p1; \
+ uint16x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 49); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4x4_t __ret; \
+ float32x4x4_t __s1 = __p1; \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 41); \
+ __ret; \
+})
+#else
+#define vld4q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4x4_t __ret; \
+ float32x4x4_t __s1 = __p1; \
+ float32x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 41); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4x4_t __ret; \
+ int32x4x4_t __s1 = __p1; \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 34); \
+ __ret; \
+})
+#else
+#define vld4q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4x4_t __ret; \
+ int32x4x4_t __s1 = __p1; \
+ int32x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 34); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8x4_t __ret; \
+ int16x8x4_t __s1 = __p1; \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 33); \
+ __ret; \
+})
+#else
+#define vld4q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8x4_t __ret; \
+ int16x8x4_t __s1 = __p1; \
+ int16x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 33); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8x4_t __ret; \
+ uint8x8x4_t __s1 = __p1; \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 16); \
+ __ret; \
+})
+#else
+#define vld4_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8x4_t __ret; \
+ uint8x8x4_t __s1 = __p1; \
+ uint8x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 16); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2x4_t __ret; \
+ uint32x2x4_t __s1 = __p1; \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 18); \
+ __ret; \
+})
+#else
+#define vld4_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2x4_t __ret; \
+ uint32x2x4_t __s1 = __p1; \
+ uint32x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 18); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4x4_t __ret; \
+ uint16x4x4_t __s1 = __p1; \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 17); \
+ __ret; \
+})
+#else
+#define vld4_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4x4_t __ret; \
+ uint16x4x4_t __s1 = __p1; \
+ uint16x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 17); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8x4_t __ret; \
+ int8x8x4_t __s1 = __p1; \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 0); \
+ __ret; \
+})
+#else
+#define vld4_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8x4_t __ret; \
+ int8x8x4_t __s1 = __p1; \
+ int8x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 0); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmulq_n_u32(uint32x4_t __p0, uint32_t __p1) {
+#define vld4_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2x4_t __ret; \
+ float32x2x4_t __s1 = __p1; \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 9); \
+ __ret; \
+})
+#else
+#define vld4_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2x4_t __ret; \
+ float32x2x4_t __s1 = __p1; \
+ float32x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 9); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2x4_t __ret; \
+ int32x2x4_t __s1 = __p1; \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 2); \
+ __ret; \
+})
+#else
+#define vld4_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2x4_t __ret; \
+ int32x2x4_t __s1 = __p1; \
+ int32x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 2); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4x4_t __ret; \
+ int16x4x4_t __s1 = __p1; \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 1); \
+ __ret; \
+})
+#else
+#define vld4_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4x4_t __ret; \
+ int16x4x4_t __s1 = __p1; \
+ int16x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 1); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vmaxq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vmaxq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmaxq_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
- __ret = __p0 * (uint32x4_t) {__p1, __p1, __p1, __p1};
+ __ret = (uint32x4_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
return __ret;
}
#else
-__ai uint32x4_t vmulq_n_u32(uint32x4_t __p0, uint32_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vmaxq_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __rev0 * (uint32x4_t) {__p1, __p1, __p1, __p1};
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vmulq_n_u16(uint16x8_t __p0, uint16_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vmaxq_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint16x8_t __ret;
- __ret = __p0 * (uint16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1};
+ __ret = (uint16x8_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
return __ret;
}
#else
-__ai uint16x8_t vmulq_n_u16(uint16x8_t __p0, uint16_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vmaxq_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 * (uint16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1};
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vmulq_n_f32(float32x4_t __p0, float32_t __p1) {
+__ai __attribute__((target("neon"))) int8x16_t vmaxq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vmaxq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vmaxq_f32(float32x4_t __p0, float32x4_t __p1) {
float32x4_t __ret;
- __ret = __p0 * (float32x4_t) {__p1, __p1, __p1, __p1};
+ __ret = (float32x4_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
return __ret;
}
#else
-__ai float32x4_t vmulq_n_f32(float32x4_t __p0, float32_t __p1) {
+__ai __attribute__((target("neon"))) float32x4_t vmaxq_f32(float32x4_t __p0, float32x4_t __p1) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __rev0 * (float32x4_t) {__p1, __p1, __p1, __p1};
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmulq_n_s32(int32x4_t __p0, int32_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vmaxq_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
- __ret = __p0 * (int32x4_t) {__p1, __p1, __p1, __p1};
+ __ret = (int32x4_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
return __ret;
}
#else
-__ai int32x4_t vmulq_n_s32(int32x4_t __p0, int32_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vmaxq_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __rev0 * (int32x4_t) {__p1, __p1, __p1, __p1};
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vmulq_n_s16(int16x8_t __p0, int16_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vmaxq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
- __ret = __p0 * (int16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1};
+ __ret = (int16x8_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
return __ret;
}
#else
-__ai int16x8_t vmulq_n_s16(int16x8_t __p0, int16_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vmaxq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 * (int16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1};
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vmax_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vmax_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vmul_n_u32(uint32x2_t __p0, uint32_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vmax_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint32x2_t __ret;
- __ret = __p0 * (uint32x2_t) {__p1, __p1};
+ __ret = (uint32x2_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
return __ret;
}
#else
-__ai uint32x2_t vmul_n_u32(uint32x2_t __p0, uint32_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vmax_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __rev0 * (uint32x2_t) {__p1, __p1};
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vmul_n_u16(uint16x4_t __p0, uint16_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vmax_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint16x4_t __ret;
- __ret = __p0 * (uint16x4_t) {__p1, __p1, __p1, __p1};
+ __ret = (uint16x4_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
return __ret;
}
#else
-__ai uint16x4_t vmul_n_u16(uint16x4_t __p0, uint16_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vmax_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __rev0 * (uint16x4_t) {__p1, __p1, __p1, __p1};
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vmul_n_f32(float32x2_t __p0, float32_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vmax_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vmax_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vmax_f32(float32x2_t __p0, float32x2_t __p1) {
float32x2_t __ret;
- __ret = __p0 * (float32x2_t) {__p1, __p1};
+ __ret = (float32x2_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
return __ret;
}
#else
-__ai float32x2_t vmul_n_f32(float32x2_t __p0, float32_t __p1) {
+__ai __attribute__((target("neon"))) float32x2_t vmax_f32(float32x2_t __p0, float32x2_t __p1) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __rev0 * (float32x2_t) {__p1, __p1};
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vmul_n_s32(int32x2_t __p0, int32_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vmax_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
- __ret = __p0 * (int32x2_t) {__p1, __p1};
+ __ret = (int32x2_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
return __ret;
}
#else
-__ai int32x2_t vmul_n_s32(int32x2_t __p0, int32_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vmax_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __rev0 * (int32x2_t) {__p1, __p1};
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vmul_n_s16(int16x4_t __p0, int16_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vmax_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
- __ret = __p0 * (int16x4_t) {__p1, __p1, __p1, __p1};
+ __ret = (int16x4_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
return __ret;
}
#else
-__ai int16x4_t vmul_n_s16(int16x4_t __p0, int16_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vmax_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __rev0 * (int16x4_t) {__p1, __p1, __p1, __p1};
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x8_t vmull_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly16x8_t __ret;
- __ret = (poly16x8_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 37);
+__ai __attribute__((target("neon"))) uint8x16_t vminq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
return __ret;
}
#else
-__ai poly16x8_t vmull_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly16x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly16x8_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 37);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vminq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly16x8_t __noswap_vmull_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly16x8_t __ret;
- __ret = (poly16x8_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 37);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vminq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vminq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vmull_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vminq_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 49);
+ __ret = (uint16x8_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
return __ret;
}
#else
-__ai uint16x8_t vmull_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vminq_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint16x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 49);
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai uint16x8_t __noswap_vmull_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 49);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vmull_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 51);
+__ai __attribute__((target("neon"))) int8x16_t vminq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
return __ret;
}
#else
-__ai uint64x2_t vmull_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint64x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai uint64x2_t __noswap_vmull_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 51);
+__ai __attribute__((target("neon"))) int8x16_t vminq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmull_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 50);
+__ai __attribute__((target("neon"))) float32x4_t vminq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
return __ret;
}
#else
-__ai uint32x4_t vmull_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint32x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai uint32x4_t __noswap_vmull_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 50);
+__ai __attribute__((target("neon"))) float32x4_t vminq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vmull_s8(int8x8_t __p0, int8x8_t __p1) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 33);
+__ai __attribute__((target("neon"))) int32x4_t vminq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
return __ret;
}
#else
-__ai int16x8_t vmull_s8(int8x8_t __p0, int8x8_t __p1) {
- int16x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-__ai int16x8_t __noswap_vmull_s8(int8x8_t __p0, int8x8_t __p1) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 33);
+__ai __attribute__((target("neon"))) int32x4_t vminq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vmull_s32(int32x2_t __p0, int32x2_t __p1) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 35);
+__ai __attribute__((target("neon"))) int16x8_t vminq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
return __ret;
}
#else
-__ai int64x2_t vmull_s32(int32x2_t __p0, int32x2_t __p1) {
- int64x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 35);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai int64x2_t __noswap_vmull_s32(int32x2_t __p0, int32x2_t __p1) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 35);
+__ai __attribute__((target("neon"))) int16x8_t vminq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmull_s16(int16x4_t __p0, int16x4_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 34);
+__ai __attribute__((target("neon"))) uint8x8_t vmin_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
return __ret;
}
#else
-__ai int32x4_t vmull_s16(int16x4_t __p0, int16x4_t __p1) {
- int32x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai int32x4_t __noswap_vmull_s16(int16x4_t __p0, int16x4_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 34);
+__ai __attribute__((target("neon"))) uint8x8_t vmin_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmull_lane_u32(__p0_106, __p1_106, __p2_106) __extension__ ({ \
- uint64x2_t __ret_106; \
- uint32x2_t __s0_106 = __p0_106; \
- uint32x2_t __s1_106 = __p1_106; \
- __ret_106 = vmull_u32(__s0_106, splat_lane_u32(__s1_106, __p2_106)); \
- __ret_106; \
-})
-#else
-#define vmull_lane_u32(__p0_107, __p1_107, __p2_107) __extension__ ({ \
- uint64x2_t __ret_107; \
- uint32x2_t __s0_107 = __p0_107; \
- uint32x2_t __s1_107 = __p1_107; \
- uint32x2_t __rev0_107; __rev0_107 = __builtin_shufflevector(__s0_107, __s0_107, 1, 0); \
- uint32x2_t __rev1_107; __rev1_107 = __builtin_shufflevector(__s1_107, __s1_107, 1, 0); \
- __ret_107 = __noswap_vmull_u32(__rev0_107, __noswap_splat_lane_u32(__rev1_107, __p2_107)); \
- __ret_107 = __builtin_shufflevector(__ret_107, __ret_107, 1, 0); \
- __ret_107; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vmull_lane_u16(__p0_108, __p1_108, __p2_108) __extension__ ({ \
- uint32x4_t __ret_108; \
- uint16x4_t __s0_108 = __p0_108; \
- uint16x4_t __s1_108 = __p1_108; \
- __ret_108 = vmull_u16(__s0_108, splat_lane_u16(__s1_108, __p2_108)); \
- __ret_108; \
-})
-#else
-#define vmull_lane_u16(__p0_109, __p1_109, __p2_109) __extension__ ({ \
- uint32x4_t __ret_109; \
- uint16x4_t __s0_109 = __p0_109; \
- uint16x4_t __s1_109 = __p1_109; \
- uint16x4_t __rev0_109; __rev0_109 = __builtin_shufflevector(__s0_109, __s0_109, 3, 2, 1, 0); \
- uint16x4_t __rev1_109; __rev1_109 = __builtin_shufflevector(__s1_109, __s1_109, 3, 2, 1, 0); \
- __ret_109 = __noswap_vmull_u16(__rev0_109, __noswap_splat_lane_u16(__rev1_109, __p2_109)); \
- __ret_109 = __builtin_shufflevector(__ret_109, __ret_109, 3, 2, 1, 0); \
- __ret_109; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vmull_lane_s32(__p0_110, __p1_110, __p2_110) __extension__ ({ \
- int64x2_t __ret_110; \
- int32x2_t __s0_110 = __p0_110; \
- int32x2_t __s1_110 = __p1_110; \
- __ret_110 = vmull_s32(__s0_110, splat_lane_s32(__s1_110, __p2_110)); \
- __ret_110; \
-})
-#else
-#define vmull_lane_s32(__p0_111, __p1_111, __p2_111) __extension__ ({ \
- int64x2_t __ret_111; \
- int32x2_t __s0_111 = __p0_111; \
- int32x2_t __s1_111 = __p1_111; \
- int32x2_t __rev0_111; __rev0_111 = __builtin_shufflevector(__s0_111, __s0_111, 1, 0); \
- int32x2_t __rev1_111; __rev1_111 = __builtin_shufflevector(__s1_111, __s1_111, 1, 0); \
- __ret_111 = __noswap_vmull_s32(__rev0_111, __noswap_splat_lane_s32(__rev1_111, __p2_111)); \
- __ret_111 = __builtin_shufflevector(__ret_111, __ret_111, 1, 0); \
- __ret_111; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vmull_lane_s16(__p0_112, __p1_112, __p2_112) __extension__ ({ \
- int32x4_t __ret_112; \
- int16x4_t __s0_112 = __p0_112; \
- int16x4_t __s1_112 = __p1_112; \
- __ret_112 = vmull_s16(__s0_112, splat_lane_s16(__s1_112, __p2_112)); \
- __ret_112; \
-})
-#else
-#define vmull_lane_s16(__p0_113, __p1_113, __p2_113) __extension__ ({ \
- int32x4_t __ret_113; \
- int16x4_t __s0_113 = __p0_113; \
- int16x4_t __s1_113 = __p1_113; \
- int16x4_t __rev0_113; __rev0_113 = __builtin_shufflevector(__s0_113, __s0_113, 3, 2, 1, 0); \
- int16x4_t __rev1_113; __rev1_113 = __builtin_shufflevector(__s1_113, __s1_113, 3, 2, 1, 0); \
- __ret_113 = __noswap_vmull_s16(__rev0_113, __noswap_splat_lane_s16(__rev1_113, __p2_113)); \
- __ret_113 = __builtin_shufflevector(__ret_113, __ret_113, 3, 2, 1, 0); \
- __ret_113; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vmull_n_u32(uint32x2_t __p0, uint32_t __p1) {
- uint64x2_t __ret;
- __ret = vmull_u32(__p0, (uint32x2_t) {__p1, __p1});
+__ai __attribute__((target("neon"))) uint32x2_t vmin_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
return __ret;
}
#else
-__ai uint64x2_t vmull_n_u32(uint32x2_t __p0, uint32_t __p1) {
- uint64x2_t __ret;
+__ai __attribute__((target("neon"))) uint32x2_t vmin_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __noswap_vmull_u32(__rev0, (uint32x2_t) {__p1, __p1});
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai uint64x2_t __noswap_vmull_n_u32(uint32x2_t __p0, uint32_t __p1) {
- uint64x2_t __ret;
- __ret = __noswap_vmull_u32(__p0, (uint32x2_t) {__p1, __p1});
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmull_n_u16(uint16x4_t __p0, uint16_t __p1) {
- uint32x4_t __ret;
- __ret = vmull_u16(__p0, (uint16x4_t) {__p1, __p1, __p1, __p1});
+__ai __attribute__((target("neon"))) uint16x4_t vmin_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
return __ret;
}
#else
-__ai uint32x4_t vmull_n_u16(uint16x4_t __p0, uint16_t __p1) {
- uint32x4_t __ret;
+__ai __attribute__((target("neon"))) uint16x4_t vmin_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __noswap_vmull_u16(__rev0, (uint16x4_t) {__p1, __p1, __p1, __p1});
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai uint32x4_t __noswap_vmull_n_u16(uint16x4_t __p0, uint16_t __p1) {
- uint32x4_t __ret;
- __ret = __noswap_vmull_u16(__p0, (uint16x4_t) {__p1, __p1, __p1, __p1});
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vmull_n_s32(int32x2_t __p0, int32_t __p1) {
- int64x2_t __ret;
- __ret = vmull_s32(__p0, (int32x2_t) {__p1, __p1});
+__ai __attribute__((target("neon"))) int8x8_t vmin_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
return __ret;
}
#else
-__ai int64x2_t vmull_n_s32(int32x2_t __p0, int32_t __p1) {
- int64x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __noswap_vmull_s32(__rev0, (int32x2_t) {__p1, __p1});
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai int64x2_t __noswap_vmull_n_s32(int32x2_t __p0, int32_t __p1) {
- int64x2_t __ret;
- __ret = __noswap_vmull_s32(__p0, (int32x2_t) {__p1, __p1});
+__ai __attribute__((target("neon"))) int8x8_t vmin_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmull_n_s16(int16x4_t __p0, int16_t __p1) {
- int32x4_t __ret;
- __ret = vmull_s16(__p0, (int16x4_t) {__p1, __p1, __p1, __p1});
+__ai __attribute__((target("neon"))) float32x2_t vmin_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
return __ret;
}
#else
-__ai int32x4_t vmull_n_s16(int16x4_t __p0, int16_t __p1) {
- int32x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __noswap_vmull_s16(__rev0, (int16x4_t) {__p1, __p1, __p1, __p1});
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai int32x4_t __noswap_vmull_n_s16(int16x4_t __p0, int16_t __p1) {
- int32x4_t __ret;
- __ret = __noswap_vmull_s16(__p0, (int16x4_t) {__p1, __p1, __p1, __p1});
+__ai __attribute__((target("neon"))) float32x2_t vmin_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vmvn_p8(poly8x8_t __p0) {
- poly8x8_t __ret;
- __ret = ~__p0;
+__ai __attribute__((target("neon"))) int32x2_t vmin_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
return __ret;
}
#else
-__ai poly8x8_t vmvn_p8(poly8x8_t __p0) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = ~__rev0;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x2_t vmin_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vmvnq_p8(poly8x16_t __p0) {
- poly8x16_t __ret;
- __ret = ~__p0;
+__ai __attribute__((target("neon"))) int16x4_t vmin_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
return __ret;
}
#else
-__ai poly8x16_t vmvnq_p8(poly8x16_t __p0) {
- poly8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = ~__rev0;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16x4_t vmin_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vmvnq_u8(uint8x16_t __p0) {
+__ai __attribute__((target("neon"))) uint8x16_t vmlaq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint8x16_t __ret;
- __ret = ~__p0;
+ __ret = __p0 + __p1 * __p2;
return __ret;
}
#else
-__ai uint8x16_t vmvnq_u8(uint8x16_t __p0) {
+__ai __attribute__((target("neon"))) uint8x16_t vmlaq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint8x16_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = ~__rev0;
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmvnq_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlaq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
- __ret = ~__p0;
+ __ret = __p0 + __p1 * __p2;
return __ret;
}
#else
-__ai uint32x4_t vmvnq_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlaq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = ~__rev0;
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ uint32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vmvnq_u16(uint16x8_t __p0) {
+__ai __attribute__((target("neon"))) uint16x8_t vmlaq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
uint16x8_t __ret;
- __ret = ~__p0;
+ __ret = __p0 + __p1 * __p2;
return __ret;
}
#else
-__ai uint16x8_t vmvnq_u16(uint16x8_t __p0) {
+__ai __attribute__((target("neon"))) uint16x8_t vmlaq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = ~__rev0;
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vmvnq_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vmlaq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
int8x16_t __ret;
- __ret = ~__p0;
+ __ret = __p0 + __p1 * __p2;
return __ret;
}
#else
-__ai int8x16_t vmvnq_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vmlaq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
int8x16_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = ~__rev0;
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmvnq_s32(int32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vmlaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+ float32x4_t __ret;
+ __ret = __p0 + __p1 * __p2;
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vmlaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ float32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1 * __rev2;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmlaq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
int32x4_t __ret;
- __ret = ~__p0;
+ __ret = __p0 + __p1 * __p2;
return __ret;
}
#else
-__ai int32x4_t vmvnq_s32(int32x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vmlaq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = ~__rev0;
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vmvnq_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vmlaq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
int16x8_t __ret;
- __ret = ~__p0;
+ __ret = __p0 + __p1 * __p2;
return __ret;
}
#else
-__ai int16x8_t vmvnq_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vmlaq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = ~__rev0;
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vmvn_u8(uint8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vmla_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint8x8_t __ret;
- __ret = ~__p0;
+ __ret = __p0 + __p1 * __p2;
return __ret;
}
#else
-__ai uint8x8_t vmvn_u8(uint8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vmla_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint8x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = ~__rev0;
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vmvn_u32(uint32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vmla_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
uint32x2_t __ret;
- __ret = ~__p0;
+ __ret = __p0 + __p1 * __p2;
return __ret;
}
#else
-__ai uint32x2_t vmvn_u32(uint32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vmla_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = ~__rev0;
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ uint32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = __rev0 + __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vmvn_u16(uint16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vmla_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
uint16x4_t __ret;
- __ret = ~__p0;
+ __ret = __p0 + __p1 * __p2;
return __ret;
}
#else
-__ai uint16x4_t vmvn_u16(uint16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vmla_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = ~__rev0;
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ uint16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vmvn_s8(int8x8_t __p0) {
+__ai __attribute__((target("neon"))) int8x8_t vmla_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
int8x8_t __ret;
- __ret = ~__p0;
+ __ret = __p0 + __p1 * __p2;
return __ret;
}
#else
-__ai int8x8_t vmvn_s8(int8x8_t __p0) {
+__ai __attribute__((target("neon"))) int8x8_t vmla_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
int8x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = ~__rev0;
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vmvn_s32(int32x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vmla_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+ float32x2_t __ret;
+ __ret = __p0 + __p1 * __p2;
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vmla_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ float32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = __rev0 + __rev1 * __rev2;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vmla_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int32x2_t __ret;
- __ret = ~__p0;
+ __ret = __p0 + __p1 * __p2;
return __ret;
}
#else
-__ai int32x2_t vmvn_s32(int32x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vmla_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = ~__rev0;
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ int32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = __rev0 + __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vmvn_s16(int16x4_t __p0) {
+__ai __attribute__((target("neon"))) int16x4_t vmla_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
int16x4_t __ret;
- __ret = ~__p0;
+ __ret = __p0 + __p1 * __p2;
return __ret;
}
#else
-__ai int16x4_t vmvn_s16(int16x4_t __p0) {
+__ai __attribute__((target("neon"))) int16x4_t vmla_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = ~__rev0;
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ int16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vnegq_s8(int8x16_t __p0) {
- int8x16_t __ret;
- __ret = -__p0;
+#define vmlaq_lane_u32(__p0_54, __p1_54, __p2_54, __p3_54) __extension__ ({ \
+ uint32x4_t __ret_54; \
+ uint32x4_t __s0_54 = __p0_54; \
+ uint32x4_t __s1_54 = __p1_54; \
+ uint32x2_t __s2_54 = __p2_54; \
+ __ret_54 = __s0_54 + __s1_54 * splatq_lane_u32(__s2_54, __p3_54); \
+ __ret_54; \
+})
+#else
+#define vmlaq_lane_u32(__p0_55, __p1_55, __p2_55, __p3_55) __extension__ ({ \
+ uint32x4_t __ret_55; \
+ uint32x4_t __s0_55 = __p0_55; \
+ uint32x4_t __s1_55 = __p1_55; \
+ uint32x2_t __s2_55 = __p2_55; \
+ uint32x4_t __rev0_55; __rev0_55 = __builtin_shufflevector(__s0_55, __s0_55, 3, 2, 1, 0); \
+ uint32x4_t __rev1_55; __rev1_55 = __builtin_shufflevector(__s1_55, __s1_55, 3, 2, 1, 0); \
+ uint32x2_t __rev2_55; __rev2_55 = __builtin_shufflevector(__s2_55, __s2_55, 1, 0); \
+ __ret_55 = __rev0_55 + __rev1_55 * __noswap_splatq_lane_u32(__rev2_55, __p3_55); \
+ __ret_55 = __builtin_shufflevector(__ret_55, __ret_55, 3, 2, 1, 0); \
+ __ret_55; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlaq_lane_u16(__p0_56, __p1_56, __p2_56, __p3_56) __extension__ ({ \
+ uint16x8_t __ret_56; \
+ uint16x8_t __s0_56 = __p0_56; \
+ uint16x8_t __s1_56 = __p1_56; \
+ uint16x4_t __s2_56 = __p2_56; \
+ __ret_56 = __s0_56 + __s1_56 * splatq_lane_u16(__s2_56, __p3_56); \
+ __ret_56; \
+})
+#else
+#define vmlaq_lane_u16(__p0_57, __p1_57, __p2_57, __p3_57) __extension__ ({ \
+ uint16x8_t __ret_57; \
+ uint16x8_t __s0_57 = __p0_57; \
+ uint16x8_t __s1_57 = __p1_57; \
+ uint16x4_t __s2_57 = __p2_57; \
+ uint16x8_t __rev0_57; __rev0_57 = __builtin_shufflevector(__s0_57, __s0_57, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev1_57; __rev1_57 = __builtin_shufflevector(__s1_57, __s1_57, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x4_t __rev2_57; __rev2_57 = __builtin_shufflevector(__s2_57, __s2_57, 3, 2, 1, 0); \
+ __ret_57 = __rev0_57 + __rev1_57 * __noswap_splatq_lane_u16(__rev2_57, __p3_57); \
+ __ret_57 = __builtin_shufflevector(__ret_57, __ret_57, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_57; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlaq_lane_f32(__p0_58, __p1_58, __p2_58, __p3_58) __extension__ ({ \
+ float32x4_t __ret_58; \
+ float32x4_t __s0_58 = __p0_58; \
+ float32x4_t __s1_58 = __p1_58; \
+ float32x2_t __s2_58 = __p2_58; \
+ __ret_58 = __s0_58 + __s1_58 * splatq_lane_f32(__s2_58, __p3_58); \
+ __ret_58; \
+})
+#else
+#define vmlaq_lane_f32(__p0_59, __p1_59, __p2_59, __p3_59) __extension__ ({ \
+ float32x4_t __ret_59; \
+ float32x4_t __s0_59 = __p0_59; \
+ float32x4_t __s1_59 = __p1_59; \
+ float32x2_t __s2_59 = __p2_59; \
+ float32x4_t __rev0_59; __rev0_59 = __builtin_shufflevector(__s0_59, __s0_59, 3, 2, 1, 0); \
+ float32x4_t __rev1_59; __rev1_59 = __builtin_shufflevector(__s1_59, __s1_59, 3, 2, 1, 0); \
+ float32x2_t __rev2_59; __rev2_59 = __builtin_shufflevector(__s2_59, __s2_59, 1, 0); \
+ __ret_59 = __rev0_59 + __rev1_59 * __noswap_splatq_lane_f32(__rev2_59, __p3_59); \
+ __ret_59 = __builtin_shufflevector(__ret_59, __ret_59, 3, 2, 1, 0); \
+ __ret_59; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlaq_lane_s32(__p0_60, __p1_60, __p2_60, __p3_60) __extension__ ({ \
+ int32x4_t __ret_60; \
+ int32x4_t __s0_60 = __p0_60; \
+ int32x4_t __s1_60 = __p1_60; \
+ int32x2_t __s2_60 = __p2_60; \
+ __ret_60 = __s0_60 + __s1_60 * splatq_lane_s32(__s2_60, __p3_60); \
+ __ret_60; \
+})
+#else
+#define vmlaq_lane_s32(__p0_61, __p1_61, __p2_61, __p3_61) __extension__ ({ \
+ int32x4_t __ret_61; \
+ int32x4_t __s0_61 = __p0_61; \
+ int32x4_t __s1_61 = __p1_61; \
+ int32x2_t __s2_61 = __p2_61; \
+ int32x4_t __rev0_61; __rev0_61 = __builtin_shufflevector(__s0_61, __s0_61, 3, 2, 1, 0); \
+ int32x4_t __rev1_61; __rev1_61 = __builtin_shufflevector(__s1_61, __s1_61, 3, 2, 1, 0); \
+ int32x2_t __rev2_61; __rev2_61 = __builtin_shufflevector(__s2_61, __s2_61, 1, 0); \
+ __ret_61 = __rev0_61 + __rev1_61 * __noswap_splatq_lane_s32(__rev2_61, __p3_61); \
+ __ret_61 = __builtin_shufflevector(__ret_61, __ret_61, 3, 2, 1, 0); \
+ __ret_61; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlaq_lane_s16(__p0_62, __p1_62, __p2_62, __p3_62) __extension__ ({ \
+ int16x8_t __ret_62; \
+ int16x8_t __s0_62 = __p0_62; \
+ int16x8_t __s1_62 = __p1_62; \
+ int16x4_t __s2_62 = __p2_62; \
+ __ret_62 = __s0_62 + __s1_62 * splatq_lane_s16(__s2_62, __p3_62); \
+ __ret_62; \
+})
+#else
+#define vmlaq_lane_s16(__p0_63, __p1_63, __p2_63, __p3_63) __extension__ ({ \
+ int16x8_t __ret_63; \
+ int16x8_t __s0_63 = __p0_63; \
+ int16x8_t __s1_63 = __p1_63; \
+ int16x4_t __s2_63 = __p2_63; \
+ int16x8_t __rev0_63; __rev0_63 = __builtin_shufflevector(__s0_63, __s0_63, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1_63; __rev1_63 = __builtin_shufflevector(__s1_63, __s1_63, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x4_t __rev2_63; __rev2_63 = __builtin_shufflevector(__s2_63, __s2_63, 3, 2, 1, 0); \
+ __ret_63 = __rev0_63 + __rev1_63 * __noswap_splatq_lane_s16(__rev2_63, __p3_63); \
+ __ret_63 = __builtin_shufflevector(__ret_63, __ret_63, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_63; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmla_lane_u32(__p0_64, __p1_64, __p2_64, __p3_64) __extension__ ({ \
+ uint32x2_t __ret_64; \
+ uint32x2_t __s0_64 = __p0_64; \
+ uint32x2_t __s1_64 = __p1_64; \
+ uint32x2_t __s2_64 = __p2_64; \
+ __ret_64 = __s0_64 + __s1_64 * splat_lane_u32(__s2_64, __p3_64); \
+ __ret_64; \
+})
+#else
+#define vmla_lane_u32(__p0_65, __p1_65, __p2_65, __p3_65) __extension__ ({ \
+ uint32x2_t __ret_65; \
+ uint32x2_t __s0_65 = __p0_65; \
+ uint32x2_t __s1_65 = __p1_65; \
+ uint32x2_t __s2_65 = __p2_65; \
+ uint32x2_t __rev0_65; __rev0_65 = __builtin_shufflevector(__s0_65, __s0_65, 1, 0); \
+ uint32x2_t __rev1_65; __rev1_65 = __builtin_shufflevector(__s1_65, __s1_65, 1, 0); \
+ uint32x2_t __rev2_65; __rev2_65 = __builtin_shufflevector(__s2_65, __s2_65, 1, 0); \
+ __ret_65 = __rev0_65 + __rev1_65 * __noswap_splat_lane_u32(__rev2_65, __p3_65); \
+ __ret_65 = __builtin_shufflevector(__ret_65, __ret_65, 1, 0); \
+ __ret_65; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmla_lane_u16(__p0_66, __p1_66, __p2_66, __p3_66) __extension__ ({ \
+ uint16x4_t __ret_66; \
+ uint16x4_t __s0_66 = __p0_66; \
+ uint16x4_t __s1_66 = __p1_66; \
+ uint16x4_t __s2_66 = __p2_66; \
+ __ret_66 = __s0_66 + __s1_66 * splat_lane_u16(__s2_66, __p3_66); \
+ __ret_66; \
+})
+#else
+#define vmla_lane_u16(__p0_67, __p1_67, __p2_67, __p3_67) __extension__ ({ \
+ uint16x4_t __ret_67; \
+ uint16x4_t __s0_67 = __p0_67; \
+ uint16x4_t __s1_67 = __p1_67; \
+ uint16x4_t __s2_67 = __p2_67; \
+ uint16x4_t __rev0_67; __rev0_67 = __builtin_shufflevector(__s0_67, __s0_67, 3, 2, 1, 0); \
+ uint16x4_t __rev1_67; __rev1_67 = __builtin_shufflevector(__s1_67, __s1_67, 3, 2, 1, 0); \
+ uint16x4_t __rev2_67; __rev2_67 = __builtin_shufflevector(__s2_67, __s2_67, 3, 2, 1, 0); \
+ __ret_67 = __rev0_67 + __rev1_67 * __noswap_splat_lane_u16(__rev2_67, __p3_67); \
+ __ret_67 = __builtin_shufflevector(__ret_67, __ret_67, 3, 2, 1, 0); \
+ __ret_67; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmla_lane_f32(__p0_68, __p1_68, __p2_68, __p3_68) __extension__ ({ \
+ float32x2_t __ret_68; \
+ float32x2_t __s0_68 = __p0_68; \
+ float32x2_t __s1_68 = __p1_68; \
+ float32x2_t __s2_68 = __p2_68; \
+ __ret_68 = __s0_68 + __s1_68 * splat_lane_f32(__s2_68, __p3_68); \
+ __ret_68; \
+})
+#else
+#define vmla_lane_f32(__p0_69, __p1_69, __p2_69, __p3_69) __extension__ ({ \
+ float32x2_t __ret_69; \
+ float32x2_t __s0_69 = __p0_69; \
+ float32x2_t __s1_69 = __p1_69; \
+ float32x2_t __s2_69 = __p2_69; \
+ float32x2_t __rev0_69; __rev0_69 = __builtin_shufflevector(__s0_69, __s0_69, 1, 0); \
+ float32x2_t __rev1_69; __rev1_69 = __builtin_shufflevector(__s1_69, __s1_69, 1, 0); \
+ float32x2_t __rev2_69; __rev2_69 = __builtin_shufflevector(__s2_69, __s2_69, 1, 0); \
+ __ret_69 = __rev0_69 + __rev1_69 * __noswap_splat_lane_f32(__rev2_69, __p3_69); \
+ __ret_69 = __builtin_shufflevector(__ret_69, __ret_69, 1, 0); \
+ __ret_69; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmla_lane_s32(__p0_70, __p1_70, __p2_70, __p3_70) __extension__ ({ \
+ int32x2_t __ret_70; \
+ int32x2_t __s0_70 = __p0_70; \
+ int32x2_t __s1_70 = __p1_70; \
+ int32x2_t __s2_70 = __p2_70; \
+ __ret_70 = __s0_70 + __s1_70 * splat_lane_s32(__s2_70, __p3_70); \
+ __ret_70; \
+})
+#else
+#define vmla_lane_s32(__p0_71, __p1_71, __p2_71, __p3_71) __extension__ ({ \
+ int32x2_t __ret_71; \
+ int32x2_t __s0_71 = __p0_71; \
+ int32x2_t __s1_71 = __p1_71; \
+ int32x2_t __s2_71 = __p2_71; \
+ int32x2_t __rev0_71; __rev0_71 = __builtin_shufflevector(__s0_71, __s0_71, 1, 0); \
+ int32x2_t __rev1_71; __rev1_71 = __builtin_shufflevector(__s1_71, __s1_71, 1, 0); \
+ int32x2_t __rev2_71; __rev2_71 = __builtin_shufflevector(__s2_71, __s2_71, 1, 0); \
+ __ret_71 = __rev0_71 + __rev1_71 * __noswap_splat_lane_s32(__rev2_71, __p3_71); \
+ __ret_71 = __builtin_shufflevector(__ret_71, __ret_71, 1, 0); \
+ __ret_71; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmla_lane_s16(__p0_72, __p1_72, __p2_72, __p3_72) __extension__ ({ \
+ int16x4_t __ret_72; \
+ int16x4_t __s0_72 = __p0_72; \
+ int16x4_t __s1_72 = __p1_72; \
+ int16x4_t __s2_72 = __p2_72; \
+ __ret_72 = __s0_72 + __s1_72 * splat_lane_s16(__s2_72, __p3_72); \
+ __ret_72; \
+})
+#else
+#define vmla_lane_s16(__p0_73, __p1_73, __p2_73, __p3_73) __extension__ ({ \
+ int16x4_t __ret_73; \
+ int16x4_t __s0_73 = __p0_73; \
+ int16x4_t __s1_73 = __p1_73; \
+ int16x4_t __s2_73 = __p2_73; \
+ int16x4_t __rev0_73; __rev0_73 = __builtin_shufflevector(__s0_73, __s0_73, 3, 2, 1, 0); \
+ int16x4_t __rev1_73; __rev1_73 = __builtin_shufflevector(__s1_73, __s1_73, 3, 2, 1, 0); \
+ int16x4_t __rev2_73; __rev2_73 = __builtin_shufflevector(__s2_73, __s2_73, 3, 2, 1, 0); \
+ __ret_73 = __rev0_73 + __rev1_73 * __noswap_splat_lane_s16(__rev2_73, __p3_73); \
+ __ret_73 = __builtin_shufflevector(__ret_73, __ret_73, 3, 2, 1, 0); \
+ __ret_73; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmlaq_n_u32(uint32x4_t __p0, uint32x4_t __p1, uint32_t __p2) {
+ uint32x4_t __ret;
+ __ret = __p0 + __p1 * (uint32x4_t) {__p2, __p2, __p2, __p2};
return __ret;
}
#else
-__ai int8x16_t vnegq_s8(int8x16_t __p0) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = -__rev0;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x4_t vmlaq_n_u32(uint32x4_t __p0, uint32x4_t __p1, uint32_t __p2) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1 * (uint32x4_t) {__p2, __p2, __p2, __p2};
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmlaq_n_u16(uint16x8_t __p0, uint16x8_t __p1, uint16_t __p2) {
+ uint16x8_t __ret;
+ __ret = __p0 + __p1 * (uint16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmlaq_n_u16(uint16x8_t __p0, uint16x8_t __p1, uint16_t __p2) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1 * (uint16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vnegq_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vmlaq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
float32x4_t __ret;
- __ret = -__p0;
+ __ret = __p0 + __p1 * (float32x4_t) {__p2, __p2, __p2, __p2};
return __ret;
}
#else
-__ai float32x4_t vnegq_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vmlaq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = -__rev0;
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1 * (float32x4_t) {__p2, __p2, __p2, __p2};
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vnegq_s32(int32x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vmlaq_n_s32(int32x4_t __p0, int32x4_t __p1, int32_t __p2) {
int32x4_t __ret;
- __ret = -__p0;
+ __ret = __p0 + __p1 * (int32x4_t) {__p2, __p2, __p2, __p2};
return __ret;
}
#else
-__ai int32x4_t vnegq_s32(int32x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vmlaq_n_s32(int32x4_t __p0, int32x4_t __p1, int32_t __p2) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = -__rev0;
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1 * (int32x4_t) {__p2, __p2, __p2, __p2};
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vnegq_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vmlaq_n_s16(int16x8_t __p0, int16x8_t __p1, int16_t __p2) {
int16x8_t __ret;
- __ret = -__p0;
+ __ret = __p0 + __p1 * (int16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
return __ret;
}
#else
-__ai int16x8_t vnegq_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vmlaq_n_s16(int16x8_t __p0, int16x8_t __p1, int16_t __p2) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = -__rev0;
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1 * (int16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vneg_s8(int8x8_t __p0) {
- int8x8_t __ret;
- __ret = -__p0;
+__ai __attribute__((target("neon"))) uint32x2_t vmla_n_u32(uint32x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
+ uint32x2_t __ret;
+ __ret = __p0 + __p1 * (uint32x2_t) {__p2, __p2};
return __ret;
}
#else
-__ai int8x8_t vneg_s8(int8x8_t __p0) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = -__rev0;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x2_t vmla_n_u32(uint32x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 + __rev1 * (uint32x2_t) {__p2, __p2};
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vmla_n_u16(uint16x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
+ uint16x4_t __ret;
+ __ret = __p0 + __p1 * (uint16x4_t) {__p2, __p2, __p2, __p2};
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vmla_n_u16(uint16x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1 * (uint16x4_t) {__p2, __p2, __p2, __p2};
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vneg_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vmla_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
float32x2_t __ret;
- __ret = -__p0;
+ __ret = __p0 + __p1 * (float32x2_t) {__p2, __p2};
return __ret;
}
#else
-__ai float32x2_t vneg_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vmla_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = -__rev0;
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 + __rev1 * (float32x2_t) {__p2, __p2};
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vneg_s32(int32x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vmla_n_s32(int32x2_t __p0, int32x2_t __p1, int32_t __p2) {
int32x2_t __ret;
- __ret = -__p0;
+ __ret = __p0 + __p1 * (int32x2_t) {__p2, __p2};
return __ret;
}
#else
-__ai int32x2_t vneg_s32(int32x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vmla_n_s32(int32x2_t __p0, int32x2_t __p1, int32_t __p2) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = -__rev0;
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 + __rev1 * (int32x2_t) {__p2, __p2};
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vneg_s16(int16x4_t __p0) {
+__ai __attribute__((target("neon"))) int16x4_t vmla_n_s16(int16x4_t __p0, int16x4_t __p1, int16_t __p2) {
int16x4_t __ret;
- __ret = -__p0;
+ __ret = __p0 + __p1 * (int16x4_t) {__p2, __p2, __p2, __p2};
return __ret;
}
#else
-__ai int16x4_t vneg_s16(int16x4_t __p0) {
+__ai __attribute__((target("neon"))) int16x4_t vmla_n_s16(int16x4_t __p0, int16x4_t __p1, int16_t __p2) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = -__rev0;
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 + __rev1 * (int16x4_t) {__p2, __p2, __p2, __p2};
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vornq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint8x16_t vmlsq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint8x16_t __ret;
- __ret = __p0 | ~__p1;
+ __ret = __p0 - __p1 * __p2;
return __ret;
}
#else
-__ai uint8x16_t vornq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint8x16_t vmlsq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint8x16_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 | ~__rev1;
+ uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 - __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vornq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlsq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
- __ret = __p0 | ~__p1;
+ __ret = __p0 - __p1 * __p2;
return __ret;
}
#else
-__ai uint32x4_t vornq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlsq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 | ~__rev1;
+ uint32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __rev0 - __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vornq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- __ret = __p0 | ~__p1;
- return __ret;
-}
-#else
-__ai uint64x2_t vornq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 | ~__rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vornq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vmlsq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
uint16x8_t __ret;
- __ret = __p0 | ~__p1;
+ __ret = __p0 - __p1 * __p2;
return __ret;
}
#else
-__ai uint16x8_t vornq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vmlsq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 | ~__rev1;
+ uint16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 - __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vornq_s8(int8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) int8x16_t vmlsq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
int8x16_t __ret;
- __ret = __p0 | ~__p1;
+ __ret = __p0 - __p1 * __p2;
return __ret;
}
#else
-__ai int8x16_t vornq_s8(int8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) int8x16_t vmlsq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
int8x16_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 | ~__rev1;
+ int8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 - __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vornq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = __p0 | ~__p1;
+__ai __attribute__((target("neon"))) float32x4_t vmlsq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+ float32x4_t __ret;
+ __ret = __p0 - __p1 * __p2;
return __ret;
}
#else
-__ai int32x4_t vornq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 | ~__rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x4_t vmlsq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ float32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __rev0 - __rev1 * __rev2;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vornq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- __ret = __p0 | ~__p1;
+__ai __attribute__((target("neon"))) int32x4_t vmlsq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+ int32x4_t __ret;
+ __ret = __p0 - __p1 * __p2;
return __ret;
}
#else
-__ai int64x2_t vornq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 | ~__rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int32x4_t vmlsq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __rev0 - __rev1 * __rev2;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vornq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vmlsq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
int16x8_t __ret;
- __ret = __p0 | ~__p1;
+ __ret = __p0 - __p1 * __p2;
return __ret;
}
#else
-__ai int16x8_t vornq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vmlsq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 | ~__rev1;
+ int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 - __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vorn_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vmls_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint8x8_t __ret;
- __ret = __p0 | ~__p1;
+ __ret = __p0 - __p1 * __p2;
return __ret;
}
#else
-__ai uint8x8_t vorn_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vmls_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint8x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 | ~__rev1;
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 - __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vorn_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vmls_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
uint32x2_t __ret;
- __ret = __p0 | ~__p1;
+ __ret = __p0 - __p1 * __p2;
return __ret;
}
#else
-__ai uint32x2_t vorn_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vmls_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 | ~__rev1;
+ uint32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = __rev0 - __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vorn_u64(uint64x1_t __p0, uint64x1_t __p1) {
- uint64x1_t __ret;
- __ret = __p0 | ~__p1;
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vorn_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vmls_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
uint16x4_t __ret;
- __ret = __p0 | ~__p1;
+ __ret = __p0 - __p1 * __p2;
return __ret;
}
#else
-__ai uint16x4_t vorn_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vmls_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 | ~__rev1;
+ uint16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __rev0 - __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vorn_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vmls_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
int8x8_t __ret;
- __ret = __p0 | ~__p1;
+ __ret = __p0 - __p1 * __p2;
return __ret;
}
#else
-__ai int8x8_t vorn_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vmls_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
int8x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 | ~__rev1;
+ int8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 - __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vorn_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) float32x2_t vmls_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+ float32x2_t __ret;
+ __ret = __p0 - __p1 * __p2;
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vmls_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ float32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = __rev0 - __rev1 * __rev2;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vmls_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int32x2_t __ret;
- __ret = __p0 | ~__p1;
+ __ret = __p0 - __p1 * __p2;
return __ret;
}
#else
-__ai int32x2_t vorn_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vmls_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 | ~__rev1;
+ int32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = __rev0 - __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai int64x1_t vorn_s64(int64x1_t __p0, int64x1_t __p1) {
- int64x1_t __ret;
- __ret = __p0 | ~__p1;
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vorn_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vmls_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
int16x4_t __ret;
- __ret = __p0 | ~__p1;
+ __ret = __p0 - __p1 * __p2;
return __ret;
}
#else
-__ai int16x4_t vorn_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vmls_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 | ~__rev1;
+ int16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __rev0 - __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vorrq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = __p0 | __p1;
- return __ret;
-}
+#define vmlsq_lane_u32(__p0_74, __p1_74, __p2_74, __p3_74) __extension__ ({ \
+ uint32x4_t __ret_74; \
+ uint32x4_t __s0_74 = __p0_74; \
+ uint32x4_t __s1_74 = __p1_74; \
+ uint32x2_t __s2_74 = __p2_74; \
+ __ret_74 = __s0_74 - __s1_74 * splatq_lane_u32(__s2_74, __p3_74); \
+ __ret_74; \
+})
#else
-__ai uint8x16_t vorrq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 | __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vmlsq_lane_u32(__p0_75, __p1_75, __p2_75, __p3_75) __extension__ ({ \
+ uint32x4_t __ret_75; \
+ uint32x4_t __s0_75 = __p0_75; \
+ uint32x4_t __s1_75 = __p1_75; \
+ uint32x2_t __s2_75 = __p2_75; \
+ uint32x4_t __rev0_75; __rev0_75 = __builtin_shufflevector(__s0_75, __s0_75, 3, 2, 1, 0); \
+ uint32x4_t __rev1_75; __rev1_75 = __builtin_shufflevector(__s1_75, __s1_75, 3, 2, 1, 0); \
+ uint32x2_t __rev2_75; __rev2_75 = __builtin_shufflevector(__s2_75, __s2_75, 1, 0); \
+ __ret_75 = __rev0_75 - __rev1_75 * __noswap_splatq_lane_u32(__rev2_75, __p3_75); \
+ __ret_75 = __builtin_shufflevector(__ret_75, __ret_75, 3, 2, 1, 0); \
+ __ret_75; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsq_lane_u16(__p0_76, __p1_76, __p2_76, __p3_76) __extension__ ({ \
+ uint16x8_t __ret_76; \
+ uint16x8_t __s0_76 = __p0_76; \
+ uint16x8_t __s1_76 = __p1_76; \
+ uint16x4_t __s2_76 = __p2_76; \
+ __ret_76 = __s0_76 - __s1_76 * splatq_lane_u16(__s2_76, __p3_76); \
+ __ret_76; \
+})
+#else
+#define vmlsq_lane_u16(__p0_77, __p1_77, __p2_77, __p3_77) __extension__ ({ \
+ uint16x8_t __ret_77; \
+ uint16x8_t __s0_77 = __p0_77; \
+ uint16x8_t __s1_77 = __p1_77; \
+ uint16x4_t __s2_77 = __p2_77; \
+ uint16x8_t __rev0_77; __rev0_77 = __builtin_shufflevector(__s0_77, __s0_77, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev1_77; __rev1_77 = __builtin_shufflevector(__s1_77, __s1_77, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x4_t __rev2_77; __rev2_77 = __builtin_shufflevector(__s2_77, __s2_77, 3, 2, 1, 0); \
+ __ret_77 = __rev0_77 - __rev1_77 * __noswap_splatq_lane_u16(__rev2_77, __p3_77); \
+ __ret_77 = __builtin_shufflevector(__ret_77, __ret_77, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_77; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsq_lane_f32(__p0_78, __p1_78, __p2_78, __p3_78) __extension__ ({ \
+ float32x4_t __ret_78; \
+ float32x4_t __s0_78 = __p0_78; \
+ float32x4_t __s1_78 = __p1_78; \
+ float32x2_t __s2_78 = __p2_78; \
+ __ret_78 = __s0_78 - __s1_78 * splatq_lane_f32(__s2_78, __p3_78); \
+ __ret_78; \
+})
+#else
+#define vmlsq_lane_f32(__p0_79, __p1_79, __p2_79, __p3_79) __extension__ ({ \
+ float32x4_t __ret_79; \
+ float32x4_t __s0_79 = __p0_79; \
+ float32x4_t __s1_79 = __p1_79; \
+ float32x2_t __s2_79 = __p2_79; \
+ float32x4_t __rev0_79; __rev0_79 = __builtin_shufflevector(__s0_79, __s0_79, 3, 2, 1, 0); \
+ float32x4_t __rev1_79; __rev1_79 = __builtin_shufflevector(__s1_79, __s1_79, 3, 2, 1, 0); \
+ float32x2_t __rev2_79; __rev2_79 = __builtin_shufflevector(__s2_79, __s2_79, 1, 0); \
+ __ret_79 = __rev0_79 - __rev1_79 * __noswap_splatq_lane_f32(__rev2_79, __p3_79); \
+ __ret_79 = __builtin_shufflevector(__ret_79, __ret_79, 3, 2, 1, 0); \
+ __ret_79; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsq_lane_s32(__p0_80, __p1_80, __p2_80, __p3_80) __extension__ ({ \
+ int32x4_t __ret_80; \
+ int32x4_t __s0_80 = __p0_80; \
+ int32x4_t __s1_80 = __p1_80; \
+ int32x2_t __s2_80 = __p2_80; \
+ __ret_80 = __s0_80 - __s1_80 * splatq_lane_s32(__s2_80, __p3_80); \
+ __ret_80; \
+})
+#else
+#define vmlsq_lane_s32(__p0_81, __p1_81, __p2_81, __p3_81) __extension__ ({ \
+ int32x4_t __ret_81; \
+ int32x4_t __s0_81 = __p0_81; \
+ int32x4_t __s1_81 = __p1_81; \
+ int32x2_t __s2_81 = __p2_81; \
+ int32x4_t __rev0_81; __rev0_81 = __builtin_shufflevector(__s0_81, __s0_81, 3, 2, 1, 0); \
+ int32x4_t __rev1_81; __rev1_81 = __builtin_shufflevector(__s1_81, __s1_81, 3, 2, 1, 0); \
+ int32x2_t __rev2_81; __rev2_81 = __builtin_shufflevector(__s2_81, __s2_81, 1, 0); \
+ __ret_81 = __rev0_81 - __rev1_81 * __noswap_splatq_lane_s32(__rev2_81, __p3_81); \
+ __ret_81 = __builtin_shufflevector(__ret_81, __ret_81, 3, 2, 1, 0); \
+ __ret_81; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsq_lane_s16(__p0_82, __p1_82, __p2_82, __p3_82) __extension__ ({ \
+ int16x8_t __ret_82; \
+ int16x8_t __s0_82 = __p0_82; \
+ int16x8_t __s1_82 = __p1_82; \
+ int16x4_t __s2_82 = __p2_82; \
+ __ret_82 = __s0_82 - __s1_82 * splatq_lane_s16(__s2_82, __p3_82); \
+ __ret_82; \
+})
+#else
+#define vmlsq_lane_s16(__p0_83, __p1_83, __p2_83, __p3_83) __extension__ ({ \
+ int16x8_t __ret_83; \
+ int16x8_t __s0_83 = __p0_83; \
+ int16x8_t __s1_83 = __p1_83; \
+ int16x4_t __s2_83 = __p2_83; \
+ int16x8_t __rev0_83; __rev0_83 = __builtin_shufflevector(__s0_83, __s0_83, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1_83; __rev1_83 = __builtin_shufflevector(__s1_83, __s1_83, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x4_t __rev2_83; __rev2_83 = __builtin_shufflevector(__s2_83, __s2_83, 3, 2, 1, 0); \
+ __ret_83 = __rev0_83 - __rev1_83 * __noswap_splatq_lane_s16(__rev2_83, __p3_83); \
+ __ret_83 = __builtin_shufflevector(__ret_83, __ret_83, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_83; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vorrq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+#define vmls_lane_u32(__p0_84, __p1_84, __p2_84, __p3_84) __extension__ ({ \
+ uint32x2_t __ret_84; \
+ uint32x2_t __s0_84 = __p0_84; \
+ uint32x2_t __s1_84 = __p1_84; \
+ uint32x2_t __s2_84 = __p2_84; \
+ __ret_84 = __s0_84 - __s1_84 * splat_lane_u32(__s2_84, __p3_84); \
+ __ret_84; \
+})
+#else
+#define vmls_lane_u32(__p0_85, __p1_85, __p2_85, __p3_85) __extension__ ({ \
+ uint32x2_t __ret_85; \
+ uint32x2_t __s0_85 = __p0_85; \
+ uint32x2_t __s1_85 = __p1_85; \
+ uint32x2_t __s2_85 = __p2_85; \
+ uint32x2_t __rev0_85; __rev0_85 = __builtin_shufflevector(__s0_85, __s0_85, 1, 0); \
+ uint32x2_t __rev1_85; __rev1_85 = __builtin_shufflevector(__s1_85, __s1_85, 1, 0); \
+ uint32x2_t __rev2_85; __rev2_85 = __builtin_shufflevector(__s2_85, __s2_85, 1, 0); \
+ __ret_85 = __rev0_85 - __rev1_85 * __noswap_splat_lane_u32(__rev2_85, __p3_85); \
+ __ret_85 = __builtin_shufflevector(__ret_85, __ret_85, 1, 0); \
+ __ret_85; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmls_lane_u16(__p0_86, __p1_86, __p2_86, __p3_86) __extension__ ({ \
+ uint16x4_t __ret_86; \
+ uint16x4_t __s0_86 = __p0_86; \
+ uint16x4_t __s1_86 = __p1_86; \
+ uint16x4_t __s2_86 = __p2_86; \
+ __ret_86 = __s0_86 - __s1_86 * splat_lane_u16(__s2_86, __p3_86); \
+ __ret_86; \
+})
+#else
+#define vmls_lane_u16(__p0_87, __p1_87, __p2_87, __p3_87) __extension__ ({ \
+ uint16x4_t __ret_87; \
+ uint16x4_t __s0_87 = __p0_87; \
+ uint16x4_t __s1_87 = __p1_87; \
+ uint16x4_t __s2_87 = __p2_87; \
+ uint16x4_t __rev0_87; __rev0_87 = __builtin_shufflevector(__s0_87, __s0_87, 3, 2, 1, 0); \
+ uint16x4_t __rev1_87; __rev1_87 = __builtin_shufflevector(__s1_87, __s1_87, 3, 2, 1, 0); \
+ uint16x4_t __rev2_87; __rev2_87 = __builtin_shufflevector(__s2_87, __s2_87, 3, 2, 1, 0); \
+ __ret_87 = __rev0_87 - __rev1_87 * __noswap_splat_lane_u16(__rev2_87, __p3_87); \
+ __ret_87 = __builtin_shufflevector(__ret_87, __ret_87, 3, 2, 1, 0); \
+ __ret_87; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmls_lane_f32(__p0_88, __p1_88, __p2_88, __p3_88) __extension__ ({ \
+ float32x2_t __ret_88; \
+ float32x2_t __s0_88 = __p0_88; \
+ float32x2_t __s1_88 = __p1_88; \
+ float32x2_t __s2_88 = __p2_88; \
+ __ret_88 = __s0_88 - __s1_88 * splat_lane_f32(__s2_88, __p3_88); \
+ __ret_88; \
+})
+#else
+#define vmls_lane_f32(__p0_89, __p1_89, __p2_89, __p3_89) __extension__ ({ \
+ float32x2_t __ret_89; \
+ float32x2_t __s0_89 = __p0_89; \
+ float32x2_t __s1_89 = __p1_89; \
+ float32x2_t __s2_89 = __p2_89; \
+ float32x2_t __rev0_89; __rev0_89 = __builtin_shufflevector(__s0_89, __s0_89, 1, 0); \
+ float32x2_t __rev1_89; __rev1_89 = __builtin_shufflevector(__s1_89, __s1_89, 1, 0); \
+ float32x2_t __rev2_89; __rev2_89 = __builtin_shufflevector(__s2_89, __s2_89, 1, 0); \
+ __ret_89 = __rev0_89 - __rev1_89 * __noswap_splat_lane_f32(__rev2_89, __p3_89); \
+ __ret_89 = __builtin_shufflevector(__ret_89, __ret_89, 1, 0); \
+ __ret_89; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmls_lane_s32(__p0_90, __p1_90, __p2_90, __p3_90) __extension__ ({ \
+ int32x2_t __ret_90; \
+ int32x2_t __s0_90 = __p0_90; \
+ int32x2_t __s1_90 = __p1_90; \
+ int32x2_t __s2_90 = __p2_90; \
+ __ret_90 = __s0_90 - __s1_90 * splat_lane_s32(__s2_90, __p3_90); \
+ __ret_90; \
+})
+#else
+#define vmls_lane_s32(__p0_91, __p1_91, __p2_91, __p3_91) __extension__ ({ \
+ int32x2_t __ret_91; \
+ int32x2_t __s0_91 = __p0_91; \
+ int32x2_t __s1_91 = __p1_91; \
+ int32x2_t __s2_91 = __p2_91; \
+ int32x2_t __rev0_91; __rev0_91 = __builtin_shufflevector(__s0_91, __s0_91, 1, 0); \
+ int32x2_t __rev1_91; __rev1_91 = __builtin_shufflevector(__s1_91, __s1_91, 1, 0); \
+ int32x2_t __rev2_91; __rev2_91 = __builtin_shufflevector(__s2_91, __s2_91, 1, 0); \
+ __ret_91 = __rev0_91 - __rev1_91 * __noswap_splat_lane_s32(__rev2_91, __p3_91); \
+ __ret_91 = __builtin_shufflevector(__ret_91, __ret_91, 1, 0); \
+ __ret_91; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmls_lane_s16(__p0_92, __p1_92, __p2_92, __p3_92) __extension__ ({ \
+ int16x4_t __ret_92; \
+ int16x4_t __s0_92 = __p0_92; \
+ int16x4_t __s1_92 = __p1_92; \
+ int16x4_t __s2_92 = __p2_92; \
+ __ret_92 = __s0_92 - __s1_92 * splat_lane_s16(__s2_92, __p3_92); \
+ __ret_92; \
+})
+#else
+#define vmls_lane_s16(__p0_93, __p1_93, __p2_93, __p3_93) __extension__ ({ \
+ int16x4_t __ret_93; \
+ int16x4_t __s0_93 = __p0_93; \
+ int16x4_t __s1_93 = __p1_93; \
+ int16x4_t __s2_93 = __p2_93; \
+ int16x4_t __rev0_93; __rev0_93 = __builtin_shufflevector(__s0_93, __s0_93, 3, 2, 1, 0); \
+ int16x4_t __rev1_93; __rev1_93 = __builtin_shufflevector(__s1_93, __s1_93, 3, 2, 1, 0); \
+ int16x4_t __rev2_93; __rev2_93 = __builtin_shufflevector(__s2_93, __s2_93, 3, 2, 1, 0); \
+ __ret_93 = __rev0_93 - __rev1_93 * __noswap_splat_lane_s16(__rev2_93, __p3_93); \
+ __ret_93 = __builtin_shufflevector(__ret_93, __ret_93, 3, 2, 1, 0); \
+ __ret_93; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmlsq_n_u32(uint32x4_t __p0, uint32x4_t __p1, uint32_t __p2) {
uint32x4_t __ret;
- __ret = __p0 | __p1;
+ __ret = __p0 - __p1 * (uint32x4_t) {__p2, __p2, __p2, __p2};
return __ret;
}
#else
-__ai uint32x4_t vorrq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlsq_n_u32(uint32x4_t __p0, uint32x4_t __p1, uint32_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 | __rev1;
+ __ret = __rev0 - __rev1 * (uint32x4_t) {__p2, __p2, __p2, __p2};
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vorrq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- __ret = __p0 | __p1;
- return __ret;
-}
-#else
-__ai uint64x2_t vorrq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 | __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vorrq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vmlsq_n_u16(uint16x8_t __p0, uint16x8_t __p1, uint16_t __p2) {
uint16x8_t __ret;
- __ret = __p0 | __p1;
+ __ret = __p0 - __p1 * (uint16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
return __ret;
}
#else
-__ai uint16x8_t vorrq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vmlsq_n_u16(uint16x8_t __p0, uint16x8_t __p1, uint16_t __p2) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 | __rev1;
+ __ret = __rev0 - __rev1 * (uint16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vorrq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = __p0 | __p1;
+__ai __attribute__((target("neon"))) float32x4_t vmlsq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
+ float32x4_t __ret;
+ __ret = __p0 - __p1 * (float32x4_t) {__p2, __p2, __p2, __p2};
return __ret;
}
#else
-__ai int8x16_t vorrq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 | __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x4_t vmlsq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 - __rev1 * (float32x4_t) {__p2, __p2, __p2, __p2};
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vorrq_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vmlsq_n_s32(int32x4_t __p0, int32x4_t __p1, int32_t __p2) {
int32x4_t __ret;
- __ret = __p0 | __p1;
+ __ret = __p0 - __p1 * (int32x4_t) {__p2, __p2, __p2, __p2};
return __ret;
}
#else
-__ai int32x4_t vorrq_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vmlsq_n_s32(int32x4_t __p0, int32x4_t __p1, int32_t __p2) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 | __rev1;
+ __ret = __rev0 - __rev1 * (int32x4_t) {__p2, __p2, __p2, __p2};
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vorrq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- __ret = __p0 | __p1;
- return __ret;
-}
-#else
-__ai int64x2_t vorrq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 | __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vorrq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vmlsq_n_s16(int16x8_t __p0, int16x8_t __p1, int16_t __p2) {
int16x8_t __ret;
- __ret = __p0 | __p1;
+ __ret = __p0 - __p1 * (int16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
return __ret;
}
#else
-__ai int16x8_t vorrq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vmlsq_n_s16(int16x8_t __p0, int16x8_t __p1, int16_t __p2) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 | __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vorr_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = __p0 | __p1;
- return __ret;
-}
-#else
-__ai uint8x8_t vorr_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 | __rev1;
+ __ret = __rev0 - __rev1 * (int16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vorr_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vmls_n_u32(uint32x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
uint32x2_t __ret;
- __ret = __p0 | __p1;
+ __ret = __p0 - __p1 * (uint32x2_t) {__p2, __p2};
return __ret;
}
#else
-__ai uint32x2_t vorr_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vmls_n_u32(uint32x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 | __rev1;
+ __ret = __rev0 - __rev1 * (uint32x2_t) {__p2, __p2};
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vorr_u64(uint64x1_t __p0, uint64x1_t __p1) {
- uint64x1_t __ret;
- __ret = __p0 | __p1;
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vorr_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vmls_n_u16(uint16x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
uint16x4_t __ret;
- __ret = __p0 | __p1;
+ __ret = __p0 - __p1 * (uint16x4_t) {__p2, __p2, __p2, __p2};
return __ret;
}
#else
-__ai uint16x4_t vorr_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vmls_n_u16(uint16x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 | __rev1;
+ __ret = __rev0 - __rev1 * (uint16x4_t) {__p2, __p2, __p2, __p2};
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vorr_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = __p0 | __p1;
+__ai __attribute__((target("neon"))) float32x2_t vmls_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
+ float32x2_t __ret;
+ __ret = __p0 - __p1 * (float32x2_t) {__p2, __p2};
return __ret;
}
#else
-__ai int8x8_t vorr_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 | __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x2_t vmls_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 - __rev1 * (float32x2_t) {__p2, __p2};
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vorr_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vmls_n_s32(int32x2_t __p0, int32x2_t __p1, int32_t __p2) {
int32x2_t __ret;
- __ret = __p0 | __p1;
+ __ret = __p0 - __p1 * (int32x2_t) {__p2, __p2};
return __ret;
}
#else
-__ai int32x2_t vorr_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vmls_n_s32(int32x2_t __p0, int32x2_t __p1, int32_t __p2) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 | __rev1;
+ __ret = __rev0 - __rev1 * (int32x2_t) {__p2, __p2};
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai int64x1_t vorr_s64(int64x1_t __p0, int64x1_t __p1) {
- int64x1_t __ret;
- __ret = __p0 | __p1;
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vorr_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vmls_n_s16(int16x4_t __p0, int16x4_t __p1, int16_t __p2) {
int16x4_t __ret;
- __ret = __p0 | __p1;
+ __ret = __p0 - __p1 * (int16x4_t) {__p2, __p2, __p2, __p2};
return __ret;
}
#else
-__ai int16x4_t vorr_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vmls_n_s16(int16x4_t __p0, int16x4_t __p1, int16_t __p2) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 | __rev1;
+ __ret = __rev0 - __rev1 * (int16x4_t) {__p2, __p2, __p2, __p2};
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vpadalq_u8(uint16x8_t __p0, uint8x16_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vpadalq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+__ai __attribute__((target("neon"))) poly8x8_t vmov_n_p8(poly8_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
return __ret;
}
#else
-__ai uint16x8_t vpadalq_u8(uint16x8_t __p0, uint8x16_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vpadalq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+__ai __attribute__((target("neon"))) poly8x8_t vmov_n_p8(poly8_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vpadalq_u32(uint64x2_t __p0, uint32x4_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vpadalq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+__ai __attribute__((target("neon"))) poly16x4_t vmov_n_p16(poly16_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t) {__p0, __p0, __p0, __p0};
return __ret;
}
#else
-__ai uint64x2_t vpadalq_u32(uint64x2_t __p0, uint32x4_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vpadalq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) poly16x4_t vmov_n_p16(poly16_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t) {__p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vpadalq_u16(uint32x4_t __p0, uint16x8_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vpadalq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+__ai __attribute__((target("neon"))) poly8x16_t vmovq_n_p8(poly8_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
return __ret;
}
#else
-__ai uint32x4_t vpadalq_u16(uint32x4_t __p0, uint16x8_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vpadalq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly8x16_t vmovq_n_p8(poly8_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vpadalq_s8(int16x8_t __p0, int8x16_t __p1) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vpadalq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+__ai __attribute__((target("neon"))) poly16x8_t vmovq_n_p16(poly16_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
return __ret;
}
#else
-__ai int16x8_t vpadalq_s8(int16x8_t __p0, int8x16_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vpadalq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+__ai __attribute__((target("neon"))) poly16x8_t vmovq_n_p16(poly16_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vpadalq_s32(int64x2_t __p0, int32x4_t __p1) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vpadalq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+__ai __attribute__((target("neon"))) uint8x16_t vmovq_n_u8(uint8_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
return __ret;
}
#else
-__ai int64x2_t vpadalq_s32(int64x2_t __p0, int32x4_t __p1) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vpadalq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vmovq_n_u8(uint8_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vpadalq_s16(int32x4_t __p0, int16x8_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vpadalq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+__ai __attribute__((target("neon"))) uint32x4_t vmovq_n_u32(uint32_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) {__p0, __p0, __p0, __p0};
return __ret;
}
#else
-__ai int32x4_t vpadalq_s16(int32x4_t __p0, int16x8_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vpadalq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+__ai __attribute__((target("neon"))) uint32x4_t vmovq_n_u32(uint32_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) {__p0, __p0, __p0, __p0};
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vpadal_u8(uint16x4_t __p0, uint8x8_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+__ai __attribute__((target("neon"))) uint64x2_t vmovq_n_u64(uint64_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) {__p0, __p0};
return __ret;
}
#else
-__ai uint16x4_t vpadal_u8(uint16x4_t __p0, uint8x8_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vpadal_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint64x2_t vmovq_n_u64(uint64_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) {__p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x1_t vpadal_u32(uint64x1_t __p0, uint32x2_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+__ai __attribute__((target("neon"))) uint16x8_t vmovq_n_u16(uint16_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
return __ret;
}
#else
-__ai uint64x1_t vpadal_u32(uint64x1_t __p0, uint32x2_t __p1) {
- uint64x1_t __ret;
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x1_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__rev1, 19);
+__ai __attribute__((target("neon"))) uint16x8_t vmovq_n_u16(uint16_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vpadal_u16(uint32x2_t __p0, uint16x4_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+__ai __attribute__((target("neon"))) int8x16_t vmovq_n_s8(int8_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
return __ret;
}
#else
-__ai uint32x2_t vpadal_u16(uint32x2_t __p0, uint16x4_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vpadal_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int8x16_t vmovq_n_s8(int8_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vpadal_s8(int16x4_t __p0, int8x8_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+__ai __attribute__((target("neon"))) float32x4_t vmovq_n_f32(float32_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) {__p0, __p0, __p0, __p0};
return __ret;
}
#else
-__ai int16x4_t vpadal_s8(int16x4_t __p0, int8x8_t __p1) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vpadal_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+__ai __attribute__((target("neon"))) float32x4_t vmovq_n_f32(float32_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) {__p0, __p0, __p0, __p0};
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x1_t vpadal_s32(int64x1_t __p0, int32x2_t __p1) {
- int64x1_t __ret;
- __ret = (int64x1_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
+#define vmovq_n_f16(__p0) __extension__ ({ \
+ float16x8_t __ret; \
+ float16_t __s0 = __p0; \
+ __ret = (float16x8_t) {__s0, __s0, __s0, __s0, __s0, __s0, __s0, __s0}; \
+ __ret; \
+})
+#else
+#define vmovq_n_f16(__p0) __extension__ ({ \
+ float16x8_t __ret; \
+ float16_t __s0 = __p0; \
+ __ret = (float16x8_t) {__s0, __s0, __s0, __s0, __s0, __s0, __s0, __s0}; \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmovq_n_s32(int32_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) {__p0, __p0, __p0, __p0};
return __ret;
}
#else
-__ai int64x1_t vpadal_s32(int64x1_t __p0, int32x2_t __p1) {
- int64x1_t __ret;
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int64x1_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__rev1, 3);
+__ai __attribute__((target("neon"))) int32x4_t vmovq_n_s32(int32_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) {__p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vpadal_s16(int32x2_t __p0, int16x4_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+__ai __attribute__((target("neon"))) int64x2_t vmovq_n_s64(int64_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) {__p0, __p0};
return __ret;
}
#else
-__ai int32x2_t vpadal_s16(int32x2_t __p0, int16x4_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vpadal_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+__ai __attribute__((target("neon"))) int64x2_t vmovq_n_s64(int64_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) {__p0, __p0};
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vpadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vmovq_n_s16(int16_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmovq_n_s16(int16_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vmov_n_u8(uint8_t __p0) {
uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ __ret = (uint8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
return __ret;
}
#else
-__ai uint8x8_t vpadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vmov_n_u8(uint8_t __p0) {
uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = (uint8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vpadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vmov_n_u32(uint32_t __p0) {
uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ __ret = (uint32x2_t) {__p0, __p0};
return __ret;
}
#else
-__ai uint32x2_t vpadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vmov_n_u32(uint32_t __p0) {
uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = (uint32x2_t) {__p0, __p0};
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vmov_n_u64(uint64_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) {__p0};
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vpadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vmov_n_u16(uint16_t __p0) {
uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ __ret = (uint16x4_t) {__p0, __p0, __p0, __p0};
return __ret;
}
#else
-__ai uint16x4_t vpadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vmov_n_u16(uint16_t __p0) {
uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = (uint16x4_t) {__p0, __p0, __p0, __p0};
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vpadd_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vmov_n_s8(int8_t __p0) {
int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+ __ret = (int8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
return __ret;
}
#else
-__ai int8x8_t vpadd_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vmov_n_s8(int8_t __p0) {
int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = (int8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vpadd_f32(float32x2_t __p0, float32x2_t __p1) {
+__ai __attribute__((target("neon"))) float32x2_t vmov_n_f32(float32_t __p0) {
float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+ __ret = (float32x2_t) {__p0, __p0};
return __ret;
}
#else
-__ai float32x2_t vpadd_f32(float32x2_t __p0, float32x2_t __p1) {
+__ai __attribute__((target("neon"))) float32x2_t vmov_n_f32(float32_t __p0) {
float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+ __ret = (float32x2_t) {__p0, __p0};
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vpadd_s32(int32x2_t __p0, int32x2_t __p1) {
+#define vmov_n_f16(__p0) __extension__ ({ \
+ float16x4_t __ret; \
+ float16_t __s0 = __p0; \
+ __ret = (float16x4_t) {__s0, __s0, __s0, __s0}; \
+ __ret; \
+})
+#else
+#define vmov_n_f16(__p0) __extension__ ({ \
+ float16x4_t __ret; \
+ float16_t __s0 = __p0; \
+ __ret = (float16x4_t) {__s0, __s0, __s0, __s0}; \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vmov_n_s32(int32_t __p0) {
int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+ __ret = (int32x2_t) {__p0, __p0};
return __ret;
}
#else
-__ai int32x2_t vpadd_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vmov_n_s32(int32_t __p0) {
int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = (int32x2_t) {__p0, __p0};
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
+__ai __attribute__((target("neon"))) int64x1_t vmov_n_s64(int64_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t) {__p0};
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vpadd_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vmov_n_s16(int16_t __p0) {
int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ __ret = (int16x4_t) {__p0, __p0, __p0, __p0};
return __ret;
}
#else
-__ai int16x4_t vpadd_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vmov_n_s16(int16_t __p0) {
int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = (int16x4_t) {__p0, __p0, __p0, __p0};
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vpaddlq_u8(uint8x16_t __p0) {
+__ai __attribute__((target("neon"))) uint16x8_t vmovl_u8(uint8x8_t __p0) {
uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vpaddlq_v((int8x16_t)__p0, 49);
+ __ret = (uint16x8_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 49);
return __ret;
}
#else
-__ai uint16x8_t vpaddlq_u8(uint8x16_t __p0) {
+__ai __attribute__((target("neon"))) uint16x8_t vmovl_u8(uint8x8_t __p0) {
uint16x8_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vpaddlq_v((int8x16_t)__rev0, 49);
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vmovl_v((int8x8_t)__rev0, 49);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) uint16x8_t __noswap_vmovl_u8(uint8x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 49);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vpaddlq_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint64x2_t vmovl_u32(uint32x2_t __p0) {
uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vpaddlq_v((int8x16_t)__p0, 51);
+ __ret = (uint64x2_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 51);
return __ret;
}
#else
-__ai uint64x2_t vpaddlq_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint64x2_t vmovl_u32(uint32x2_t __p0) {
uint64x2_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vpaddlq_v((int8x16_t)__rev0, 51);
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vmovl_v((int8x8_t)__rev0, 51);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vmovl_u32(uint32x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 51);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vpaddlq_u16(uint16x8_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vmovl_u16(uint16x4_t __p0) {
uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vpaddlq_v((int8x16_t)__p0, 50);
+ __ret = (uint32x4_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 50);
return __ret;
}
#else
-__ai uint32x4_t vpaddlq_u16(uint16x8_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vmovl_u16(uint16x4_t __p0) {
uint32x4_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vpaddlq_v((int8x16_t)__rev0, 50);
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vmovl_v((int8x8_t)__rev0, 50);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vmovl_u16(uint16x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 50);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vpaddlq_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vmovl_s8(int8x8_t __p0) {
int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vpaddlq_v((int8x16_t)__p0, 33);
+ __ret = (int16x8_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 33);
return __ret;
}
#else
-__ai int16x8_t vpaddlq_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vmovl_s8(int8x8_t __p0) {
int16x8_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vpaddlq_v((int8x16_t)__rev0, 33);
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vmovl_v((int8x8_t)__rev0, 33);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vmovl_s8(int8x8_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 33);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vpaddlq_s32(int32x4_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vmovl_s32(int32x2_t __p0) {
int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vpaddlq_v((int8x16_t)__p0, 35);
+ __ret = (int64x2_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 35);
return __ret;
}
#else
-__ai int64x2_t vpaddlq_s32(int32x4_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vmovl_s32(int32x2_t __p0) {
int64x2_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vpaddlq_v((int8x16_t)__rev0, 35);
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vmovl_v((int8x8_t)__rev0, 35);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vmovl_s32(int32x2_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 35);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vpaddlq_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vmovl_s16(int16x4_t __p0) {
int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vpaddlq_v((int8x16_t)__p0, 34);
+ __ret = (int32x4_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 34);
return __ret;
}
#else
-__ai int32x4_t vpaddlq_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vmovl_s16(int16x4_t __p0) {
int32x4_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vpaddlq_v((int8x16_t)__rev0, 34);
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vmovl_v((int8x8_t)__rev0, 34);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vmovl_s16(int16x4_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 34);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vpaddl_u8(uint8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vmovn_u32(uint32x4_t __p0) {
uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vpaddl_v((int8x8_t)__p0, 17);
+ __ret = (uint16x4_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 17);
return __ret;
}
#else
-__ai uint16x4_t vpaddl_u8(uint8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vmovn_u32(uint32x4_t __p0) {
uint16x4_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vpaddl_v((int8x8_t)__rev0, 17);
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vmovn_v((int8x16_t)__rev0, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint64x1_t vpaddl_u32(uint32x2_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vpaddl_v((int8x8_t)__p0, 19);
- return __ret;
-}
-#else
-__ai uint64x1_t vpaddl_u32(uint32x2_t __p0) {
- uint64x1_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x1_t) __builtin_neon_vpaddl_v((int8x8_t)__rev0, 19);
+__ai __attribute__((target("neon"))) uint16x4_t __noswap_vmovn_u32(uint32x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 17);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vpaddl_u16(uint16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vmovn_u64(uint64x2_t __p0) {
uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vpaddl_v((int8x8_t)__p0, 18);
+ __ret = (uint32x2_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 18);
return __ret;
}
#else
-__ai uint32x2_t vpaddl_u16(uint16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vmovn_u64(uint64x2_t __p0) {
uint32x2_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vpaddl_v((int8x8_t)__rev0, 18);
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vmovn_v((int8x16_t)__rev0, 18);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) uint32x2_t __noswap_vmovn_u64(uint64x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 18);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vpaddl_s8(int8x8_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vpaddl_v((int8x8_t)__p0, 1);
+__ai __attribute__((target("neon"))) uint8x8_t vmovn_u16(uint16x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 16);
return __ret;
}
#else
-__ai int16x4_t vpaddl_s8(int8x8_t __p0) {
- int16x4_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vpaddl_v((int8x8_t)__rev0, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x8_t vmovn_u16(uint16x8_t __p0) {
+ uint8x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vmovn_v((int8x16_t)__rev0, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t __noswap_vmovn_u16(uint16x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 16);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x1_t vpaddl_s32(int32x2_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t) __builtin_neon_vpaddl_v((int8x8_t)__p0, 3);
+__ai __attribute__((target("neon"))) int16x4_t vmovn_s32(int32x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 1);
return __ret;
}
#else
-__ai int64x1_t vpaddl_s32(int32x2_t __p0) {
- int64x1_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int64x1_t) __builtin_neon_vpaddl_v((int8x8_t)__rev0, 3);
+__ai __attribute__((target("neon"))) int16x4_t vmovn_s32(int32x4_t __p0) {
+ int16x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vmovn_v((int8x16_t)__rev0, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vmovn_s32(int32x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 1);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vpaddl_s16(int16x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vmovn_s64(int64x2_t __p0) {
int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vpaddl_v((int8x8_t)__p0, 2);
+ __ret = (int32x2_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 2);
return __ret;
}
#else
-__ai int32x2_t vpaddl_s16(int16x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vmovn_s64(int64x2_t __p0) {
int32x2_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vpaddl_v((int8x8_t)__rev0, 2);
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vmovn_v((int8x16_t)__rev0, 2);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vmovn_s64(int64x2_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 2);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vpmax_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+__ai __attribute__((target("neon"))) int8x8_t vmovn_s16(int16x8_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 0);
return __ret;
}
#else
-__ai uint8x8_t vpmax_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+__ai __attribute__((target("neon"))) int8x8_t vmovn_s16(int16x8_t __p0) {
+ int8x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vmovn_v((int8x16_t)__rev0, 0);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) int8x8_t __noswap_vmovn_s16(int16x8_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vpmax_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+__ai __attribute__((target("neon"))) uint8x16_t vmulq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = __p0 * __p1;
return __ret;
}
#else
-__ai uint32x2_t vpmax_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vmulq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 * __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vpmax_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+__ai __attribute__((target("neon"))) uint32x4_t vmulq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = __p0 * __p1;
return __ret;
}
#else
-__ai uint16x4_t vpmax_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+__ai __attribute__((target("neon"))) uint32x4_t vmulq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 * __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vpmax_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+__ai __attribute__((target("neon"))) uint16x8_t vmulq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = __p0 * __p1;
return __ret;
}
#else
-__ai int8x8_t vpmax_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+__ai __attribute__((target("neon"))) uint16x8_t vmulq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 * __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vpmax_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+__ai __attribute__((target("neon"))) int8x16_t vmulq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = __p0 * __p1;
return __ret;
}
#else
-__ai float32x2_t vpmax_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int8x16_t vmulq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 * __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vpmax_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+__ai __attribute__((target("neon"))) float32x4_t vmulq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = __p0 * __p1;
return __ret;
}
#else
-__ai int32x2_t vpmax_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) float32x4_t vmulq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 * __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vpmax_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+__ai __attribute__((target("neon"))) int32x4_t vmulq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = __p0 * __p1;
return __ret;
}
#else
-__ai int16x4_t vpmax_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+__ai __attribute__((target("neon"))) int32x4_t vmulq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 * __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vpmin_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vmulq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = __p0 * __p1;
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmulq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 * __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vmul_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ __ret = __p0 * __p1;
return __ret;
}
#else
-__ai uint8x8_t vpmin_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vmul_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint8x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __rev0 * __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vpmin_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vmul_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ __ret = __p0 * __p1;
return __ret;
}
#else
-__ai uint32x2_t vpmin_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vmul_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __rev0 * __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vpmin_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vmul_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ __ret = __p0 * __p1;
return __ret;
}
#else
-__ai uint16x4_t vpmin_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vmul_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = __rev0 * __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vpmin_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vmul_s8(int8x8_t __p0, int8x8_t __p1) {
int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+ __ret = __p0 * __p1;
return __ret;
}
#else
-__ai int8x8_t vpmin_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vmul_s8(int8x8_t __p0, int8x8_t __p1) {
int8x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = __rev0 * __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vpmin_f32(float32x2_t __p0, float32x2_t __p1) {
+__ai __attribute__((target("neon"))) float32x2_t vmul_f32(float32x2_t __p0, float32x2_t __p1) {
float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+ __ret = __p0 * __p1;
return __ret;
}
#else
-__ai float32x2_t vpmin_f32(float32x2_t __p0, float32x2_t __p1) {
+__ai __attribute__((target("neon"))) float32x2_t vmul_f32(float32x2_t __p0, float32x2_t __p1) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+ __ret = __rev0 * __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vpmin_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vmul_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+ __ret = __p0 * __p1;
return __ret;
}
#else
-__ai int32x2_t vpmin_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vmul_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = __rev0 * __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vpmin_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vmul_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ __ret = __p0 * __p1;
return __ret;
}
#else
-__ai int16x4_t vpmin_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vmul_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = __rev0 * __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vqabsq_s8(int8x16_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vqabsq_v((int8x16_t)__p0, 32);
+__ai __attribute__((target("neon"))) poly8x8_t vmul_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) __builtin_neon_vmul_v((int8x8_t)__p0, (int8x8_t)__p1, 4);
return __ret;
}
#else
-__ai int8x16_t vqabsq_s8(int8x16_t __p0) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vqabsq_v((int8x16_t)__rev0, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly8x8_t vmul_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vmul_v((int8x8_t)__rev0, (int8x8_t)__rev1, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqabsq_s32(int32x4_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqabsq_v((int8x16_t)__p0, 34);
+__ai __attribute__((target("neon"))) poly8x16_t vmulq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t) __builtin_neon_vmulq_v((int8x16_t)__p0, (int8x16_t)__p1, 36);
return __ret;
}
#else
-__ai int32x4_t vqabsq_s32(int32x4_t __p0) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vqabsq_v((int8x16_t)__rev0, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly8x16_t vmulq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly8x16_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x16_t) __builtin_neon_vmulq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 36);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vqabsq_s16(int16x8_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vqabsq_v((int8x16_t)__p0, 33);
- return __ret;
-}
+#define vmulq_lane_u32(__p0_94, __p1_94, __p2_94) __extension__ ({ \
+ uint32x4_t __ret_94; \
+ uint32x4_t __s0_94 = __p0_94; \
+ uint32x2_t __s1_94 = __p1_94; \
+ __ret_94 = __s0_94 * splatq_lane_u32(__s1_94, __p2_94); \
+ __ret_94; \
+})
#else
-__ai int16x8_t vqabsq_s16(int16x8_t __p0) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vqabsq_v((int8x16_t)__rev0, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vmulq_lane_u32(__p0_95, __p1_95, __p2_95) __extension__ ({ \
+ uint32x4_t __ret_95; \
+ uint32x4_t __s0_95 = __p0_95; \
+ uint32x2_t __s1_95 = __p1_95; \
+ uint32x4_t __rev0_95; __rev0_95 = __builtin_shufflevector(__s0_95, __s0_95, 3, 2, 1, 0); \
+ uint32x2_t __rev1_95; __rev1_95 = __builtin_shufflevector(__s1_95, __s1_95, 1, 0); \
+ __ret_95 = __rev0_95 * __noswap_splatq_lane_u32(__rev1_95, __p2_95); \
+ __ret_95 = __builtin_shufflevector(__ret_95, __ret_95, 3, 2, 1, 0); \
+ __ret_95; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vqabs_s8(int8x8_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vqabs_v((int8x8_t)__p0, 0);
- return __ret;
-}
+#define vmulq_lane_u16(__p0_96, __p1_96, __p2_96) __extension__ ({ \
+ uint16x8_t __ret_96; \
+ uint16x8_t __s0_96 = __p0_96; \
+ uint16x4_t __s1_96 = __p1_96; \
+ __ret_96 = __s0_96 * splatq_lane_u16(__s1_96, __p2_96); \
+ __ret_96; \
+})
#else
-__ai int8x8_t vqabs_s8(int8x8_t __p0) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vqabs_v((int8x8_t)__rev0, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vmulq_lane_u16(__p0_97, __p1_97, __p2_97) __extension__ ({ \
+ uint16x8_t __ret_97; \
+ uint16x8_t __s0_97 = __p0_97; \
+ uint16x4_t __s1_97 = __p1_97; \
+ uint16x8_t __rev0_97; __rev0_97 = __builtin_shufflevector(__s0_97, __s0_97, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x4_t __rev1_97; __rev1_97 = __builtin_shufflevector(__s1_97, __s1_97, 3, 2, 1, 0); \
+ __ret_97 = __rev0_97 * __noswap_splatq_lane_u16(__rev1_97, __p2_97); \
+ __ret_97 = __builtin_shufflevector(__ret_97, __ret_97, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_97; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vqabs_s32(int32x2_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vqabs_v((int8x8_t)__p0, 2);
- return __ret;
-}
+#define vmulq_lane_f32(__p0_98, __p1_98, __p2_98) __extension__ ({ \
+ float32x4_t __ret_98; \
+ float32x4_t __s0_98 = __p0_98; \
+ float32x2_t __s1_98 = __p1_98; \
+ __ret_98 = __s0_98 * splatq_lane_f32(__s1_98, __p2_98); \
+ __ret_98; \
+})
#else
-__ai int32x2_t vqabs_s32(int32x2_t __p0) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vqabs_v((int8x8_t)__rev0, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vmulq_lane_f32(__p0_99, __p1_99, __p2_99) __extension__ ({ \
+ float32x4_t __ret_99; \
+ float32x4_t __s0_99 = __p0_99; \
+ float32x2_t __s1_99 = __p1_99; \
+ float32x4_t __rev0_99; __rev0_99 = __builtin_shufflevector(__s0_99, __s0_99, 3, 2, 1, 0); \
+ float32x2_t __rev1_99; __rev1_99 = __builtin_shufflevector(__s1_99, __s1_99, 1, 0); \
+ __ret_99 = __rev0_99 * __noswap_splatq_lane_f32(__rev1_99, __p2_99); \
+ __ret_99 = __builtin_shufflevector(__ret_99, __ret_99, 3, 2, 1, 0); \
+ __ret_99; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vqabs_s16(int16x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vqabs_v((int8x8_t)__p0, 1);
- return __ret;
-}
+#define vmulq_lane_s32(__p0_100, __p1_100, __p2_100) __extension__ ({ \
+ int32x4_t __ret_100; \
+ int32x4_t __s0_100 = __p0_100; \
+ int32x2_t __s1_100 = __p1_100; \
+ __ret_100 = __s0_100 * splatq_lane_s32(__s1_100, __p2_100); \
+ __ret_100; \
+})
#else
-__ai int16x4_t vqabs_s16(int16x4_t __p0) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vqabs_v((int8x8_t)__rev0, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vmulq_lane_s32(__p0_101, __p1_101, __p2_101) __extension__ ({ \
+ int32x4_t __ret_101; \
+ int32x4_t __s0_101 = __p0_101; \
+ int32x2_t __s1_101 = __p1_101; \
+ int32x4_t __rev0_101; __rev0_101 = __builtin_shufflevector(__s0_101, __s0_101, 3, 2, 1, 0); \
+ int32x2_t __rev1_101; __rev1_101 = __builtin_shufflevector(__s1_101, __s1_101, 1, 0); \
+ __ret_101 = __rev0_101 * __noswap_splatq_lane_s32(__rev1_101, __p2_101); \
+ __ret_101 = __builtin_shufflevector(__ret_101, __ret_101, 3, 2, 1, 0); \
+ __ret_101; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vqaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
- return __ret;
-}
+#define vmulq_lane_s16(__p0_102, __p1_102, __p2_102) __extension__ ({ \
+ int16x8_t __ret_102; \
+ int16x8_t __s0_102 = __p0_102; \
+ int16x4_t __s1_102 = __p1_102; \
+ __ret_102 = __s0_102 * splatq_lane_s16(__s1_102, __p2_102); \
+ __ret_102; \
+})
#else
-__ai uint8x16_t vqaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vmulq_lane_s16(__p0_103, __p1_103, __p2_103) __extension__ ({ \
+ int16x8_t __ret_103; \
+ int16x8_t __s0_103 = __p0_103; \
+ int16x4_t __s1_103 = __p1_103; \
+ int16x8_t __rev0_103; __rev0_103 = __builtin_shufflevector(__s0_103, __s0_103, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x4_t __rev1_103; __rev1_103 = __builtin_shufflevector(__s1_103, __s1_103, 3, 2, 1, 0); \
+ __ret_103 = __rev0_103 * __noswap_splatq_lane_s16(__rev1_103, __p2_103); \
+ __ret_103 = __builtin_shufflevector(__ret_103, __ret_103, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_103; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vqaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
- return __ret;
-}
+#define vmul_lane_u32(__p0_104, __p1_104, __p2_104) __extension__ ({ \
+ uint32x2_t __ret_104; \
+ uint32x2_t __s0_104 = __p0_104; \
+ uint32x2_t __s1_104 = __p1_104; \
+ __ret_104 = __s0_104 * splat_lane_u32(__s1_104, __p2_104); \
+ __ret_104; \
+})
#else
-__ai uint32x4_t vqaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vmul_lane_u32(__p0_105, __p1_105, __p2_105) __extension__ ({ \
+ uint32x2_t __ret_105; \
+ uint32x2_t __s0_105 = __p0_105; \
+ uint32x2_t __s1_105 = __p1_105; \
+ uint32x2_t __rev0_105; __rev0_105 = __builtin_shufflevector(__s0_105, __s0_105, 1, 0); \
+ uint32x2_t __rev1_105; __rev1_105 = __builtin_shufflevector(__s1_105, __s1_105, 1, 0); \
+ __ret_105 = __rev0_105 * __noswap_splat_lane_u32(__rev1_105, __p2_105); \
+ __ret_105 = __builtin_shufflevector(__ret_105, __ret_105, 1, 0); \
+ __ret_105; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vqaddq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+#define vmul_lane_u16(__p0_106, __p1_106, __p2_106) __extension__ ({ \
+ uint16x4_t __ret_106; \
+ uint16x4_t __s0_106 = __p0_106; \
+ uint16x4_t __s1_106 = __p1_106; \
+ __ret_106 = __s0_106 * splat_lane_u16(__s1_106, __p2_106); \
+ __ret_106; \
+})
+#else
+#define vmul_lane_u16(__p0_107, __p1_107, __p2_107) __extension__ ({ \
+ uint16x4_t __ret_107; \
+ uint16x4_t __s0_107 = __p0_107; \
+ uint16x4_t __s1_107 = __p1_107; \
+ uint16x4_t __rev0_107; __rev0_107 = __builtin_shufflevector(__s0_107, __s0_107, 3, 2, 1, 0); \
+ uint16x4_t __rev1_107; __rev1_107 = __builtin_shufflevector(__s1_107, __s1_107, 3, 2, 1, 0); \
+ __ret_107 = __rev0_107 * __noswap_splat_lane_u16(__rev1_107, __p2_107); \
+ __ret_107 = __builtin_shufflevector(__ret_107, __ret_107, 3, 2, 1, 0); \
+ __ret_107; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmul_lane_f32(__p0_108, __p1_108, __p2_108) __extension__ ({ \
+ float32x2_t __ret_108; \
+ float32x2_t __s0_108 = __p0_108; \
+ float32x2_t __s1_108 = __p1_108; \
+ __ret_108 = __s0_108 * splat_lane_f32(__s1_108, __p2_108); \
+ __ret_108; \
+})
+#else
+#define vmul_lane_f32(__p0_109, __p1_109, __p2_109) __extension__ ({ \
+ float32x2_t __ret_109; \
+ float32x2_t __s0_109 = __p0_109; \
+ float32x2_t __s1_109 = __p1_109; \
+ float32x2_t __rev0_109; __rev0_109 = __builtin_shufflevector(__s0_109, __s0_109, 1, 0); \
+ float32x2_t __rev1_109; __rev1_109 = __builtin_shufflevector(__s1_109, __s1_109, 1, 0); \
+ __ret_109 = __rev0_109 * __noswap_splat_lane_f32(__rev1_109, __p2_109); \
+ __ret_109 = __builtin_shufflevector(__ret_109, __ret_109, 1, 0); \
+ __ret_109; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmul_lane_s32(__p0_110, __p1_110, __p2_110) __extension__ ({ \
+ int32x2_t __ret_110; \
+ int32x2_t __s0_110 = __p0_110; \
+ int32x2_t __s1_110 = __p1_110; \
+ __ret_110 = __s0_110 * splat_lane_s32(__s1_110, __p2_110); \
+ __ret_110; \
+})
+#else
+#define vmul_lane_s32(__p0_111, __p1_111, __p2_111) __extension__ ({ \
+ int32x2_t __ret_111; \
+ int32x2_t __s0_111 = __p0_111; \
+ int32x2_t __s1_111 = __p1_111; \
+ int32x2_t __rev0_111; __rev0_111 = __builtin_shufflevector(__s0_111, __s0_111, 1, 0); \
+ int32x2_t __rev1_111; __rev1_111 = __builtin_shufflevector(__s1_111, __s1_111, 1, 0); \
+ __ret_111 = __rev0_111 * __noswap_splat_lane_s32(__rev1_111, __p2_111); \
+ __ret_111 = __builtin_shufflevector(__ret_111, __ret_111, 1, 0); \
+ __ret_111; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmul_lane_s16(__p0_112, __p1_112, __p2_112) __extension__ ({ \
+ int16x4_t __ret_112; \
+ int16x4_t __s0_112 = __p0_112; \
+ int16x4_t __s1_112 = __p1_112; \
+ __ret_112 = __s0_112 * splat_lane_s16(__s1_112, __p2_112); \
+ __ret_112; \
+})
+#else
+#define vmul_lane_s16(__p0_113, __p1_113, __p2_113) __extension__ ({ \
+ int16x4_t __ret_113; \
+ int16x4_t __s0_113 = __p0_113; \
+ int16x4_t __s1_113 = __p1_113; \
+ int16x4_t __rev0_113; __rev0_113 = __builtin_shufflevector(__s0_113, __s0_113, 3, 2, 1, 0); \
+ int16x4_t __rev1_113; __rev1_113 = __builtin_shufflevector(__s1_113, __s1_113, 3, 2, 1, 0); \
+ __ret_113 = __rev0_113 * __noswap_splat_lane_s16(__rev1_113, __p2_113); \
+ __ret_113 = __builtin_shufflevector(__ret_113, __ret_113, 3, 2, 1, 0); \
+ __ret_113; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmulq_n_u32(uint32x4_t __p0, uint32_t __p1) {
+ uint32x4_t __ret;
+ __ret = __p0 * (uint32x4_t) {__p1, __p1, __p1, __p1};
return __ret;
}
#else
-__ai uint64x2_t vqaddq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint32x4_t vmulq_n_u32(uint32x4_t __p0, uint32_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __rev0 * (uint32x4_t) {__p1, __p1, __p1, __p1};
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vqaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vmulq_n_u16(uint16x8_t __p0, uint16_t __p1) {
uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ __ret = __p0 * (uint16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1};
return __ret;
}
#else
-__ai uint16x8_t vqaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vmulq_n_u16(uint16x8_t __p0, uint16_t __p1) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __rev0 * (uint16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1};
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vqaddq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+__ai __attribute__((target("neon"))) float32x4_t vmulq_n_f32(float32x4_t __p0, float32_t __p1) {
+ float32x4_t __ret;
+ __ret = __p0 * (float32x4_t) {__p1, __p1, __p1, __p1};
return __ret;
}
#else
-__ai int8x16_t vqaddq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x4_t vmulq_n_f32(float32x4_t __p0, float32_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __rev0 * (float32x4_t) {__p1, __p1, __p1, __p1};
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vmulq_n_s32(int32x4_t __p0, int32_t __p1) {
int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+ __ret = __p0 * (int32x4_t) {__p1, __p1, __p1, __p1};
return __ret;
}
#else
-__ai int32x4_t vqaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vmulq_n_s32(int32x4_t __p0, int32_t __p1) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+ __ret = __rev0 * (int32x4_t) {__p1, __p1, __p1, __p1};
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vqaddq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
- return __ret;
-}
-#else
-__ai int64x2_t vqaddq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vqaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vmulq_n_s16(int16x8_t __p0, int16_t __p1) {
int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ __ret = __p0 * (int16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1};
return __ret;
}
#else
-__ai int16x8_t vqaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vmulq_n_s16(int16x8_t __p0, int16_t __p1) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vqadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
- return __ret;
-}
-#else
-__ai uint8x8_t vqadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __rev0 * (int16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1};
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vqadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vmul_n_u32(uint32x2_t __p0, uint32_t __p1) {
uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ __ret = __p0 * (uint32x2_t) {__p1, __p1};
return __ret;
}
#else
-__ai uint32x2_t vqadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vmul_n_u32(uint32x2_t __p0, uint32_t __p1) {
uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __rev0 * (uint32x2_t) {__p1, __p1};
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vqadd_u64(uint64x1_t __p0, uint64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vqadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vmul_n_u16(uint16x4_t __p0, uint16_t __p1) {
uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ __ret = __p0 * (uint16x4_t) {__p1, __p1, __p1, __p1};
return __ret;
}
#else
-__ai uint16x4_t vqadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vmul_n_u16(uint16x4_t __p0, uint16_t __p1) {
uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = __rev0 * (uint16x4_t) {__p1, __p1, __p1, __p1};
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vqadd_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+__ai __attribute__((target("neon"))) float32x2_t vmul_n_f32(float32x2_t __p0, float32_t __p1) {
+ float32x2_t __ret;
+ __ret = __p0 * (float32x2_t) {__p1, __p1};
return __ret;
}
#else
-__ai int8x8_t vqadd_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x2_t vmul_n_f32(float32x2_t __p0, float32_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = __rev0 * (float32x2_t) {__p1, __p1};
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vqadd_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vmul_n_s32(int32x2_t __p0, int32_t __p1) {
int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+ __ret = __p0 * (int32x2_t) {__p1, __p1};
return __ret;
}
#else
-__ai int32x2_t vqadd_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vmul_n_s32(int32x2_t __p0, int32_t __p1) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = __rev0 * (int32x2_t) {__p1, __p1};
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai int64x1_t vqadd_s64(int64x1_t __p0, int64x1_t __p1) {
- int64x1_t __ret;
- __ret = (int64x1_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vqadd_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vmul_n_s16(int16x4_t __p0, int16_t __p1) {
int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ __ret = __p0 * (int16x4_t) {__p1, __p1, __p1, __p1};
return __ret;
}
#else
-__ai int16x4_t vqadd_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vmul_n_s16(int16x4_t __p0, int16_t __p1) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = __rev0 * (int16x4_t) {__p1, __p1, __p1, __p1};
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vqdmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vqdmlal_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 35);
+__ai __attribute__((target("neon"))) poly16x8_t vmull_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 37);
return __ret;
}
#else
-__ai int64x2_t vqdmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- int32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vqdmlal_v((int8x16_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 35);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) poly16x8_t vmull_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly16x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly16x8_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 37);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai int64x2_t __noswap_vqdmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vqdmlal_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 35);
+__ai __attribute__((target("neon"))) poly16x8_t __noswap_vmull_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 37);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqdmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqdmlal_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 34);
+__ai __attribute__((target("neon"))) uint16x8_t vmull_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 49);
return __ret;
}
#else
-__ai int32x4_t vqdmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- int16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vqdmlal_v((int8x16_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint16x8_t vmull_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint16x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai int32x4_t __noswap_vqdmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqdmlal_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 34);
+__ai __attribute__((target("neon"))) uint16x8_t __noswap_vmull_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 49);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlal_lane_s32(__p0_114, __p1_114, __p2_114, __p3_114) __extension__ ({ \
- int64x2_t __ret_114; \
- int64x2_t __s0_114 = __p0_114; \
- int32x2_t __s1_114 = __p1_114; \
- int32x2_t __s2_114 = __p2_114; \
- __ret_114 = vqdmlal_s32(__s0_114, __s1_114, splat_lane_s32(__s2_114, __p3_114)); \
- __ret_114; \
-})
-#else
-#define vqdmlal_lane_s32(__p0_115, __p1_115, __p2_115, __p3_115) __extension__ ({ \
- int64x2_t __ret_115; \
- int64x2_t __s0_115 = __p0_115; \
- int32x2_t __s1_115 = __p1_115; \
- int32x2_t __s2_115 = __p2_115; \
- int64x2_t __rev0_115; __rev0_115 = __builtin_shufflevector(__s0_115, __s0_115, 1, 0); \
- int32x2_t __rev1_115; __rev1_115 = __builtin_shufflevector(__s1_115, __s1_115, 1, 0); \
- int32x2_t __rev2_115; __rev2_115 = __builtin_shufflevector(__s2_115, __s2_115, 1, 0); \
- __ret_115 = __noswap_vqdmlal_s32(__rev0_115, __rev1_115, __noswap_splat_lane_s32(__rev2_115, __p3_115)); \
- __ret_115 = __builtin_shufflevector(__ret_115, __ret_115, 1, 0); \
- __ret_115; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vqdmlal_lane_s16(__p0_116, __p1_116, __p2_116, __p3_116) __extension__ ({ \
- int32x4_t __ret_116; \
- int32x4_t __s0_116 = __p0_116; \
- int16x4_t __s1_116 = __p1_116; \
- int16x4_t __s2_116 = __p2_116; \
- __ret_116 = vqdmlal_s16(__s0_116, __s1_116, splat_lane_s16(__s2_116, __p3_116)); \
- __ret_116; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vmull_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 51);
+ return __ret;
+}
#else
-#define vqdmlal_lane_s16(__p0_117, __p1_117, __p2_117, __p3_117) __extension__ ({ \
- int32x4_t __ret_117; \
- int32x4_t __s0_117 = __p0_117; \
- int16x4_t __s1_117 = __p1_117; \
- int16x4_t __s2_117 = __p2_117; \
- int32x4_t __rev0_117; __rev0_117 = __builtin_shufflevector(__s0_117, __s0_117, 3, 2, 1, 0); \
- int16x4_t __rev1_117; __rev1_117 = __builtin_shufflevector(__s1_117, __s1_117, 3, 2, 1, 0); \
- int16x4_t __rev2_117; __rev2_117 = __builtin_shufflevector(__s2_117, __s2_117, 3, 2, 1, 0); \
- __ret_117 = __noswap_vqdmlal_s16(__rev0_117, __rev1_117, __noswap_splat_lane_s16(__rev2_117, __p3_117)); \
- __ret_117 = __builtin_shufflevector(__ret_117, __ret_117, 3, 2, 1, 0); \
- __ret_117; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vmull_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint64x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vmull_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 51);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vqdmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
- int64x2_t __ret;
- __ret = vqdmlal_s32(__p0, __p1, (int32x2_t) {__p2, __p2});
+__ai __attribute__((target("neon"))) uint32x4_t vmull_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 50);
return __ret;
}
#else
-__ai int64x2_t vqdmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __noswap_vqdmlal_s32(__rev0, __rev1, (int32x2_t) {__p2, __p2});
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint32x4_t vmull_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint32x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int64x2_t __noswap_vqdmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
- int64x2_t __ret;
- __ret = __noswap_vqdmlal_s32(__p0, __p1, (int32x2_t) {__p2, __p2});
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vmull_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 50);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqdmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
- int32x4_t __ret;
- __ret = vqdmlal_s16(__p0, __p1, (int16x4_t) {__p2, __p2, __p2, __p2});
+__ai __attribute__((target("neon"))) int16x8_t vmull_s8(int8x8_t __p0, int8x8_t __p1) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 33);
return __ret;
}
#else
-__ai int32x4_t vqdmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vqdmlal_s16(__rev0, __rev1, (int16x4_t) {__p2, __p2, __p2, __p2});
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16x8_t vmull_s8(int8x8_t __p0, int8x8_t __p1) {
+ int16x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai int32x4_t __noswap_vqdmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
- int32x4_t __ret;
- __ret = __noswap_vqdmlal_s16(__p0, __p1, (int16x4_t) {__p2, __p2, __p2, __p2});
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vmull_s8(int8x8_t __p0, int8x8_t __p1) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 33);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vqdmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmull_s32(int32x2_t __p0, int32x2_t __p1) {
int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vqdmlsl_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 35);
+ __ret = (int64x2_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 35);
return __ret;
}
#else
-__ai int64x2_t vqdmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmull_s32(int32x2_t __p0, int32x2_t __p1) {
int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- int32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vqdmlsl_v((int8x16_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 35);
+ __ret = (int64x2_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 35);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai int64x2_t __noswap_vqdmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vmull_s32(int32x2_t __p0, int32x2_t __p1) {
int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vqdmlsl_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 35);
+ __ret = (int64x2_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 35);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqdmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmull_s16(int16x4_t __p0, int16x4_t __p1) {
int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqdmlsl_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 34);
+ __ret = (int32x4_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 34);
return __ret;
}
#else
-__ai int32x4_t vqdmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmull_s16(int16x4_t __p0, int16x4_t __p1) {
int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- int16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vqdmlsl_v((int8x16_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 34);
+ __ret = (int32x4_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 34);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int32x4_t __noswap_vqdmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vmull_s16(int16x4_t __p0, int16x4_t __p1) {
int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqdmlsl_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 34);
+ __ret = (int32x4_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 34);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlsl_lane_s32(__p0_118, __p1_118, __p2_118, __p3_118) __extension__ ({ \
+#define vmull_lane_u32(__p0_114, __p1_114, __p2_114) __extension__ ({ \
+ uint64x2_t __ret_114; \
+ uint32x2_t __s0_114 = __p0_114; \
+ uint32x2_t __s1_114 = __p1_114; \
+ __ret_114 = vmull_u32(__s0_114, splat_lane_u32(__s1_114, __p2_114)); \
+ __ret_114; \
+})
+#else
+#define vmull_lane_u32(__p0_115, __p1_115, __p2_115) __extension__ ({ \
+ uint64x2_t __ret_115; \
+ uint32x2_t __s0_115 = __p0_115; \
+ uint32x2_t __s1_115 = __p1_115; \
+ uint32x2_t __rev0_115; __rev0_115 = __builtin_shufflevector(__s0_115, __s0_115, 1, 0); \
+ uint32x2_t __rev1_115; __rev1_115 = __builtin_shufflevector(__s1_115, __s1_115, 1, 0); \
+ __ret_115 = __noswap_vmull_u32(__rev0_115, __noswap_splat_lane_u32(__rev1_115, __p2_115)); \
+ __ret_115 = __builtin_shufflevector(__ret_115, __ret_115, 1, 0); \
+ __ret_115; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_lane_u16(__p0_116, __p1_116, __p2_116) __extension__ ({ \
+ uint32x4_t __ret_116; \
+ uint16x4_t __s0_116 = __p0_116; \
+ uint16x4_t __s1_116 = __p1_116; \
+ __ret_116 = vmull_u16(__s0_116, splat_lane_u16(__s1_116, __p2_116)); \
+ __ret_116; \
+})
+#else
+#define vmull_lane_u16(__p0_117, __p1_117, __p2_117) __extension__ ({ \
+ uint32x4_t __ret_117; \
+ uint16x4_t __s0_117 = __p0_117; \
+ uint16x4_t __s1_117 = __p1_117; \
+ uint16x4_t __rev0_117; __rev0_117 = __builtin_shufflevector(__s0_117, __s0_117, 3, 2, 1, 0); \
+ uint16x4_t __rev1_117; __rev1_117 = __builtin_shufflevector(__s1_117, __s1_117, 3, 2, 1, 0); \
+ __ret_117 = __noswap_vmull_u16(__rev0_117, __noswap_splat_lane_u16(__rev1_117, __p2_117)); \
+ __ret_117 = __builtin_shufflevector(__ret_117, __ret_117, 3, 2, 1, 0); \
+ __ret_117; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_lane_s32(__p0_118, __p1_118, __p2_118) __extension__ ({ \
int64x2_t __ret_118; \
- int64x2_t __s0_118 = __p0_118; \
+ int32x2_t __s0_118 = __p0_118; \
int32x2_t __s1_118 = __p1_118; \
- int32x2_t __s2_118 = __p2_118; \
- __ret_118 = vqdmlsl_s32(__s0_118, __s1_118, splat_lane_s32(__s2_118, __p3_118)); \
+ __ret_118 = vmull_s32(__s0_118, splat_lane_s32(__s1_118, __p2_118)); \
__ret_118; \
})
#else
-#define vqdmlsl_lane_s32(__p0_119, __p1_119, __p2_119, __p3_119) __extension__ ({ \
+#define vmull_lane_s32(__p0_119, __p1_119, __p2_119) __extension__ ({ \
int64x2_t __ret_119; \
- int64x2_t __s0_119 = __p0_119; \
+ int32x2_t __s0_119 = __p0_119; \
int32x2_t __s1_119 = __p1_119; \
- int32x2_t __s2_119 = __p2_119; \
- int64x2_t __rev0_119; __rev0_119 = __builtin_shufflevector(__s0_119, __s0_119, 1, 0); \
+ int32x2_t __rev0_119; __rev0_119 = __builtin_shufflevector(__s0_119, __s0_119, 1, 0); \
int32x2_t __rev1_119; __rev1_119 = __builtin_shufflevector(__s1_119, __s1_119, 1, 0); \
- int32x2_t __rev2_119; __rev2_119 = __builtin_shufflevector(__s2_119, __s2_119, 1, 0); \
- __ret_119 = __noswap_vqdmlsl_s32(__rev0_119, __rev1_119, __noswap_splat_lane_s32(__rev2_119, __p3_119)); \
+ __ret_119 = __noswap_vmull_s32(__rev0_119, __noswap_splat_lane_s32(__rev1_119, __p2_119)); \
__ret_119 = __builtin_shufflevector(__ret_119, __ret_119, 1, 0); \
__ret_119; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlsl_lane_s16(__p0_120, __p1_120, __p2_120, __p3_120) __extension__ ({ \
+#define vmull_lane_s16(__p0_120, __p1_120, __p2_120) __extension__ ({ \
int32x4_t __ret_120; \
- int32x4_t __s0_120 = __p0_120; \
+ int16x4_t __s0_120 = __p0_120; \
int16x4_t __s1_120 = __p1_120; \
- int16x4_t __s2_120 = __p2_120; \
- __ret_120 = vqdmlsl_s16(__s0_120, __s1_120, splat_lane_s16(__s2_120, __p3_120)); \
+ __ret_120 = vmull_s16(__s0_120, splat_lane_s16(__s1_120, __p2_120)); \
__ret_120; \
})
#else
-#define vqdmlsl_lane_s16(__p0_121, __p1_121, __p2_121, __p3_121) __extension__ ({ \
+#define vmull_lane_s16(__p0_121, __p1_121, __p2_121) __extension__ ({ \
int32x4_t __ret_121; \
- int32x4_t __s0_121 = __p0_121; \
+ int16x4_t __s0_121 = __p0_121; \
int16x4_t __s1_121 = __p1_121; \
- int16x4_t __s2_121 = __p2_121; \
- int32x4_t __rev0_121; __rev0_121 = __builtin_shufflevector(__s0_121, __s0_121, 3, 2, 1, 0); \
+ int16x4_t __rev0_121; __rev0_121 = __builtin_shufflevector(__s0_121, __s0_121, 3, 2, 1, 0); \
int16x4_t __rev1_121; __rev1_121 = __builtin_shufflevector(__s1_121, __s1_121, 3, 2, 1, 0); \
- int16x4_t __rev2_121; __rev2_121 = __builtin_shufflevector(__s2_121, __s2_121, 3, 2, 1, 0); \
- __ret_121 = __noswap_vqdmlsl_s16(__rev0_121, __rev1_121, __noswap_splat_lane_s16(__rev2_121, __p3_121)); \
+ __ret_121 = __noswap_vmull_s16(__rev0_121, __noswap_splat_lane_s16(__rev1_121, __p2_121)); \
__ret_121 = __builtin_shufflevector(__ret_121, __ret_121, 3, 2, 1, 0); \
__ret_121; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vqdmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
- int64x2_t __ret;
- __ret = vqdmlsl_s32(__p0, __p1, (int32x2_t) {__p2, __p2});
+__ai __attribute__((target("neon"))) uint64x2_t vmull_n_u32(uint32x2_t __p0, uint32_t __p1) {
+ uint64x2_t __ret;
+ __ret = vmull_u32(__p0, (uint32x2_t) {__p1, __p1});
return __ret;
}
#else
-__ai int64x2_t vqdmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __noswap_vqdmlsl_s32(__rev0, __rev1, (int32x2_t) {__p2, __p2});
+__ai __attribute__((target("neon"))) uint64x2_t vmull_n_u32(uint32x2_t __p0, uint32_t __p1) {
+ uint64x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = __noswap_vmull_u32(__rev0, (uint32x2_t) {__p1, __p1});
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai int64x2_t __noswap_vqdmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
- int64x2_t __ret;
- __ret = __noswap_vqdmlsl_s32(__p0, __p1, (int32x2_t) {__p2, __p2});
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vmull_n_u32(uint32x2_t __p0, uint32_t __p1) {
+ uint64x2_t __ret;
+ __ret = __noswap_vmull_u32(__p0, (uint32x2_t) {__p1, __p1});
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqdmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
- int32x4_t __ret;
- __ret = vqdmlsl_s16(__p0, __p1, (int16x4_t) {__p2, __p2, __p2, __p2});
+__ai __attribute__((target("neon"))) uint32x4_t vmull_n_u16(uint16x4_t __p0, uint16_t __p1) {
+ uint32x4_t __ret;
+ __ret = vmull_u16(__p0, (uint16x4_t) {__p1, __p1, __p1, __p1});
return __ret;
}
#else
-__ai int32x4_t vqdmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vqdmlsl_s16(__rev0, __rev1, (int16x4_t) {__p2, __p2, __p2, __p2});
+__ai __attribute__((target("neon"))) uint32x4_t vmull_n_u16(uint16x4_t __p0, uint16_t __p1) {
+ uint32x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __noswap_vmull_u16(__rev0, (uint16x4_t) {__p1, __p1, __p1, __p1});
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int32x4_t __noswap_vqdmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
- int32x4_t __ret;
- __ret = __noswap_vqdmlsl_s16(__p0, __p1, (int16x4_t) {__p2, __p2, __p2, __p2});
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vmull_n_u16(uint16x4_t __p0, uint16_t __p1) {
+ uint32x4_t __ret;
+ __ret = __noswap_vmull_u16(__p0, (uint16x4_t) {__p1, __p1, __p1, __p1});
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqdmulhq_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vmull_n_s32(int32x2_t __p0, int32_t __p1) {
+ int64x2_t __ret;
+ __ret = vmull_s32(__p0, (int32x2_t) {__p1, __p1});
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vmull_n_s32(int32x2_t __p0, int32_t __p1) {
+ int64x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = __noswap_vmull_s32(__rev0, (int32x2_t) {__p1, __p1});
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vmull_n_s32(int32x2_t __p0, int32_t __p1) {
+ int64x2_t __ret;
+ __ret = __noswap_vmull_s32(__p0, (int32x2_t) {__p1, __p1});
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmull_n_s16(int16x4_t __p0, int16_t __p1) {
int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+ __ret = vmull_s16(__p0, (int16x4_t) {__p1, __p1, __p1, __p1});
return __ret;
}
#else
-__ai int32x4_t vqdmulhq_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vmull_n_s16(int16x4_t __p0, int16_t __p1) {
int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vqdmulhq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __noswap_vmull_s16(__rev0, (int16x4_t) {__p1, __p1, __p1, __p1});
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int32x4_t __noswap_vqdmulhq_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vmull_n_s16(int16x4_t __p0, int16_t __p1) {
int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+ __ret = __noswap_vmull_s16(__p0, (int16x4_t) {__p1, __p1, __p1, __p1});
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vqdmulhq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vqdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+__ai __attribute__((target("neon"))) poly8x8_t vmvn_p8(poly8x8_t __p0) {
+ poly8x8_t __ret;
+ __ret = ~__p0;
return __ret;
}
#else
-__ai int16x8_t vqdmulhq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vqdmulhq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+__ai __attribute__((target("neon"))) poly8x8_t vmvn_p8(poly8x8_t __p0) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = ~__rev0;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai int16x8_t __noswap_vqdmulhq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vqdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vmvnq_p8(poly8x16_t __p0) {
+ poly8x16_t __ret;
+ __ret = ~__p0;
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vmvnq_p8(poly8x16_t __p0) {
+ poly8x16_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = ~__rev0;
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vqdmulh_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vqdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+__ai __attribute__((target("neon"))) uint8x16_t vmvnq_u8(uint8x16_t __p0) {
+ uint8x16_t __ret;
+ __ret = ~__p0;
return __ret;
}
#else
-__ai int32x2_t vqdmulh_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vqdmulh_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vmvnq_u8(uint8x16_t __p0) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = ~__rev0;
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai int32x2_t __noswap_vqdmulh_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vqdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmvnq_u32(uint32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = ~__p0;
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmvnq_u32(uint32x4_t __p0) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = ~__rev0;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vqdmulh_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vqdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+__ai __attribute__((target("neon"))) uint16x8_t vmvnq_u16(uint16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = ~__p0;
return __ret;
}
#else
-__ai int16x4_t vqdmulh_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vqdmulh_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint16x8_t vmvnq_u16(uint16x8_t __p0) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = ~__rev0;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai int16x4_t __noswap_vqdmulh_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vqdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vmvnq_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ __ret = ~__p0;
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vmvnq_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = ~__rev0;
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqdmulhq_n_s32(int32x4_t __p0, int32_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vmvnq_s32(int32x4_t __p0) {
int32x4_t __ret;
- __ret = vqdmulhq_s32(__p0, (int32x4_t) {__p1, __p1, __p1, __p1});
+ __ret = ~__p0;
return __ret;
}
#else
-__ai int32x4_t vqdmulhq_n_s32(int32x4_t __p0, int32_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vmvnq_s32(int32x4_t __p0) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __noswap_vqdmulhq_s32(__rev0, (int32x4_t) {__p1, __p1, __p1, __p1});
+ __ret = ~__rev0;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vqdmulhq_n_s16(int16x8_t __p0, int16_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vmvnq_s16(int16x8_t __p0) {
int16x8_t __ret;
- __ret = vqdmulhq_s16(__p0, (int16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1});
+ __ret = ~__p0;
return __ret;
}
#else
-__ai int16x8_t vqdmulhq_n_s16(int16x8_t __p0, int16_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vmvnq_s16(int16x8_t __p0) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vqdmulhq_s16(__rev0, (int16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1});
+ __ret = ~__rev0;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vqdmulh_n_s32(int32x2_t __p0, int32_t __p1) {
- int32x2_t __ret;
- __ret = vqdmulh_s32(__p0, (int32x2_t) {__p1, __p1});
+__ai __attribute__((target("neon"))) uint8x8_t vmvn_u8(uint8x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = ~__p0;
return __ret;
}
#else
-__ai int32x2_t vqdmulh_n_s32(int32x2_t __p0, int32_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __noswap_vqdmulh_s32(__rev0, (int32x2_t) {__p1, __p1});
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint8x8_t vmvn_u8(uint8x8_t __p0) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = ~__rev0;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vqdmulh_n_s16(int16x4_t __p0, int16_t __p1) {
- int16x4_t __ret;
- __ret = vqdmulh_s16(__p0, (int16x4_t) {__p1, __p1, __p1, __p1});
+__ai __attribute__((target("neon"))) uint32x2_t vmvn_u32(uint32x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = ~__p0;
return __ret;
}
#else
-__ai int16x4_t vqdmulh_n_s16(int16x4_t __p0, int16_t __p1) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __noswap_vqdmulh_s16(__rev0, (int16x4_t) {__p1, __p1, __p1, __p1});
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x2_t vmvn_u32(uint32x2_t __p0) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = ~__rev0;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vqdmull_s32(int32x2_t __p0, int32x2_t __p1) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vqdmull_v((int8x8_t)__p0, (int8x8_t)__p1, 35);
+__ai __attribute__((target("neon"))) uint16x4_t vmvn_u16(uint16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = ~__p0;
return __ret;
}
#else
-__ai int64x2_t vqdmull_s32(int32x2_t __p0, int32x2_t __p1) {
- int64x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vqdmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 35);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai int64x2_t __noswap_vqdmull_s32(int32x2_t __p0, int32x2_t __p1) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vqdmull_v((int8x8_t)__p0, (int8x8_t)__p1, 35);
+__ai __attribute__((target("neon"))) uint16x4_t vmvn_u16(uint16x4_t __p0) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = ~__rev0;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqdmull_s16(int16x4_t __p0, int16x4_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqdmull_v((int8x8_t)__p0, (int8x8_t)__p1, 34);
+__ai __attribute__((target("neon"))) int8x8_t vmvn_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ __ret = ~__p0;
return __ret;
}
#else
-__ai int32x4_t vqdmull_s16(int16x4_t __p0, int16x4_t __p1) {
- int32x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vqdmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai int32x4_t __noswap_vqdmull_s16(int16x4_t __p0, int16x4_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqdmull_v((int8x8_t)__p0, (int8x8_t)__p1, 34);
+__ai __attribute__((target("neon"))) int8x8_t vmvn_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = ~__rev0;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmull_lane_s32(__p0_122, __p1_122, __p2_122) __extension__ ({ \
- int64x2_t __ret_122; \
- int32x2_t __s0_122 = __p0_122; \
- int32x2_t __s1_122 = __p1_122; \
- __ret_122 = vqdmull_s32(__s0_122, splat_lane_s32(__s1_122, __p2_122)); \
- __ret_122; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vmvn_s32(int32x2_t __p0) {
+ int32x2_t __ret;
+ __ret = ~__p0;
+ return __ret;
+}
#else
-#define vqdmull_lane_s32(__p0_123, __p1_123, __p2_123) __extension__ ({ \
- int64x2_t __ret_123; \
- int32x2_t __s0_123 = __p0_123; \
- int32x2_t __s1_123 = __p1_123; \
- int32x2_t __rev0_123; __rev0_123 = __builtin_shufflevector(__s0_123, __s0_123, 1, 0); \
- int32x2_t __rev1_123; __rev1_123 = __builtin_shufflevector(__s1_123, __s1_123, 1, 0); \
- __ret_123 = __noswap_vqdmull_s32(__rev0_123, __noswap_splat_lane_s32(__rev1_123, __p2_123)); \
- __ret_123 = __builtin_shufflevector(__ret_123, __ret_123, 1, 0); \
- __ret_123; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vmvn_s32(int32x2_t __p0) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = ~__rev0;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmull_lane_s16(__p0_124, __p1_124, __p2_124) __extension__ ({ \
- int32x4_t __ret_124; \
- int16x4_t __s0_124 = __p0_124; \
- int16x4_t __s1_124 = __p1_124; \
- __ret_124 = vqdmull_s16(__s0_124, splat_lane_s16(__s1_124, __p2_124)); \
- __ret_124; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vmvn_s16(int16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = ~__p0;
+ return __ret;
+}
#else
-#define vqdmull_lane_s16(__p0_125, __p1_125, __p2_125) __extension__ ({ \
- int32x4_t __ret_125; \
- int16x4_t __s0_125 = __p0_125; \
- int16x4_t __s1_125 = __p1_125; \
- int16x4_t __rev0_125; __rev0_125 = __builtin_shufflevector(__s0_125, __s0_125, 3, 2, 1, 0); \
- int16x4_t __rev1_125; __rev1_125 = __builtin_shufflevector(__s1_125, __s1_125, 3, 2, 1, 0); \
- __ret_125 = __noswap_vqdmull_s16(__rev0_125, __noswap_splat_lane_s16(__rev1_125, __p2_125)); \
- __ret_125 = __builtin_shufflevector(__ret_125, __ret_125, 3, 2, 1, 0); \
- __ret_125; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vmvn_s16(int16x4_t __p0) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = ~__rev0;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vqdmull_n_s32(int32x2_t __p0, int32_t __p1) {
- int64x2_t __ret;
- __ret = vqdmull_s32(__p0, (int32x2_t) {__p1, __p1});
+__ai __attribute__((target("neon"))) int8x16_t vnegq_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ __ret = -__p0;
return __ret;
}
#else
-__ai int64x2_t vqdmull_n_s32(int32x2_t __p0, int32_t __p1) {
- int64x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __noswap_vqdmull_s32(__rev0, (int32x2_t) {__p1, __p1});
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai int64x2_t __noswap_vqdmull_n_s32(int32x2_t __p0, int32_t __p1) {
- int64x2_t __ret;
- __ret = __noswap_vqdmull_s32(__p0, (int32x2_t) {__p1, __p1});
+__ai __attribute__((target("neon"))) int8x16_t vnegq_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = -__rev0;
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqdmull_n_s16(int16x4_t __p0, int16_t __p1) {
- int32x4_t __ret;
- __ret = vqdmull_s16(__p0, (int16x4_t) {__p1, __p1, __p1, __p1});
+__ai __attribute__((target("neon"))) float32x4_t vnegq_f32(float32x4_t __p0) {
+ float32x4_t __ret;
+ __ret = -__p0;
return __ret;
}
#else
-__ai int32x4_t vqdmull_n_s16(int16x4_t __p0, int16_t __p1) {
- int32x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __noswap_vqdmull_s16(__rev0, (int16x4_t) {__p1, __p1, __p1, __p1});
+__ai __attribute__((target("neon"))) float32x4_t vnegq_f32(float32x4_t __p0) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = -__rev0;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int32x4_t __noswap_vqdmull_n_s16(int16x4_t __p0, int16_t __p1) {
- int32x4_t __ret;
- __ret = __noswap_vqdmull_s16(__p0, (int16x4_t) {__p1, __p1, __p1, __p1});
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vqmovn_u32(uint32x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 17);
+__ai __attribute__((target("neon"))) int32x4_t vnegq_s32(int32x4_t __p0) {
+ int32x4_t __ret;
+ __ret = -__p0;
return __ret;
}
#else
-__ai uint16x4_t vqmovn_u32(uint32x4_t __p0) {
- uint16x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vqmovn_v((int8x16_t)__rev0, 17);
+__ai __attribute__((target("neon"))) int32x4_t vnegq_s32(int32x4_t __p0) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = -__rev0;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai uint16x4_t __noswap_vqmovn_u32(uint32x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 17);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vqmovn_u64(uint64x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 18);
+__ai __attribute__((target("neon"))) int16x8_t vnegq_s16(int16x8_t __p0) {
+ int16x8_t __ret;
+ __ret = -__p0;
return __ret;
}
#else
-__ai uint32x2_t vqmovn_u64(uint64x2_t __p0) {
- uint32x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vqmovn_v((int8x16_t)__rev0, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai uint32x2_t __noswap_vqmovn_u64(uint64x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 18);
+__ai __attribute__((target("neon"))) int16x8_t vnegq_s16(int16x8_t __p0) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = -__rev0;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vqmovn_u16(uint16x8_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 16);
+__ai __attribute__((target("neon"))) int8x8_t vneg_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ __ret = -__p0;
return __ret;
}
#else
-__ai uint8x8_t vqmovn_u16(uint16x8_t __p0) {
- uint8x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vqmovn_v((int8x16_t)__rev0, 16);
+__ai __attribute__((target("neon"))) int8x8_t vneg_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = -__rev0;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai uint8x8_t __noswap_vqmovn_u16(uint16x8_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 16);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vqmovn_s32(int32x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 1);
+__ai __attribute__((target("neon"))) float32x2_t vneg_f32(float32x2_t __p0) {
+ float32x2_t __ret;
+ __ret = -__p0;
return __ret;
}
#else
-__ai int16x4_t vqmovn_s32(int32x4_t __p0) {
- int16x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vqmovn_v((int8x16_t)__rev0, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai int16x4_t __noswap_vqmovn_s32(int32x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 1);
+__ai __attribute__((target("neon"))) float32x2_t vneg_f32(float32x2_t __p0) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = -__rev0;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vqmovn_s64(int64x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vneg_s32(int32x2_t __p0) {
int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 2);
+ __ret = -__p0;
return __ret;
}
#else
-__ai int32x2_t vqmovn_s64(int64x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vneg_s32(int32x2_t __p0) {
int32x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vqmovn_v((int8x16_t)__rev0, 2);
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = -__rev0;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai int32x2_t __noswap_vqmovn_s64(int64x2_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 2);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vqmovn_s16(int16x8_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 0);
+__ai __attribute__((target("neon"))) int16x4_t vneg_s16(int16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = -__p0;
return __ret;
}
#else
-__ai int8x8_t vqmovn_s16(int16x8_t __p0) {
- int8x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vqmovn_v((int8x16_t)__rev0, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16x4_t vneg_s16(int16x4_t __p0) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = -__rev0;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int8x8_t __noswap_vqmovn_s16(int16x8_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vornq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = __p0 | ~__p1;
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vornq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 | ~__rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vqmovun_s32(int32x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vqmovun_v((int8x16_t)__p0, 17);
+__ai __attribute__((target("neon"))) uint32x4_t vornq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = __p0 | ~__p1;
return __ret;
}
#else
-__ai uint16x4_t vqmovun_s32(int32x4_t __p0) {
- uint16x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vqmovun_v((int8x16_t)__rev0, 17);
+__ai __attribute__((target("neon"))) uint32x4_t vornq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 | ~__rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai uint16x4_t __noswap_vqmovun_s32(int32x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vqmovun_v((int8x16_t)__p0, 17);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vqmovun_s64(int64x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vqmovun_v((int8x16_t)__p0, 18);
+__ai __attribute__((target("neon"))) uint64x2_t vornq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = __p0 | ~__p1;
return __ret;
}
#else
-__ai uint32x2_t vqmovun_s64(int64x2_t __p0) {
- uint32x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vqmovun_v((int8x16_t)__rev0, 18);
+__ai __attribute__((target("neon"))) uint64x2_t vornq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 | ~__rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai uint32x2_t __noswap_vqmovun_s64(int64x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vqmovun_v((int8x16_t)__p0, 18);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vqmovun_s16(int16x8_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vqmovun_v((int8x16_t)__p0, 16);
+__ai __attribute__((target("neon"))) uint16x8_t vornq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = __p0 | ~__p1;
return __ret;
}
#else
-__ai uint8x8_t vqmovun_s16(int16x8_t __p0) {
- uint8x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vqmovun_v((int8x16_t)__rev0, 16);
+__ai __attribute__((target("neon"))) uint16x8_t vornq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 | ~__rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai uint8x8_t __noswap_vqmovun_s16(int16x8_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vqmovun_v((int8x16_t)__p0, 16);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vqnegq_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vornq_s8(int8x16_t __p0, int8x16_t __p1) {
int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vqnegq_v((int8x16_t)__p0, 32);
+ __ret = __p0 | ~__p1;
return __ret;
}
#else
-__ai int8x16_t vqnegq_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vornq_s8(int8x16_t __p0, int8x16_t __p1) {
int8x16_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vqnegq_v((int8x16_t)__rev0, 32);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 | ~__rev1;
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqnegq_s32(int32x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vornq_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqnegq_v((int8x16_t)__p0, 34);
+ __ret = __p0 | ~__p1;
return __ret;
}
#else
-__ai int32x4_t vqnegq_s32(int32x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vornq_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vqnegq_v((int8x16_t)__rev0, 34);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 | ~__rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vqnegq_s16(int16x8_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vqnegq_v((int8x16_t)__p0, 33);
- return __ret;
-}
-#else
-__ai int16x8_t vqnegq_s16(int16x8_t __p0) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vqnegq_v((int8x16_t)__rev0, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vqneg_s8(int8x8_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vqneg_v((int8x8_t)__p0, 0);
- return __ret;
-}
-#else
-__ai int8x8_t vqneg_s8(int8x8_t __p0) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vqneg_v((int8x8_t)__rev0, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vqneg_s32(int32x2_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vqneg_v((int8x8_t)__p0, 2);
+__ai __attribute__((target("neon"))) int64x2_t vornq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ __ret = __p0 | ~__p1;
return __ret;
}
#else
-__ai int32x2_t vqneg_s32(int32x2_t __p0) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vqneg_v((int8x8_t)__rev0, 2);
+__ai __attribute__((target("neon"))) int64x2_t vornq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 | ~__rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vqneg_s16(int16x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vqneg_v((int8x8_t)__p0, 1);
- return __ret;
-}
-#else
-__ai int16x4_t vqneg_s16(int16x4_t __p0) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vqneg_v((int8x8_t)__rev0, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqrdmulhq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqrdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
- return __ret;
-}
-#else
-__ai int32x4_t vqrdmulhq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vqrdmulhq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai int32x4_t __noswap_vqrdmulhq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqrdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vqrdmulhq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vornq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vqrdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ __ret = __p0 | ~__p1;
return __ret;
}
#else
-__ai int16x8_t vqrdmulhq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vornq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vqrdmulhq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = __rev0 | ~__rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai int16x8_t __noswap_vqrdmulhq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vqrdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vqrdmulh_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vqrdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+__ai __attribute__((target("neon"))) uint8x8_t vorn_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = __p0 | ~__p1;
return __ret;
}
#else
-__ai int32x2_t vqrdmulh_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vqrdmulh_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai int32x2_t __noswap_vqrdmulh_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vqrdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+__ai __attribute__((target("neon"))) uint8x8_t vorn_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 | ~__rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vqrdmulh_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vqrdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+__ai __attribute__((target("neon"))) uint32x2_t vorn_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = __p0 | ~__p1;
return __ret;
}
#else
-__ai int16x4_t vqrdmulh_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vqrdmulh_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai int16x4_t __noswap_vqrdmulh_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vqrdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+__ai __attribute__((target("neon"))) uint32x2_t vorn_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 | ~__rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vorn_u64(uint64x1_t __p0, uint64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = __p0 | ~__p1;
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqrdmulhq_n_s32(int32x4_t __p0, int32_t __p1) {
- int32x4_t __ret;
- __ret = vqrdmulhq_s32(__p0, (int32x4_t) {__p1, __p1, __p1, __p1});
+__ai __attribute__((target("neon"))) uint16x4_t vorn_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = __p0 | ~__p1;
return __ret;
}
#else
-__ai int32x4_t vqrdmulhq_n_s32(int32x4_t __p0, int32_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __noswap_vqrdmulhq_s32(__rev0, (int32x4_t) {__p1, __p1, __p1, __p1});
+__ai __attribute__((target("neon"))) uint16x4_t vorn_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 | ~__rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vqrdmulhq_n_s16(int16x8_t __p0, int16_t __p1) {
- int16x8_t __ret;
- __ret = vqrdmulhq_s16(__p0, (int16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1});
+__ai __attribute__((target("neon"))) int8x8_t vorn_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = __p0 | ~__p1;
return __ret;
}
#else
-__ai int16x8_t vqrdmulhq_n_s16(int16x8_t __p0, int16_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vqrdmulhq_s16(__rev0, (int16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1});
+__ai __attribute__((target("neon"))) int8x8_t vorn_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 | ~__rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vqrdmulh_n_s32(int32x2_t __p0, int32_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vorn_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
- __ret = vqrdmulh_s32(__p0, (int32x2_t) {__p1, __p1});
+ __ret = __p0 | ~__p1;
return __ret;
}
#else
-__ai int32x2_t vqrdmulh_n_s32(int32x2_t __p0, int32_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vorn_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __noswap_vqrdmulh_s32(__rev0, (int32x2_t) {__p1, __p1});
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 | ~__rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
+__ai __attribute__((target("neon"))) int64x1_t vorn_s64(int64x1_t __p0, int64x1_t __p1) {
+ int64x1_t __ret;
+ __ret = __p0 | ~__p1;
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vqrdmulh_n_s16(int16x4_t __p0, int16_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vorn_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
- __ret = vqrdmulh_s16(__p0, (int16x4_t) {__p1, __p1, __p1, __p1});
+ __ret = __p0 | ~__p1;
return __ret;
}
#else
-__ai int16x4_t vqrdmulh_n_s16(int16x4_t __p0, int16_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vorn_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __noswap_vqrdmulh_s16(__rev0, (int16x4_t) {__p1, __p1, __p1, __p1});
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 | ~__rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vqrshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint8x16_t vorrq_u8(uint8x16_t __p0, uint8x16_t __p1) {
uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ __ret = __p0 | __p1;
return __ret;
}
#else
-__ai uint8x16_t vqrshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint8x16_t vorrq_u8(uint8x16_t __p0, uint8x16_t __p1) {
uint8x16_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 | __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vqrshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vorrq_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+ __ret = __p0 | __p1;
return __ret;
}
#else
-__ai uint32x4_t vqrshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vorrq_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 | __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vqrshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vorrq_u64(uint64x2_t __p0, uint64x2_t __p1) {
uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+ __ret = __p0 | __p1;
return __ret;
}
#else
-__ai uint64x2_t vqrshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vorrq_u64(uint64x2_t __p0, uint64x2_t __p1) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 | __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vqrshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vorrq_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ __ret = __p0 | __p1;
return __ret;
}
#else
-__ai uint16x8_t vqrshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vorrq_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 | __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vqrshlq_s8(int8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) int8x16_t vorrq_s8(int8x16_t __p0, int8x16_t __p1) {
int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+ __ret = __p0 | __p1;
return __ret;
}
#else
-__ai int8x16_t vqrshlq_s8(int8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) int8x16_t vorrq_s8(int8x16_t __p0, int8x16_t __p1) {
int8x16_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+ __ret = __rev0 | __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqrshlq_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vorrq_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+ __ret = __p0 | __p1;
return __ret;
}
#else
-__ai int32x4_t vqrshlq_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vorrq_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+ __ret = __rev0 | __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vqrshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vorrq_s64(int64x2_t __p0, int64x2_t __p1) {
int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+ __ret = __p0 | __p1;
return __ret;
}
#else
-__ai int64x2_t vqrshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vorrq_s64(int64x2_t __p0, int64x2_t __p1) {
int64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+ __ret = __rev0 | __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vqrshlq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vorrq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ __ret = __p0 | __p1;
return __ret;
}
#else
-__ai int16x8_t vqrshlq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vorrq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = __rev0 | __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vqrshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vorr_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ __ret = __p0 | __p1;
return __ret;
}
#else
-__ai uint8x8_t vqrshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vorr_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint8x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vqrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 | __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vqrshl_u32(uint32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vorr_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ __ret = __p0 | __p1;
return __ret;
}
#else
-__ai uint32x2_t vqrshl_u32(uint32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vorr_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vqrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 | __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vqrshl_u64(uint64x1_t __p0, int64x1_t __p1) {
+__ai __attribute__((target("neon"))) uint64x1_t vorr_u64(uint64x1_t __p0, uint64x1_t __p1) {
uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+ __ret = __p0 | __p1;
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vqrshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vorr_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ __ret = __p0 | __p1;
return __ret;
}
#else
-__ai uint16x4_t vqrshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vorr_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vqrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 | __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vqrshl_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vorr_s8(int8x8_t __p0, int8x8_t __p1) {
int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+ __ret = __p0 | __p1;
return __ret;
}
#else
-__ai int8x8_t vqrshl_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vorr_s8(int8x8_t __p0, int8x8_t __p1) {
int8x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vqrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = __rev0 | __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vqrshl_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vorr_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+ __ret = __p0 | __p1;
return __ret;
}
#else
-__ai int32x2_t vqrshl_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vorr_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vqrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = __rev0 | __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai int64x1_t vqrshl_s64(int64x1_t __p0, int64x1_t __p1) {
+__ai __attribute__((target("neon"))) int64x1_t vorr_s64(int64x1_t __p0, int64x1_t __p1) {
int64x1_t __ret;
- __ret = (int64x1_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
+ __ret = __p0 | __p1;
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vqrshl_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vorr_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ __ret = __p0 | __p1;
return __ret;
}
#else
-__ai int16x4_t vqrshl_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vorr_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vqrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = __rev0 | __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrshrn_n_u32(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 17); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vpadalq_u8(uint16x8_t __p0, uint8x16_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vpadalq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ return __ret;
+}
#else
-#define vqrshrn_n_u32(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__rev0, __p1, 17); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vqrshrn_n_u32(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 17); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vpadalq_u8(uint16x8_t __p0, uint8x16_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vpadalq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrshrn_n_u64(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 18); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vpadalq_u32(uint64x2_t __p0, uint32x4_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vpadalq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+ return __ret;
+}
#else
-#define vqrshrn_n_u64(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__rev0, __p1, 18); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_vqrshrn_n_u64(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 18); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vpadalq_u32(uint64x2_t __p0, uint32x4_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vpadalq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrshrn_n_u16(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 16); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vpadalq_u16(uint32x4_t __p0, uint16x8_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vpadalq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+ return __ret;
+}
#else
-#define vqrshrn_n_u16(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__rev0, __p1, 16); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vqrshrn_n_u16(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 16); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vpadalq_u16(uint32x4_t __p0, uint16x8_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vpadalq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrshrn_n_s32(__p0, __p1) __extension__ ({ \
- int16x4_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (int16x4_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vpadalq_s8(int16x8_t __p0, int8x16_t __p1) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vpadalq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ return __ret;
+}
#else
-#define vqrshrn_n_s32(__p0, __p1) __extension__ ({ \
- int16x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__rev0, __p1, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vqrshrn_n_s32(__p0, __p1) __extension__ ({ \
- int16x4_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (int16x4_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vpadalq_s8(int16x8_t __p0, int8x16_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vpadalq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrshrn_n_s64(__p0, __p1) __extension__ ({ \
- int32x2_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (int32x2_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vpadalq_s32(int64x2_t __p0, int32x4_t __p1) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vpadalq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+ return __ret;
+}
#else
-#define vqrshrn_n_s64(__p0, __p1) __extension__ ({ \
- int32x2_t __ret; \
- int64x2_t __s0 = __p0; \
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__rev0, __p1, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_vqrshrn_n_s64(__p0, __p1) __extension__ ({ \
- int32x2_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (int32x2_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vpadalq_s32(int64x2_t __p0, int32x4_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vpadalq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrshrn_n_s16(__p0, __p1) __extension__ ({ \
- int8x8_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (int8x8_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vpadalq_s16(int32x4_t __p0, int16x8_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vpadalq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+ return __ret;
+}
#else
-#define vqrshrn_n_s16(__p0, __p1) __extension__ ({ \
- int8x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x8_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__rev0, __p1, 0); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vqrshrn_n_s16(__p0, __p1) __extension__ ({ \
- int8x8_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (int8x8_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vpadalq_s16(int32x4_t __p0, int16x8_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vpadalq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrshrun_n_s32(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__s0, __p1, 17); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vpadal_u8(uint16x4_t __p0, uint8x8_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ return __ret;
+}
#else
-#define vqrshrun_n_s32(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__rev0, __p1, 17); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vqrshrun_n_s32(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__s0, __p1, 17); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vpadal_u8(uint16x4_t __p0, uint8x8_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vpadal_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrshrun_n_s64(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__s0, __p1, 18); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x1_t vpadal_u32(uint64x1_t __p0, uint32x2_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+ return __ret;
+}
#else
-#define vqrshrun_n_s64(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- int64x2_t __s0 = __p0; \
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__rev0, __p1, 18); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_vqrshrun_n_s64(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__s0, __p1, 18); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x1_t vpadal_u32(uint64x1_t __p0, uint32x2_t __p1) {
+ uint64x1_t __ret;
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x1_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__rev1, 19);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrshrun_n_s16(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__s0, __p1, 16); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vpadal_u16(uint32x2_t __p0, uint16x4_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ return __ret;
+}
#else
-#define vqrshrun_n_s16(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__rev0, __p1, 16); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vqrshrun_n_s16(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__s0, __p1, 16); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vpadal_u16(uint32x2_t __p0, uint16x4_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vpadal_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vqshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+__ai __attribute__((target("neon"))) int16x4_t vpadal_s8(int16x4_t __p0, int8x8_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
return __ret;
}
#else
-__ai uint8x16_t vqshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16x4_t vpadal_s8(int16x4_t __p0, int8x8_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vpadal_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vqshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+__ai __attribute__((target("neon"))) int64x1_t vpadal_s32(int64x1_t __p0, int32x2_t __p1) {
+ int64x1_t __ret;
+ __ret = (int64x1_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
return __ret;
}
#else
-__ai uint32x4_t vqshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+__ai __attribute__((target("neon"))) int64x1_t vpadal_s32(int64x1_t __p0, int32x2_t __p1) {
+ int64x1_t __ret;
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int64x1_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__rev1, 3);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vpadal_s16(int32x2_t __p0, int16x4_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vpadal_s16(int32x2_t __p0, int16x4_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vpadal_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vpadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vpadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vpadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vpadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vpadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vpadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vqshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+__ai __attribute__((target("neon"))) int8x8_t vpadd_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
return __ret;
}
#else
-__ai uint64x2_t vqshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+__ai __attribute__((target("neon"))) int8x8_t vpadd_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vpadd_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vpadd_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vpadd_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vpadd_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vqshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vpadd_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vpadd_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vpaddlq_u8(uint8x16_t __p0) {
uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ __ret = (uint16x8_t) __builtin_neon_vpaddlq_v((int8x16_t)__p0, 49);
return __ret;
}
#else
-__ai uint16x8_t vqshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vpaddlq_u8(uint8x16_t __p0) {
uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vpaddlq_v((int8x16_t)__rev0, 49);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vqshlq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+__ai __attribute__((target("neon"))) uint64x2_t vpaddlq_u32(uint32x4_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vpaddlq_v((int8x16_t)__p0, 51);
return __ret;
}
#else
-__ai int8x16_t vqshlq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint64x2_t vpaddlq_u32(uint32x4_t __p0) {
+ uint64x2_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vpaddlq_v((int8x16_t)__rev0, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqshlq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+__ai __attribute__((target("neon"))) uint32x4_t vpaddlq_u16(uint16x8_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vpaddlq_v((int8x16_t)__p0, 50);
return __ret;
}
#else
-__ai int32x4_t vqshlq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+__ai __attribute__((target("neon"))) uint32x4_t vpaddlq_u16(uint16x8_t __p0) {
+ uint32x4_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vpaddlq_v((int8x16_t)__rev0, 50);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vqshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vpaddlq_s8(int8x16_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vpaddlq_v((int8x16_t)__p0, 33);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vpaddlq_s8(int8x16_t __p0) {
+ int16x8_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vpaddlq_v((int8x16_t)__rev0, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vpaddlq_s32(int32x4_t __p0) {
int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+ __ret = (int64x2_t) __builtin_neon_vpaddlq_v((int8x16_t)__p0, 35);
return __ret;
}
#else
-__ai int64x2_t vqshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vpaddlq_s32(int32x4_t __p0) {
int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vpaddlq_v((int8x16_t)__rev0, 35);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vqshlq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+__ai __attribute__((target("neon"))) int32x4_t vpaddlq_s16(int16x8_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vpaddlq_v((int8x16_t)__p0, 34);
return __ret;
}
#else
-__ai int16x8_t vqshlq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
+__ai __attribute__((target("neon"))) int32x4_t vpaddlq_s16(int16x8_t __p0) {
+ int32x4_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vpaddlq_v((int8x16_t)__rev0, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vpaddl_u8(uint8x8_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vpaddl_v((int8x8_t)__p0, 17);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vpaddl_u8(uint8x8_t __p0) {
+ uint16x4_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vpaddl_v((int8x8_t)__rev0, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x1_t vpaddl_u32(uint32x2_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vpaddl_v((int8x8_t)__p0, 19);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x1_t vpaddl_u32(uint32x2_t __p0) {
+ uint64x1_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64x1_t) __builtin_neon_vpaddl_v((int8x8_t)__rev0, 19);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vpaddl_u16(uint16x4_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vpaddl_v((int8x8_t)__p0, 18);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vpaddl_u16(uint16x4_t __p0) {
+ uint32x2_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vpaddl_v((int8x8_t)__rev0, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vpaddl_s8(int8x8_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vpaddl_v((int8x8_t)__p0, 1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vpaddl_s8(int8x8_t __p0) {
+ int16x4_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vpaddl_v((int8x8_t)__rev0, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x1_t vpaddl_s32(int32x2_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t) __builtin_neon_vpaddl_v((int8x8_t)__p0, 3);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x1_t vpaddl_s32(int32x2_t __p0) {
+ int64x1_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int64x1_t) __builtin_neon_vpaddl_v((int8x8_t)__rev0, 3);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vpaddl_s16(int16x4_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vpaddl_v((int8x8_t)__p0, 2);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vpaddl_s16(int16x4_t __p0) {
+ int32x2_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vpaddl_v((int8x8_t)__rev0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vqshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vpmax_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ __ret = (uint8x8_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
return __ret;
}
#else
-__ai uint8x8_t vqshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vpmax_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint8x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vqshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vqshl_u32(uint32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vpmax_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ __ret = (uint32x2_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
return __ret;
}
#else
-__ai uint32x2_t vqshl_u32(uint32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vpmax_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vqshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vqshl_u64(uint64x1_t __p0, int64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vqshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vpmax_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ __ret = (uint16x4_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
return __ret;
}
#else
-__ai uint16x4_t vqshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vpmax_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vqshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vqshl_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vpmax_s8(int8x8_t __p0, int8x8_t __p1) {
int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+ __ret = (int8x8_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
return __ret;
}
#else
-__ai int8x8_t vqshl_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vpmax_s8(int8x8_t __p0, int8x8_t __p1) {
int8x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vqshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = (int8x8_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vqshl_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) float32x2_t vpmax_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vpmax_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vpmax_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+ __ret = (int32x2_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
return __ret;
}
#else
-__ai int32x2_t vqshl_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vpmax_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vqshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = (int32x2_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai int64x1_t vqshl_s64(int64x1_t __p0, int64x1_t __p1) {
- int64x1_t __ret;
- __ret = (int64x1_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vqshl_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vpmax_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ __ret = (int16x4_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
return __ret;
}
#else
-__ai int16x4_t vqshl_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vpmax_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vqshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = (int16x4_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshlq_n_u8(__p0, __p1) __extension__ ({ \
- uint8x16_t __ret; \
- uint8x16_t __s0 = __p0; \
- __ret = (uint8x16_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 48); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vpmin_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ return __ret;
+}
#else
-#define vqshlq_n_u8(__p0, __p1) __extension__ ({ \
- uint8x16_t __ret; \
- uint8x16_t __s0 = __p0; \
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x16_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 48); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vpmin_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshlq_n_u32(__p0, __p1) __extension__ ({ \
- uint32x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- __ret = (uint32x4_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 50); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vpmin_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ return __ret;
+}
#else
-#define vqshlq_n_u32(__p0, __p1) __extension__ ({ \
- uint32x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint32x4_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 50); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vpmin_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshlq_n_u64(__p0, __p1) __extension__ ({ \
- uint64x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- __ret = (uint64x2_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 51); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vpmin_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ return __ret;
+}
#else
-#define vqshlq_n_u64(__p0, __p1) __extension__ ({ \
- uint64x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint64x2_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 51); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vpmin_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshlq_n_u16(__p0, __p1) __extension__ ({ \
- uint16x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- __ret = (uint16x8_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 49); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vpmin_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+ return __ret;
+}
#else
-#define vqshlq_n_u16(__p0, __p1) __extension__ ({ \
- uint16x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint16x8_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 49); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vpmin_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshlq_n_s8(__p0, __p1) __extension__ ({ \
- int8x16_t __ret; \
- int8x16_t __s0 = __p0; \
- __ret = (int8x16_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 32); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vpmin_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+ return __ret;
+}
#else
-#define vqshlq_n_s8(__p0, __p1) __extension__ ({ \
- int8x16_t __ret; \
- int8x16_t __s0 = __p0; \
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x16_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 32); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vpmin_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshlq_n_s32(__p0, __p1) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (int32x4_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 34); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vpmin_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+ return __ret;
+}
#else
-#define vqshlq_n_s32(__p0, __p1) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 34); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vpmin_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshlq_n_s64(__p0, __p1) __extension__ ({ \
- int64x2_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (int64x2_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 35); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vpmin_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ return __ret;
+}
#else
-#define vqshlq_n_s64(__p0, __p1) __extension__ ({ \
- int64x2_t __ret; \
- int64x2_t __s0 = __p0; \
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int64x2_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 35); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vpmin_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshlq_n_s16(__p0, __p1) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (int16x8_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 33); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vqabsq_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vqabsq_v((int8x16_t)__p0, 32);
+ return __ret;
+}
#else
-#define vqshlq_n_s16(__p0, __p1) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 33); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vqabsq_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vqabsq_v((int8x16_t)__rev0, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshl_n_u8(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- uint8x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 16); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vqabsq_s32(int32x4_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vqabsq_v((int8x16_t)__p0, 34);
+ return __ret;
+}
#else
-#define vqshl_n_u8(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- uint8x8_t __s0 = __p0; \
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_vqshl_n_v((int8x8_t)__rev0, __p1, 16); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vqabsq_s32(int32x4_t __p0) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vqabsq_v((int8x16_t)__rev0, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshl_n_u32(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- uint32x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 18); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vqabsq_s16(int16x8_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vqabsq_v((int8x16_t)__p0, 33);
+ return __ret;
+}
#else
-#define vqshl_n_u32(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- uint32x2_t __s0 = __p0; \
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vqshl_n_v((int8x8_t)__rev0, __p1, 18); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vqabsq_s16(int16x8_t __p0) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vqabsq_v((int8x16_t)__rev0, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vqshl_n_u64(__p0, __p1) __extension__ ({ \
- uint64x1_t __ret; \
- uint64x1_t __s0 = __p0; \
- __ret = (uint64x1_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 19); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vqshl_n_u16(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- uint16x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 17); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vqabs_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vqabs_v((int8x8_t)__p0, 0);
+ return __ret;
+}
#else
-#define vqshl_n_u16(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- uint16x4_t __s0 = __p0; \
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vqshl_n_v((int8x8_t)__rev0, __p1, 17); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vqabs_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vqabs_v((int8x8_t)__rev0, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshl_n_s8(__p0, __p1) __extension__ ({ \
- int8x8_t __ret; \
- int8x8_t __s0 = __p0; \
- __ret = (int8x8_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vqabs_s32(int32x2_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vqabs_v((int8x8_t)__p0, 2);
+ return __ret;
+}
#else
-#define vqshl_n_s8(__p0, __p1) __extension__ ({ \
- int8x8_t __ret; \
- int8x8_t __s0 = __p0; \
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x8_t) __builtin_neon_vqshl_n_v((int8x8_t)__rev0, __p1, 0); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vqabs_s32(int32x2_t __p0) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vqabs_v((int8x8_t)__rev0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshl_n_s32(__p0, __p1) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- __ret = (int32x2_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vqabs_s16(int16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vqabs_v((int8x8_t)__p0, 1);
+ return __ret;
+}
#else
-#define vqshl_n_s32(__p0, __p1) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vqshl_n_v((int8x8_t)__rev0, __p1, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vqabs_s16(int16x4_t __p0) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vqabs_v((int8x8_t)__rev0, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vqshl_n_s64(__p0, __p1) __extension__ ({ \
- int64x1_t __ret; \
- int64x1_t __s0 = __p0; \
- __ret = (int64x1_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 3); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vqshl_n_s16(__p0, __p1) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- __ret = (int16x4_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vqaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ return __ret;
+}
#else
-#define vqshl_n_s16(__p0, __p1) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vqshl_n_v((int8x8_t)__rev0, __p1, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vqaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshluq_n_s8(__p0, __p1) __extension__ ({ \
- uint8x16_t __ret; \
- int8x16_t __s0 = __p0; \
- __ret = (uint8x16_t) __builtin_neon_vqshluq_n_v((int8x16_t)__s0, __p1, 48); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vqaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+ return __ret;
+}
#else
-#define vqshluq_n_s8(__p0, __p1) __extension__ ({ \
- uint8x16_t __ret; \
- int8x16_t __s0 = __p0; \
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x16_t) __builtin_neon_vqshluq_n_v((int8x16_t)__rev0, __p1, 48); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vqaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshluq_n_s32(__p0, __p1) __extension__ ({ \
- uint32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (uint32x4_t) __builtin_neon_vqshluq_n_v((int8x16_t)__s0, __p1, 50); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vqaddq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+ return __ret;
+}
#else
-#define vqshluq_n_s32(__p0, __p1) __extension__ ({ \
- uint32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint32x4_t) __builtin_neon_vqshluq_n_v((int8x16_t)__rev0, __p1, 50); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vqaddq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshluq_n_s64(__p0, __p1) __extension__ ({ \
- uint64x2_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (uint64x2_t) __builtin_neon_vqshluq_n_v((int8x16_t)__s0, __p1, 51); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vqaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ return __ret;
+}
#else
-#define vqshluq_n_s64(__p0, __p1) __extension__ ({ \
- uint64x2_t __ret; \
- int64x2_t __s0 = __p0; \
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint64x2_t) __builtin_neon_vqshluq_n_v((int8x16_t)__rev0, __p1, 51); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vqaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshluq_n_s16(__p0, __p1) __extension__ ({ \
- uint16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (uint16x8_t) __builtin_neon_vqshluq_n_v((int8x16_t)__s0, __p1, 49); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vqaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+ return __ret;
+}
#else
-#define vqshluq_n_s16(__p0, __p1) __extension__ ({ \
- uint16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint16x8_t) __builtin_neon_vqshluq_n_v((int8x16_t)__rev0, __p1, 49); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vqaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshlu_n_s8(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- int8x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_vqshlu_n_v((int8x8_t)__s0, __p1, 16); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vqaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+ return __ret;
+}
#else
-#define vqshlu_n_s8(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- int8x8_t __s0 = __p0; \
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_vqshlu_n_v((int8x8_t)__rev0, __p1, 16); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vqaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshlu_n_s32(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_vqshlu_n_v((int8x8_t)__s0, __p1, 18); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vqaddq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+ return __ret;
+}
#else
-#define vqshlu_n_s32(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vqshlu_n_v((int8x8_t)__rev0, __p1, 18); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vqaddq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
-#define vqshlu_n_s64(__p0, __p1) __extension__ ({ \
- uint64x1_t __ret; \
- int64x1_t __s0 = __p0; \
- __ret = (uint64x1_t) __builtin_neon_vqshlu_n_v((int8x8_t)__s0, __p1, 19); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vqshlu_n_s16(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_vqshlu_n_v((int8x8_t)__s0, __p1, 17); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vqaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ return __ret;
+}
#else
-#define vqshlu_n_s16(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vqshlu_n_v((int8x8_t)__rev0, __p1, 17); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vqaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshrn_n_u32(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 17); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vqadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ return __ret;
+}
#else
-#define vqshrn_n_u32(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vqshrn_n_v((int8x16_t)__rev0, __p1, 17); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vqshrn_n_u32(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 17); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vqadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshrn_n_u64(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 18); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vqadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ return __ret;
+}
#else
-#define vqshrn_n_u64(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vqshrn_n_v((int8x16_t)__rev0, __p1, 18); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_vqshrn_n_u64(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 18); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vqadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vqadd_u64(uint64x1_t __p0, uint64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vqshrn_n_u16(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 16); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vqadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ return __ret;
+}
#else
-#define vqshrn_n_u16(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_vqshrn_n_v((int8x16_t)__rev0, __p1, 16); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vqshrn_n_u16(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 16); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vqadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshrn_n_s32(__p0, __p1) __extension__ ({ \
- int16x4_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (int16x4_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vqadd_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+ return __ret;
+}
#else
-#define vqshrn_n_s32(__p0, __p1) __extension__ ({ \
- int16x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vqshrn_n_v((int8x16_t)__rev0, __p1, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vqshrn_n_s32(__p0, __p1) __extension__ ({ \
- int16x4_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (int16x4_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vqadd_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshrn_n_s64(__p0, __p1) __extension__ ({ \
- int32x2_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (int32x2_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vqadd_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+ return __ret;
+}
#else
-#define vqshrn_n_s64(__p0, __p1) __extension__ ({ \
- int32x2_t __ret; \
- int64x2_t __s0 = __p0; \
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vqshrn_n_v((int8x16_t)__rev0, __p1, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_vqshrn_n_s64(__p0, __p1) __extension__ ({ \
- int32x2_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (int32x2_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vqadd_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) int64x1_t vqadd_s64(int64x1_t __p0, int64x1_t __p1) {
+ int64x1_t __ret;
+ __ret = (int64x1_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vqshrn_n_s16(__p0, __p1) __extension__ ({ \
- int8x8_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (int8x8_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vqadd_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ return __ret;
+}
#else
-#define vqshrn_n_s16(__p0, __p1) __extension__ ({ \
- int8x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x8_t) __builtin_neon_vqshrn_n_v((int8x16_t)__rev0, __p1, 0); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vqshrn_n_s16(__p0, __p1) __extension__ ({ \
- int8x8_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (int8x8_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vqadd_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshrun_n_s32(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_vqshrun_n_v((int8x16_t)__s0, __p1, 17); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vqdmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vqdmlal_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 35);
+ return __ret;
+}
#else
-#define vqshrun_n_s32(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vqshrun_n_v((int8x16_t)__rev0, __p1, 17); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vqshrun_n_s32(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_vqshrun_n_v((int8x16_t)__s0, __p1, 17); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vqdmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ int32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vqdmlal_v((int8x16_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 35);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vqdmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vqdmlal_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 35);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshrun_n_s64(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_vqshrun_n_v((int8x16_t)__s0, __p1, 18); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vqdmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vqdmlal_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 34);
+ return __ret;
+}
#else
-#define vqshrun_n_s64(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- int64x2_t __s0 = __p0; \
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vqshrun_n_v((int8x16_t)__rev0, __p1, 18); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
+__ai __attribute__((target("neon"))) int32x4_t vqdmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ int16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vqdmlal_v((int8x16_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vqdmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vqdmlal_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 34);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlal_lane_s32(__p0_122, __p1_122, __p2_122, __p3_122) __extension__ ({ \
+ int64x2_t __ret_122; \
+ int64x2_t __s0_122 = __p0_122; \
+ int32x2_t __s1_122 = __p1_122; \
+ int32x2_t __s2_122 = __p2_122; \
+ __ret_122 = vqdmlal_s32(__s0_122, __s1_122, splat_lane_s32(__s2_122, __p3_122)); \
+ __ret_122; \
})
-#define __noswap_vqshrun_n_s64(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_vqshrun_n_v((int8x16_t)__s0, __p1, 18); \
- __ret; \
+#else
+#define vqdmlal_lane_s32(__p0_123, __p1_123, __p2_123, __p3_123) __extension__ ({ \
+ int64x2_t __ret_123; \
+ int64x2_t __s0_123 = __p0_123; \
+ int32x2_t __s1_123 = __p1_123; \
+ int32x2_t __s2_123 = __p2_123; \
+ int64x2_t __rev0_123; __rev0_123 = __builtin_shufflevector(__s0_123, __s0_123, 1, 0); \
+ int32x2_t __rev1_123; __rev1_123 = __builtin_shufflevector(__s1_123, __s1_123, 1, 0); \
+ int32x2_t __rev2_123; __rev2_123 = __builtin_shufflevector(__s2_123, __s2_123, 1, 0); \
+ __ret_123 = __noswap_vqdmlal_s32(__rev0_123, __rev1_123, __noswap_splat_lane_s32(__rev2_123, __p3_123)); \
+ __ret_123 = __builtin_shufflevector(__ret_123, __ret_123, 1, 0); \
+ __ret_123; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshrun_n_s16(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_vqshrun_n_v((int8x16_t)__s0, __p1, 16); \
- __ret; \
+#define vqdmlal_lane_s16(__p0_124, __p1_124, __p2_124, __p3_124) __extension__ ({ \
+ int32x4_t __ret_124; \
+ int32x4_t __s0_124 = __p0_124; \
+ int16x4_t __s1_124 = __p1_124; \
+ int16x4_t __s2_124 = __p2_124; \
+ __ret_124 = vqdmlal_s16(__s0_124, __s1_124, splat_lane_s16(__s2_124, __p3_124)); \
+ __ret_124; \
})
#else
-#define vqshrun_n_s16(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_vqshrun_n_v((int8x16_t)__rev0, __p1, 16); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vqshrun_n_s16(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_vqshrun_n_v((int8x16_t)__s0, __p1, 16); \
- __ret; \
+#define vqdmlal_lane_s16(__p0_125, __p1_125, __p2_125, __p3_125) __extension__ ({ \
+ int32x4_t __ret_125; \
+ int32x4_t __s0_125 = __p0_125; \
+ int16x4_t __s1_125 = __p1_125; \
+ int16x4_t __s2_125 = __p2_125; \
+ int32x4_t __rev0_125; __rev0_125 = __builtin_shufflevector(__s0_125, __s0_125, 3, 2, 1, 0); \
+ int16x4_t __rev1_125; __rev1_125 = __builtin_shufflevector(__s1_125, __s1_125, 3, 2, 1, 0); \
+ int16x4_t __rev2_125; __rev2_125 = __builtin_shufflevector(__s2_125, __s2_125, 3, 2, 1, 0); \
+ __ret_125 = __noswap_vqdmlal_s16(__rev0_125, __rev1_125, __noswap_splat_lane_s16(__rev2_125, __p3_125)); \
+ __ret_125 = __builtin_shufflevector(__ret_125, __ret_125, 3, 2, 1, 0); \
+ __ret_125; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vqsubq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+__ai __attribute__((target("neon"))) int64x2_t vqdmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+ int64x2_t __ret;
+ __ret = vqdmlal_s32(__p0, __p1, (int32x2_t) {__p2, __p2});
return __ret;
}
#else
-__ai uint8x16_t vqsubq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int64x2_t vqdmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __noswap_vqdmlal_s32(__rev0, __rev1, (int32x2_t) {__p2, __p2});
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vqdmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+ int64x2_t __ret;
+ __ret = __noswap_vqdmlal_s32(__p0, __p1, (int32x2_t) {__p2, __p2});
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vqsubq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+__ai __attribute__((target("neon"))) int32x4_t vqdmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+ int32x4_t __ret;
+ __ret = vqdmlal_s16(__p0, __p1, (int16x4_t) {__p2, __p2, __p2, __p2});
return __ret;
}
#else
-__ai uint32x4_t vqsubq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+__ai __attribute__((target("neon"))) int32x4_t vqdmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __noswap_vqdmlal_s16(__rev0, __rev1, (int16x4_t) {__p2, __p2, __p2, __p2});
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vqdmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+ int32x4_t __ret;
+ __ret = __noswap_vqdmlal_s16(__p0, __p1, (int16x4_t) {__p2, __p2, __p2, __p2});
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vqsubq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+__ai __attribute__((target("neon"))) int64x2_t vqdmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vqdmlsl_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 35);
return __ret;
}
#else
-__ai uint64x2_t vqsubq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+__ai __attribute__((target("neon"))) int64x2_t vqdmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ int32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vqdmlsl_v((int8x16_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 35);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vqdmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vqdmlsl_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 35);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vqsubq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+__ai __attribute__((target("neon"))) int32x4_t vqdmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vqdmlsl_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 34);
return __ret;
}
#else
-__ai uint16x8_t vqsubq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x4_t vqdmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ int16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vqdmlsl_v((int8x16_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vqdmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vqdmlsl_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 34);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vqsubq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+#define vqdmlsl_lane_s32(__p0_126, __p1_126, __p2_126, __p3_126) __extension__ ({ \
+ int64x2_t __ret_126; \
+ int64x2_t __s0_126 = __p0_126; \
+ int32x2_t __s1_126 = __p1_126; \
+ int32x2_t __s2_126 = __p2_126; \
+ __ret_126 = vqdmlsl_s32(__s0_126, __s1_126, splat_lane_s32(__s2_126, __p3_126)); \
+ __ret_126; \
+})
+#else
+#define vqdmlsl_lane_s32(__p0_127, __p1_127, __p2_127, __p3_127) __extension__ ({ \
+ int64x2_t __ret_127; \
+ int64x2_t __s0_127 = __p0_127; \
+ int32x2_t __s1_127 = __p1_127; \
+ int32x2_t __s2_127 = __p2_127; \
+ int64x2_t __rev0_127; __rev0_127 = __builtin_shufflevector(__s0_127, __s0_127, 1, 0); \
+ int32x2_t __rev1_127; __rev1_127 = __builtin_shufflevector(__s1_127, __s1_127, 1, 0); \
+ int32x2_t __rev2_127; __rev2_127 = __builtin_shufflevector(__s2_127, __s2_127, 1, 0); \
+ __ret_127 = __noswap_vqdmlsl_s32(__rev0_127, __rev1_127, __noswap_splat_lane_s32(__rev2_127, __p3_127)); \
+ __ret_127 = __builtin_shufflevector(__ret_127, __ret_127, 1, 0); \
+ __ret_127; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlsl_lane_s16(__p0_128, __p1_128, __p2_128, __p3_128) __extension__ ({ \
+ int32x4_t __ret_128; \
+ int32x4_t __s0_128 = __p0_128; \
+ int16x4_t __s1_128 = __p1_128; \
+ int16x4_t __s2_128 = __p2_128; \
+ __ret_128 = vqdmlsl_s16(__s0_128, __s1_128, splat_lane_s16(__s2_128, __p3_128)); \
+ __ret_128; \
+})
+#else
+#define vqdmlsl_lane_s16(__p0_129, __p1_129, __p2_129, __p3_129) __extension__ ({ \
+ int32x4_t __ret_129; \
+ int32x4_t __s0_129 = __p0_129; \
+ int16x4_t __s1_129 = __p1_129; \
+ int16x4_t __s2_129 = __p2_129; \
+ int32x4_t __rev0_129; __rev0_129 = __builtin_shufflevector(__s0_129, __s0_129, 3, 2, 1, 0); \
+ int16x4_t __rev1_129; __rev1_129 = __builtin_shufflevector(__s1_129, __s1_129, 3, 2, 1, 0); \
+ int16x4_t __rev2_129; __rev2_129 = __builtin_shufflevector(__s2_129, __s2_129, 3, 2, 1, 0); \
+ __ret_129 = __noswap_vqdmlsl_s16(__rev0_129, __rev1_129, __noswap_splat_lane_s16(__rev2_129, __p3_129)); \
+ __ret_129 = __builtin_shufflevector(__ret_129, __ret_129, 3, 2, 1, 0); \
+ __ret_129; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqdmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+ int64x2_t __ret;
+ __ret = vqdmlsl_s32(__p0, __p1, (int32x2_t) {__p2, __p2});
return __ret;
}
#else
-__ai int8x16_t vqsubq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int64x2_t vqdmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __noswap_vqdmlsl_s32(__rev0, __rev1, (int32x2_t) {__p2, __p2});
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vqdmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+ int64x2_t __ret;
+ __ret = __noswap_vqdmlsl_s32(__p0, __p1, (int32x2_t) {__p2, __p2});
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqsubq_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vqdmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+ __ret = vqdmlsl_s16(__p0, __p1, (int16x4_t) {__p2, __p2, __p2, __p2});
return __ret;
}
#else
-__ai int32x4_t vqsubq_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vqdmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __noswap_vqdmlsl_s16(__rev0, __rev1, (int16x4_t) {__p2, __p2, __p2, __p2});
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vqdmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+ int32x4_t __ret;
+ __ret = __noswap_vqdmlsl_s16(__p0, __p1, (int16x4_t) {__p2, __p2, __p2, __p2});
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vqsubq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+__ai __attribute__((target("neon"))) int32x4_t vqdmulhq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vqdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
return __ret;
}
#else
-__ai int64x2_t vqsubq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int32x4_t vqdmulhq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vqdmulhq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vqdmulhq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vqdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vqsubq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vqdmulhq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ __ret = (int16x8_t) __builtin_neon_vqdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
return __ret;
}
#else
-__ai int16x8_t vqsubq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vqdmulhq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = (int16x8_t) __builtin_neon_vqdmulhq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vqdmulhq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vqdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vqsub_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+__ai __attribute__((target("neon"))) int32x2_t vqdmulh_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vqdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
return __ret;
}
#else
-__ai uint8x8_t vqsub_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vqsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x2_t vqdmulh_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vqdmulh_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vqdmulh_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vqdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vqsub_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+__ai __attribute__((target("neon"))) int16x4_t vqdmulh_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vqdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
return __ret;
}
#else
-__ai uint32x2_t vqsub_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vqsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int16x4_t vqdmulh_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vqdmulh_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-#endif
-
-__ai uint64x1_t vqsub_u64(uint64x1_t __p0, uint64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vqdmulh_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vqdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
return __ret;
}
+#endif
+
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vqsub_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+__ai __attribute__((target("neon"))) int32x4_t vqdmulhq_n_s32(int32x4_t __p0, int32_t __p1) {
+ int32x4_t __ret;
+ __ret = vqdmulhq_s32(__p0, (int32x4_t) {__p1, __p1, __p1, __p1});
return __ret;
}
#else
-__ai uint16x4_t vqsub_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vqsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+__ai __attribute__((target("neon"))) int32x4_t vqdmulhq_n_s32(int32x4_t __p0, int32_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __noswap_vqdmulhq_s32(__rev0, (int32x4_t) {__p1, __p1, __p1, __p1});
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vqsub_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+__ai __attribute__((target("neon"))) int16x8_t vqdmulhq_n_s16(int16x8_t __p0, int16_t __p1) {
+ int16x8_t __ret;
+ __ret = vqdmulhq_s16(__p0, (int16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1});
return __ret;
}
#else
-__ai int8x8_t vqsub_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vqsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+__ai __attribute__((target("neon"))) int16x8_t vqdmulhq_n_s16(int16x8_t __p0, int16_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vqdmulhq_s16(__rev0, (int16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1});
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vqsub_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vqdmulh_n_s32(int32x2_t __p0, int32_t __p1) {
int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+ __ret = vqdmulh_s32(__p0, (int32x2_t) {__p1, __p1});
return __ret;
}
#else
-__ai int32x2_t vqsub_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vqdmulh_n_s32(int32x2_t __p0, int32_t __p1) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vqsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = __noswap_vqdmulh_s32(__rev0, (int32x2_t) {__p1, __p1});
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai int64x1_t vqsub_s64(int64x1_t __p0, int64x1_t __p1) {
- int64x1_t __ret;
- __ret = (int64x1_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vqsub_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vqdmulh_n_s16(int16x4_t __p0, int16_t __p1) {
int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ __ret = vqdmulh_s16(__p0, (int16x4_t) {__p1, __p1, __p1, __p1});
return __ret;
}
#else
-__ai int16x4_t vqsub_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vqdmulh_n_s16(int16x4_t __p0, int16_t __p1) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vqsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = __noswap_vqdmulh_s16(__rev0, (int16x4_t) {__p1, __p1, __p1, __p1});
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vraddhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
+__ai __attribute__((target("neon"))) int64x2_t vqdmull_s32(int32x2_t __p0, int32x2_t __p1) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vqdmull_v((int8x8_t)__p0, (int8x8_t)__p1, 35);
return __ret;
}
#else
-__ai uint16x4_t vraddhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint16x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vraddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int64x2_t vqdmull_s32(int32x2_t __p0, int32x2_t __p1) {
+ int64x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vqdmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 35);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai uint16x4_t __noswap_vraddhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vqdmull_s32(int32x2_t __p0, int32x2_t __p1) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vqdmull_v((int8x8_t)__p0, (int8x8_t)__p1, 35);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vraddhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
+__ai __attribute__((target("neon"))) int32x4_t vqdmull_s16(int16x4_t __p0, int16x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vqdmull_v((int8x8_t)__p0, (int8x8_t)__p1, 34);
return __ret;
}
#else
-__ai uint32x2_t vraddhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint32x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vraddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int32x4_t vqdmull_s16(int16x4_t __p0, int16x4_t __p1) {
+ int32x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vqdmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai uint32x2_t __noswap_vraddhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vqdmull_s16(int16x4_t __p0, int16x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vqdmull_v((int8x8_t)__p0, (int8x8_t)__p1, 34);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vraddhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
+#define vqdmull_lane_s32(__p0_130, __p1_130, __p2_130) __extension__ ({ \
+ int64x2_t __ret_130; \
+ int32x2_t __s0_130 = __p0_130; \
+ int32x2_t __s1_130 = __p1_130; \
+ __ret_130 = vqdmull_s32(__s0_130, splat_lane_s32(__s1_130, __p2_130)); \
+ __ret_130; \
+})
+#else
+#define vqdmull_lane_s32(__p0_131, __p1_131, __p2_131) __extension__ ({ \
+ int64x2_t __ret_131; \
+ int32x2_t __s0_131 = __p0_131; \
+ int32x2_t __s1_131 = __p1_131; \
+ int32x2_t __rev0_131; __rev0_131 = __builtin_shufflevector(__s0_131, __s0_131, 1, 0); \
+ int32x2_t __rev1_131; __rev1_131 = __builtin_shufflevector(__s1_131, __s1_131, 1, 0); \
+ __ret_131 = __noswap_vqdmull_s32(__rev0_131, __noswap_splat_lane_s32(__rev1_131, __p2_131)); \
+ __ret_131 = __builtin_shufflevector(__ret_131, __ret_131, 1, 0); \
+ __ret_131; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmull_lane_s16(__p0_132, __p1_132, __p2_132) __extension__ ({ \
+ int32x4_t __ret_132; \
+ int16x4_t __s0_132 = __p0_132; \
+ int16x4_t __s1_132 = __p1_132; \
+ __ret_132 = vqdmull_s16(__s0_132, splat_lane_s16(__s1_132, __p2_132)); \
+ __ret_132; \
+})
+#else
+#define vqdmull_lane_s16(__p0_133, __p1_133, __p2_133) __extension__ ({ \
+ int32x4_t __ret_133; \
+ int16x4_t __s0_133 = __p0_133; \
+ int16x4_t __s1_133 = __p1_133; \
+ int16x4_t __rev0_133; __rev0_133 = __builtin_shufflevector(__s0_133, __s0_133, 3, 2, 1, 0); \
+ int16x4_t __rev1_133; __rev1_133 = __builtin_shufflevector(__s1_133, __s1_133, 3, 2, 1, 0); \
+ __ret_133 = __noswap_vqdmull_s16(__rev0_133, __noswap_splat_lane_s16(__rev1_133, __p2_133)); \
+ __ret_133 = __builtin_shufflevector(__ret_133, __ret_133, 3, 2, 1, 0); \
+ __ret_133; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqdmull_n_s32(int32x2_t __p0, int32_t __p1) {
+ int64x2_t __ret;
+ __ret = vqdmull_s32(__p0, (int32x2_t) {__p1, __p1});
return __ret;
}
#else
-__ai uint8x8_t vraddhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint8x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vraddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int64x2_t vqdmull_n_s32(int32x2_t __p0, int32_t __p1) {
+ int64x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = __noswap_vqdmull_s32(__rev0, (int32x2_t) {__p1, __p1});
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai uint8x8_t __noswap_vraddhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vqdmull_n_s32(int32x2_t __p0, int32_t __p1) {
+ int64x2_t __ret;
+ __ret = __noswap_vqdmull_s32(__p0, (int32x2_t) {__p1, __p1});
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vraddhn_s32(int32x4_t __p0, int32x4_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
+__ai __attribute__((target("neon"))) int32x4_t vqdmull_n_s16(int16x4_t __p0, int16_t __p1) {
+ int32x4_t __ret;
+ __ret = vqdmull_s16(__p0, (int16x4_t) {__p1, __p1, __p1, __p1});
return __ret;
}
#else
-__ai int16x4_t vraddhn_s32(int32x4_t __p0, int32x4_t __p1) {
- int16x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vraddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 1);
+__ai __attribute__((target("neon"))) int32x4_t vqdmull_n_s16(int16x4_t __p0, int16_t __p1) {
+ int32x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __noswap_vqdmull_s16(__rev0, (int16x4_t) {__p1, __p1, __p1, __p1});
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int16x4_t __noswap_vraddhn_s32(int32x4_t __p0, int32x4_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vqdmull_n_s16(int16x4_t __p0, int16_t __p1) {
+ int32x4_t __ret;
+ __ret = __noswap_vqdmull_s16(__p0, (int16x4_t) {__p1, __p1, __p1, __p1});
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vraddhn_s64(int64x2_t __p0, int64x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
+__ai __attribute__((target("neon"))) uint16x4_t vqmovn_u32(uint32x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 17);
return __ret;
}
#else
-__ai int32x2_t vraddhn_s64(int64x2_t __p0, int64x2_t __p1) {
- int32x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vraddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint16x4_t vqmovn_u32(uint32x4_t __p0) {
+ uint16x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vqmovn_v((int8x16_t)__rev0, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int32x2_t __noswap_vraddhn_s64(int64x2_t __p0, int64x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
+__ai __attribute__((target("neon"))) uint16x4_t __noswap_vqmovn_u32(uint32x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 17);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vraddhn_s16(int16x8_t __p0, int16x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
+__ai __attribute__((target("neon"))) uint32x2_t vqmovn_u64(uint64x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 18);
return __ret;
}
#else
-__ai int8x8_t vraddhn_s16(int16x8_t __p0, int16x8_t __p1) {
- int8x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vraddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x2_t vqmovn_u64(uint64x2_t __p0) {
+ uint32x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vqmovn_v((int8x16_t)__rev0, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai int8x8_t __noswap_vraddhn_s16(int16x8_t __p0, int16x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
+__ai __attribute__((target("neon"))) uint32x2_t __noswap_vqmovn_u64(uint64x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 18);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vrecpeq_u32(uint32x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vrecpeq_v((int8x16_t)__p0, 50);
+__ai __attribute__((target("neon"))) uint8x8_t vqmovn_u16(uint16x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 16);
return __ret;
}
#else
-__ai uint32x4_t vrecpeq_u32(uint32x4_t __p0) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vrecpeq_v((int8x16_t)__rev0, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x8_t vqmovn_u16(uint16x8_t __p0) {
+ uint8x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vqmovn_v((int8x16_t)__rev0, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t __noswap_vqmovn_u16(uint16x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 16);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vrecpeq_f32(float32x4_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vrecpeq_v((int8x16_t)__p0, 41);
+__ai __attribute__((target("neon"))) int16x4_t vqmovn_s32(int32x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 1);
return __ret;
}
#else
-__ai float32x4_t vrecpeq_f32(float32x4_t __p0) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vrecpeq_v((int8x16_t)__rev0, 41);
+__ai __attribute__((target("neon"))) int16x4_t vqmovn_s32(int32x4_t __p0) {
+ int16x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vqmovn_v((int8x16_t)__rev0, 1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vrecpe_u32(uint32x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vrecpe_v((int8x8_t)__p0, 18);
- return __ret;
-}
-#else
-__ai uint32x2_t vrecpe_u32(uint32x2_t __p0) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vrecpe_v((int8x8_t)__rev0, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vqmovn_s32(int32x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 1);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vrecpe_f32(float32x2_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vrecpe_v((int8x8_t)__p0, 9);
+__ai __attribute__((target("neon"))) int32x2_t vqmovn_s64(int64x2_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 2);
return __ret;
}
#else
-__ai float32x2_t vrecpe_f32(float32x2_t __p0) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vrecpe_v((int8x8_t)__rev0, 9);
+__ai __attribute__((target("neon"))) int32x2_t vqmovn_s64(int64x2_t __p0) {
+ int32x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vqmovn_v((int8x16_t)__rev0, 2);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vrecpsq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vrecpsq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
- return __ret;
-}
-#else
-__ai float32x4_t vrecpsq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vrecpsq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vqmovn_s64(int64x2_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 2);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vrecps_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vrecps_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+__ai __attribute__((target("neon"))) int8x8_t vqmovn_s16(int16x8_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 0);
return __ret;
}
#else
-__ai float32x2_t vrecps_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vrecps_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vrev16_p8(poly8x8_t __p0) {
- poly8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6);
+__ai __attribute__((target("neon"))) int8x8_t vqmovn_s16(int16x8_t __p0) {
+ int8x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vqmovn_v((int8x16_t)__rev0, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-#else
-__ai poly8x8_t vrev16_p8(poly8x8_t __p0) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int8x8_t __noswap_vqmovn_s16(int16x8_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vrev16q_p8(poly8x16_t __p0) {
- poly8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+__ai __attribute__((target("neon"))) uint16x4_t vqmovun_s32(int32x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vqmovun_v((int8x16_t)__p0, 17);
return __ret;
}
#else
-__ai poly8x16_t vrev16q_p8(poly8x16_t __p0) {
- poly8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vrev16q_u8(uint8x16_t __p0) {
- uint8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+__ai __attribute__((target("neon"))) uint16x4_t vqmovun_s32(int32x4_t __p0) {
+ uint16x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vqmovun_v((int8x16_t)__rev0, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-#else
-__ai uint8x16_t vrev16q_u8(uint8x16_t __p0) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint16x4_t __noswap_vqmovun_s32(int32x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vqmovun_v((int8x16_t)__p0, 17);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vrev16q_s8(int8x16_t __p0) {
- int8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+__ai __attribute__((target("neon"))) uint32x2_t vqmovun_s64(int64x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vqmovun_v((int8x16_t)__p0, 18);
return __ret;
}
#else
-__ai int8x16_t vrev16q_s8(int8x16_t __p0) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x2_t vqmovun_s64(int64x2_t __p0) {
+ uint32x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vqmovun_v((int8x16_t)__rev0, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t __noswap_vqmovun_s64(int64x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vqmovun_v((int8x16_t)__p0, 18);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vrev16_u8(uint8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vqmovun_s16(int16x8_t __p0) {
uint8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6);
+ __ret = (uint8x8_t) __builtin_neon_vqmovun_v((int8x16_t)__p0, 16);
return __ret;
}
#else
-__ai uint8x8_t vrev16_u8(uint8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vqmovun_s16(int16x8_t __p0) {
uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6);
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vqmovun_v((int8x16_t)__rev0, 16);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vrev16_s8(int8x8_t __p0) {
- int8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6);
- return __ret;
-}
-#else
-__ai int8x8_t vrev16_s8(int8x8_t __p0) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x8_t __noswap_vqmovun_s16(int16x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vqmovun_v((int8x16_t)__p0, 16);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vrev32_p8(poly8x8_t __p0) {
- poly8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
+__ai __attribute__((target("neon"))) int8x16_t vqnegq_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vqnegq_v((int8x16_t)__p0, 32);
return __ret;
}
#else
-__ai poly8x8_t vrev32_p8(poly8x8_t __p0) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int8x16_t vqnegq_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vqnegq_v((int8x16_t)__rev0, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x4_t vrev32_p16(poly16x4_t __p0) {
- poly16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2);
+__ai __attribute__((target("neon"))) int32x4_t vqnegq_s32(int32x4_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vqnegq_v((int8x16_t)__p0, 34);
return __ret;
}
#else
-__ai poly16x4_t vrev32_p16(poly16x4_t __p0) {
- poly16x4_t __ret;
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2);
+__ai __attribute__((target("neon"))) int32x4_t vqnegq_s32(int32x4_t __p0) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vqnegq_v((int8x16_t)__rev0, 34);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vrev32q_p8(poly8x16_t __p0) {
- poly8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
+__ai __attribute__((target("neon"))) int16x8_t vqnegq_s16(int16x8_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vqnegq_v((int8x16_t)__p0, 33);
return __ret;
}
#else
-__ai poly8x16_t vrev32q_p8(poly8x16_t __p0) {
- poly8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16x8_t vqnegq_s16(int16x8_t __p0) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vqnegq_v((int8x16_t)__rev0, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x8_t vrev32q_p16(poly16x8_t __p0) {
- poly16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6);
+__ai __attribute__((target("neon"))) int8x8_t vqneg_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vqneg_v((int8x8_t)__p0, 0);
return __ret;
}
#else
-__ai poly16x8_t vrev32q_p16(poly16x8_t __p0) {
- poly16x8_t __ret;
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6);
+__ai __attribute__((target("neon"))) int8x8_t vqneg_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vqneg_v((int8x8_t)__rev0, 0);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vrev32q_u8(uint8x16_t __p0) {
- uint8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
+__ai __attribute__((target("neon"))) int32x2_t vqneg_s32(int32x2_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vqneg_v((int8x8_t)__p0, 2);
return __ret;
}
#else
-__ai uint8x16_t vrev32q_u8(uint8x16_t __p0) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x2_t vqneg_s32(int32x2_t __p0) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vqneg_v((int8x8_t)__rev0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vrev32q_u16(uint16x8_t __p0) {
- uint16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6);
+__ai __attribute__((target("neon"))) int16x4_t vqneg_s16(int16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vqneg_v((int8x8_t)__p0, 1);
return __ret;
}
#else
-__ai uint16x8_t vrev32q_u16(uint16x8_t __p0) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16x4_t vqneg_s16(int16x4_t __p0) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vqneg_v((int8x8_t)__rev0, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vrev32q_s8(int8x16_t __p0) {
- int8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
+__ai __attribute__((target("neon"))) int32x4_t vqrdmulhq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vqrdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
return __ret;
}
#else
-__ai int8x16_t vrev32q_s8(int8x16_t __p0) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x4_t vqrdmulhq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vqrdmulhq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vqrdmulhq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vqrdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vrev32q_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vqrdmulhq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6);
+ __ret = (int16x8_t) __builtin_neon_vqrdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
return __ret;
}
#else
-__ai int16x8_t vrev32q_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vqrdmulhq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vqrdmulhq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vrev32_u8(uint8x8_t __p0) {
- uint8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
- return __ret;
-}
-#else
-__ai uint8x8_t vrev32_u8(uint8x8_t __p0) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vqrdmulhq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vqrdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vrev32_u16(uint16x4_t __p0) {
- uint16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2);
+__ai __attribute__((target("neon"))) int32x2_t vqrdmulh_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vqrdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
return __ret;
}
#else
-__ai uint16x4_t vrev32_u16(uint16x4_t __p0) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vrev32_s8(int8x8_t __p0) {
- int8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
+__ai __attribute__((target("neon"))) int32x2_t vqrdmulh_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vqrdmulh_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-#else
-__ai int8x8_t vrev32_s8(int8x8_t __p0) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vqrdmulh_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vqrdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vrev32_s16(int16x4_t __p0) {
+__ai __attribute__((target("neon"))) int16x4_t vqrdmulh_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2);
+ __ret = (int16x4_t) __builtin_neon_vqrdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
return __ret;
}
#else
-__ai int16x4_t vrev32_s16(int16x4_t __p0) {
+__ai __attribute__((target("neon"))) int16x4_t vqrdmulh_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vqrdmulh_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vqrdmulh_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vqrdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vrev64_p8(poly8x8_t __p0) {
- poly8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x4_t vqrdmulhq_n_s32(int32x4_t __p0, int32_t __p1) {
+ int32x4_t __ret;
+ __ret = vqrdmulhq_s32(__p0, (int32x4_t) {__p1, __p1, __p1, __p1});
return __ret;
}
#else
-__ai poly8x8_t vrev64_p8(poly8x8_t __p0) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x4_t vqrdmulhq_n_s32(int32x4_t __p0, int32_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __noswap_vqrdmulhq_s32(__rev0, (int32x4_t) {__p1, __p1, __p1, __p1});
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x4_t vrev64_p16(poly16x4_t __p0) {
- poly16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16x8_t vqrdmulhq_n_s16(int16x8_t __p0, int16_t __p1) {
+ int16x8_t __ret;
+ __ret = vqrdmulhq_s16(__p0, (int16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1});
return __ret;
}
#else
-__ai poly16x4_t vrev64_p16(poly16x4_t __p0) {
- poly16x4_t __ret;
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16x8_t vqrdmulhq_n_s16(int16x8_t __p0, int16_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vqrdmulhq_s16(__rev0, (int16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1});
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vrev64q_p8(poly8x16_t __p0) {
- poly8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
+__ai __attribute__((target("neon"))) int32x2_t vqrdmulh_n_s32(int32x2_t __p0, int32_t __p1) {
+ int32x2_t __ret;
+ __ret = vqrdmulh_s32(__p0, (int32x2_t) {__p1, __p1});
return __ret;
}
#else
-__ai poly8x16_t vrev64q_p8(poly8x16_t __p0) {
- poly8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x2_t vqrdmulh_n_s32(int32x2_t __p0, int32_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = __noswap_vqrdmulh_s32(__rev0, (int32x2_t) {__p1, __p1});
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x8_t vrev64q_p16(poly16x8_t __p0) {
- poly16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
+__ai __attribute__((target("neon"))) int16x4_t vqrdmulh_n_s16(int16x4_t __p0, int16_t __p1) {
+ int16x4_t __ret;
+ __ret = vqrdmulh_s16(__p0, (int16x4_t) {__p1, __p1, __p1, __p1});
return __ret;
}
#else
-__ai poly16x8_t vrev64q_p16(poly16x8_t __p0) {
- poly16x8_t __ret;
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16x4_t vqrdmulh_n_s16(int16x4_t __p0, int16_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __noswap_vqrdmulh_s16(__rev0, (int16x4_t) {__p1, __p1, __p1, __p1});
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vrev64q_u8(uint8x16_t __p0) {
+__ai __attribute__((target("neon"))) uint8x16_t vqrshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
uint8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
+ __ret = (uint8x16_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
return __ret;
}
#else
-__ai uint8x16_t vrev64q_u8(uint8x16_t __p0) {
+__ai __attribute__((target("neon"))) uint8x16_t vqrshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
uint8x16_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vrev64q_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vqrshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
uint32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2);
+ __ret = (uint32x4_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
return __ret;
}
#else
-__ai uint32x4_t vrev64q_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vqrshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vrev64q_u16(uint16x8_t __p0) {
+__ai __attribute__((target("neon"))) uint64x2_t vqrshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vqrshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vqrshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
uint16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
+ __ret = (uint16x8_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
return __ret;
}
#else
-__ai uint16x8_t vrev64q_u16(uint16x8_t __p0) {
+__ai __attribute__((target("neon"))) uint16x8_t vqrshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vrev64q_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vqrshlq_s8(int8x16_t __p0, int8x16_t __p1) {
int8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
+ __ret = (int8x16_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
return __ret;
}
#else
-__ai int8x16_t vrev64q_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vqrshlq_s8(int8x16_t __p0, int8x16_t __p1) {
int8x16_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vrev64q_f32(float32x4_t __p0) {
- float32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2);
+__ai __attribute__((target("neon"))) int32x4_t vqrshlq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
return __ret;
}
#else
-__ai float32x4_t vrev64q_f32(float32x4_t __p0) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2);
+__ai __attribute__((target("neon"))) int32x4_t vqrshlq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vrev64q_s32(int32x4_t __p0) {
- int32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2);
+__ai __attribute__((target("neon"))) int64x2_t vqrshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
return __ret;
}
#else
-__ai int32x4_t vrev64q_s32(int32x4_t __p0) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int64x2_t vqrshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vrev64q_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vqrshlq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
+ __ret = (int16x8_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
return __ret;
}
#else
-__ai int16x8_t vrev64q_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vqrshlq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vrev64_u8(uint8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vqrshl_u8(uint8x8_t __p0, int8x8_t __p1) {
uint8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
return __ret;
}
#else
-__ai uint8x8_t vrev64_u8(uint8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vqrshl_u8(uint8x8_t __p0, int8x8_t __p1) {
uint8x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vqrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vrev64_u32(uint32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vqrshl_u32(uint32x2_t __p0, int32x2_t __p1) {
uint32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
return __ret;
}
#else
-__ai uint32x2_t vrev64_u32(uint32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vqrshl_u32(uint32x2_t __p0, int32x2_t __p1) {
uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vqrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vqrshl_u64(uint64x1_t __p0, int64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vrev64_u16(uint16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vqrshl_u16(uint16x4_t __p0, int16x4_t __p1) {
uint16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
return __ret;
}
#else
-__ai uint16x4_t vrev64_u16(uint16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vqrshl_u16(uint16x4_t __p0, int16x4_t __p1) {
uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vqrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vrev64_s8(int8x8_t __p0) {
+__ai __attribute__((target("neon"))) int8x8_t vqrshl_s8(int8x8_t __p0, int8x8_t __p1) {
int8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
return __ret;
}
#else
-__ai int8x8_t vrev64_s8(int8x8_t __p0) {
+__ai __attribute__((target("neon"))) int8x8_t vqrshl_s8(int8x8_t __p0, int8x8_t __p1) {
int8x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vqrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vrev64_f32(float32x2_t __p0) {
- float32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1, 0);
- return __ret;
-}
-#else
-__ai float32x2_t vrev64_f32(float32x2_t __p0) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vrev64_s32(int32x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vqrshl_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
return __ret;
}
#else
-__ai int32x2_t vrev64_s32(int32x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vqrshl_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vqrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
+__ai __attribute__((target("neon"))) int64x1_t vqrshl_s64(int64x1_t __p0, int64x1_t __p1) {
+ int64x1_t __ret;
+ __ret = (int64x1_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vrev64_s16(int16x4_t __p0) {
+__ai __attribute__((target("neon"))) int16x4_t vqrshl_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
return __ret;
}
#else
-__ai int16x4_t vrev64_s16(int16x4_t __p0) {
+__ai __attribute__((target("neon"))) int16x4_t vqrshl_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vqrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vrhaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vrhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
- return __ret;
-}
-#else
-__ai uint8x16_t vrhaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vrhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vrhaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vrhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
- return __ret;
-}
-#else
-__ai uint32x4_t vrhaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vrhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vrhaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vrhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
- return __ret;
-}
-#else
-__ai uint16x8_t vrhaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vrhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vrhaddq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vrhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
- return __ret;
-}
+#define vqrshrn_n_u32(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ __ret = (uint16x4_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 17); \
+ __ret; \
+})
#else
-__ai int8x16_t vrhaddq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vrhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrshrn_n_u32(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint16x4_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__rev0, __p1, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vqrshrn_n_u32(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ __ret = (uint16x4_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 17); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vrhaddq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vrhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
- return __ret;
-}
+#define vqrshrn_n_u64(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ __ret = (uint32x2_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 18); \
+ __ret; \
+})
#else
-__ai int32x4_t vrhaddq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vrhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrshrn_n_u64(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint32x2_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__rev0, __p1, 18); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_vqrshrn_n_u64(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ __ret = (uint32x2_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 18); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vrhaddq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vrhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
- return __ret;
-}
+#define vqrshrn_n_u16(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ __ret = (uint8x8_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 16); \
+ __ret; \
+})
#else
-__ai int16x8_t vrhaddq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vrhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrshrn_n_u16(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x8_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__rev0, __p1, 16); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vqrshrn_n_u16(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ __ret = (uint8x8_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 16); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vrhadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vrhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
- return __ret;
-}
+#define vqrshrn_n_s32(__p0, __p1) __extension__ ({ \
+ int16x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (int16x4_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 1); \
+ __ret; \
+})
#else
-__ai uint8x8_t vrhadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vrhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrshrn_n_s32(__p0, __p1) __extension__ ({ \
+ int16x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (int16x4_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__rev0, __p1, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vqrshrn_n_s32(__p0, __p1) __extension__ ({ \
+ int16x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (int16x4_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 1); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vrhadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vrhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
- return __ret;
-}
+#define vqrshrn_n_s64(__p0, __p1) __extension__ ({ \
+ int32x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (int32x2_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 2); \
+ __ret; \
+})
#else
-__ai uint32x2_t vrhadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vrhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vqrshrn_n_s64(__p0, __p1) __extension__ ({ \
+ int32x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (int32x2_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__rev0, __p1, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_vqrshrn_n_s64(__p0, __p1) __extension__ ({ \
+ int32x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (int32x2_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vrhadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vrhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
- return __ret;
-}
+#define vqrshrn_n_s16(__p0, __p1) __extension__ ({ \
+ int8x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (int8x8_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 0); \
+ __ret; \
+})
#else
-__ai uint16x4_t vrhadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vrhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrshrn_n_s16(__p0, __p1) __extension__ ({ \
+ int8x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__rev0, __p1, 0); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vqrshrn_n_s16(__p0, __p1) __extension__ ({ \
+ int8x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (int8x8_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vrhadd_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vrhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
- return __ret;
-}
+#define vqrshrun_n_s32(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (uint16x4_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__s0, __p1, 17); \
+ __ret; \
+})
#else
-__ai int8x8_t vrhadd_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vrhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrshrun_n_s32(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint16x4_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__rev0, __p1, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vqrshrun_n_s32(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (uint16x4_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__s0, __p1, 17); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vrhadd_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vrhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
- return __ret;
-}
+#define vqrshrun_n_s64(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (uint32x2_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__s0, __p1, 18); \
+ __ret; \
+})
#else
-__ai int32x2_t vrhadd_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vrhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vqrshrun_n_s64(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint32x2_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__rev0, __p1, 18); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_vqrshrun_n_s64(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (uint32x2_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__s0, __p1, 18); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vrhadd_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vrhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
- return __ret;
-}
+#define vqrshrun_n_s16(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (uint8x8_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__s0, __p1, 16); \
+ __ret; \
+})
#else
-__ai int16x4_t vrhadd_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vrhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrshrun_n_s16(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x8_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__rev0, __p1, 16); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vqrshrun_n_s16(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (uint8x8_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__s0, __p1, 16); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vrshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint8x16_t vqshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ __ret = (uint8x16_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
return __ret;
}
#else
-__ai uint8x16_t vrshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint8x16_t vqshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
uint8x16_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = (uint8x16_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vrshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vqshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+ __ret = (uint32x4_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
return __ret;
}
#else
-__ai uint32x4_t vrshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vqshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = (uint32x4_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vrshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vqshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+ __ret = (uint64x2_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
return __ret;
}
#else
-__ai uint64x2_t vrshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vqshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+ __ret = (uint64x2_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vrshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vqshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ __ret = (uint16x8_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
return __ret;
}
#else
-__ai uint16x8_t vrshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vqshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = (uint16x8_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vrshlq_s8(int8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) int8x16_t vqshlq_s8(int8x16_t __p0, int8x16_t __p1) {
int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+ __ret = (int8x16_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
return __ret;
}
#else
-__ai int8x16_t vrshlq_s8(int8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) int8x16_t vqshlq_s8(int8x16_t __p0, int8x16_t __p1) {
int8x16_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+ __ret = (int8x16_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vrshlq_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vqshlq_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+ __ret = (int32x4_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
return __ret;
}
#else
-__ai int32x4_t vrshlq_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vqshlq_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+ __ret = (int32x4_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vrshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vqshlq_s64(int64x2_t __p0, int64x2_t __p1) {
int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+ __ret = (int64x2_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
return __ret;
}
#else
-__ai int64x2_t vrshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vqshlq_s64(int64x2_t __p0, int64x2_t __p1) {
int64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+ __ret = (int64x2_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vrshlq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vqshlq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ __ret = (int16x8_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
return __ret;
}
#else
-__ai int16x8_t vrshlq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vqshlq_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = (int16x8_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vrshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vqshl_u8(uint8x8_t __p0, int8x8_t __p1) {
uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ __ret = (uint8x8_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
return __ret;
}
#else
-__ai uint8x8_t vrshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vqshl_u8(uint8x8_t __p0, int8x8_t __p1) {
uint8x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = (uint8x8_t) __builtin_neon_vqshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vrshl_u32(uint32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vqshl_u32(uint32x2_t __p0, int32x2_t __p1) {
uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ __ret = (uint32x2_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
return __ret;
}
#else
-__ai uint32x2_t vrshl_u32(uint32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vqshl_u32(uint32x2_t __p0, int32x2_t __p1) {
uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = (uint32x2_t) __builtin_neon_vqshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vrshl_u64(uint64x1_t __p0, int64x1_t __p1) {
+__ai __attribute__((target("neon"))) uint64x1_t vqshl_u64(uint64x1_t __p0, int64x1_t __p1) {
uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+ __ret = (uint64x1_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vrshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vqshl_u16(uint16x4_t __p0, int16x4_t __p1) {
uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ __ret = (uint16x4_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
return __ret;
}
#else
-__ai uint16x4_t vrshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vqshl_u16(uint16x4_t __p0, int16x4_t __p1) {
uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = (uint16x4_t) __builtin_neon_vqshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vrshl_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vqshl_s8(int8x8_t __p0, int8x8_t __p1) {
int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+ __ret = (int8x8_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
return __ret;
}
#else
-__ai int8x8_t vrshl_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vqshl_s8(int8x8_t __p0, int8x8_t __p1) {
int8x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = (int8x8_t) __builtin_neon_vqshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vrshl_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vqshl_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+ __ret = (int32x2_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
return __ret;
}
#else
-__ai int32x2_t vrshl_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vqshl_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = (int32x2_t) __builtin_neon_vqshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai int64x1_t vrshl_s64(int64x1_t __p0, int64x1_t __p1) {
+__ai __attribute__((target("neon"))) int64x1_t vqshl_s64(int64x1_t __p0, int64x1_t __p1) {
int64x1_t __ret;
- __ret = (int64x1_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
+ __ret = (int64x1_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vrshl_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vqshl_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ __ret = (int16x4_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
return __ret;
}
#else
-__ai int16x4_t vrshl_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vqshl_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = (int16x4_t) __builtin_neon_vqshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrshrq_n_u8(__p0, __p1) __extension__ ({ \
+#define vqshlq_n_u8(__p0, __p1) __extension__ ({ \
uint8x16_t __ret; \
uint8x16_t __s0 = __p0; \
- __ret = (uint8x16_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 48); \
+ __ret = (uint8x16_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 48); \
__ret; \
})
#else
-#define vrshrq_n_u8(__p0, __p1) __extension__ ({ \
+#define vqshlq_n_u8(__p0, __p1) __extension__ ({ \
uint8x16_t __ret; \
uint8x16_t __s0 = __p0; \
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x16_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 48); \
+ __ret = (uint8x16_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 48); \
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrshrq_n_u32(__p0, __p1) __extension__ ({ \
+#define vqshlq_n_u32(__p0, __p1) __extension__ ({ \
uint32x4_t __ret; \
uint32x4_t __s0 = __p0; \
- __ret = (uint32x4_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 50); \
+ __ret = (uint32x4_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 50); \
__ret; \
})
#else
-#define vrshrq_n_u32(__p0, __p1) __extension__ ({ \
+#define vqshlq_n_u32(__p0, __p1) __extension__ ({ \
uint32x4_t __ret; \
uint32x4_t __s0 = __p0; \
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint32x4_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 50); \
+ __ret = (uint32x4_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 50); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrshrq_n_u64(__p0, __p1) __extension__ ({ \
+#define vqshlq_n_u64(__p0, __p1) __extension__ ({ \
uint64x2_t __ret; \
uint64x2_t __s0 = __p0; \
- __ret = (uint64x2_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 51); \
+ __ret = (uint64x2_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 51); \
__ret; \
})
#else
-#define vrshrq_n_u64(__p0, __p1) __extension__ ({ \
+#define vqshlq_n_u64(__p0, __p1) __extension__ ({ \
uint64x2_t __ret; \
uint64x2_t __s0 = __p0; \
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint64x2_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 51); \
+ __ret = (uint64x2_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 51); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrshrq_n_u16(__p0, __p1) __extension__ ({ \
+#define vqshlq_n_u16(__p0, __p1) __extension__ ({ \
uint16x8_t __ret; \
uint16x8_t __s0 = __p0; \
- __ret = (uint16x8_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 49); \
+ __ret = (uint16x8_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 49); \
__ret; \
})
#else
-#define vrshrq_n_u16(__p0, __p1) __extension__ ({ \
+#define vqshlq_n_u16(__p0, __p1) __extension__ ({ \
uint16x8_t __ret; \
uint16x8_t __s0 = __p0; \
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint16x8_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 49); \
+ __ret = (uint16x8_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 49); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrshrq_n_s8(__p0, __p1) __extension__ ({ \
+#define vqshlq_n_s8(__p0, __p1) __extension__ ({ \
int8x16_t __ret; \
int8x16_t __s0 = __p0; \
- __ret = (int8x16_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 32); \
+ __ret = (int8x16_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 32); \
__ret; \
})
#else
-#define vrshrq_n_s8(__p0, __p1) __extension__ ({ \
+#define vqshlq_n_s8(__p0, __p1) __extension__ ({ \
int8x16_t __ret; \
int8x16_t __s0 = __p0; \
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x16_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 32); \
+ __ret = (int8x16_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 32); \
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrshrq_n_s32(__p0, __p1) __extension__ ({ \
+#define vqshlq_n_s32(__p0, __p1) __extension__ ({ \
int32x4_t __ret; \
int32x4_t __s0 = __p0; \
- __ret = (int32x4_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 34); \
+ __ret = (int32x4_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 34); \
__ret; \
})
#else
-#define vrshrq_n_s32(__p0, __p1) __extension__ ({ \
+#define vqshlq_n_s32(__p0, __p1) __extension__ ({ \
int32x4_t __ret; \
int32x4_t __s0 = __p0; \
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 34); \
+ __ret = (int32x4_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 34); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrshrq_n_s64(__p0, __p1) __extension__ ({ \
+#define vqshlq_n_s64(__p0, __p1) __extension__ ({ \
int64x2_t __ret; \
int64x2_t __s0 = __p0; \
- __ret = (int64x2_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 35); \
+ __ret = (int64x2_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 35); \
__ret; \
})
#else
-#define vrshrq_n_s64(__p0, __p1) __extension__ ({ \
+#define vqshlq_n_s64(__p0, __p1) __extension__ ({ \
int64x2_t __ret; \
int64x2_t __s0 = __p0; \
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int64x2_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 35); \
+ __ret = (int64x2_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 35); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrshrq_n_s16(__p0, __p1) __extension__ ({ \
+#define vqshlq_n_s16(__p0, __p1) __extension__ ({ \
int16x8_t __ret; \
int16x8_t __s0 = __p0; \
- __ret = (int16x8_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 33); \
+ __ret = (int16x8_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 33); \
__ret; \
})
#else
-#define vrshrq_n_s16(__p0, __p1) __extension__ ({ \
+#define vqshlq_n_s16(__p0, __p1) __extension__ ({ \
int16x8_t __ret; \
int16x8_t __s0 = __p0; \
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 33); \
+ __ret = (int16x8_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 33); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrshr_n_u8(__p0, __p1) __extension__ ({ \
+#define vqshl_n_u8(__p0, __p1) __extension__ ({ \
uint8x8_t __ret; \
uint8x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 16); \
+ __ret = (uint8x8_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 16); \
__ret; \
})
#else
-#define vrshr_n_u8(__p0, __p1) __extension__ ({ \
+#define vqshl_n_u8(__p0, __p1) __extension__ ({ \
uint8x8_t __ret; \
uint8x8_t __s0 = __p0; \
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_vrshr_n_v((int8x8_t)__rev0, __p1, 16); \
+ __ret = (uint8x8_t) __builtin_neon_vqshl_n_v((int8x8_t)__rev0, __p1, 16); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrshr_n_u32(__p0, __p1) __extension__ ({ \
+#define vqshl_n_u32(__p0, __p1) __extension__ ({ \
uint32x2_t __ret; \
uint32x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 18); \
+ __ret = (uint32x2_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 18); \
__ret; \
})
#else
-#define vrshr_n_u32(__p0, __p1) __extension__ ({ \
+#define vqshl_n_u32(__p0, __p1) __extension__ ({ \
uint32x2_t __ret; \
uint32x2_t __s0 = __p0; \
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vrshr_n_v((int8x8_t)__rev0, __p1, 18); \
+ __ret = (uint32x2_t) __builtin_neon_vqshl_n_v((int8x8_t)__rev0, __p1, 18); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
-#define vrshr_n_u64(__p0, __p1) __extension__ ({ \
+#define vqshl_n_u64(__p0, __p1) __extension__ ({ \
uint64x1_t __ret; \
uint64x1_t __s0 = __p0; \
- __ret = (uint64x1_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 19); \
+ __ret = (uint64x1_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 19); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vrshr_n_u16(__p0, __p1) __extension__ ({ \
+#define vqshl_n_u16(__p0, __p1) __extension__ ({ \
uint16x4_t __ret; \
uint16x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 17); \
+ __ret = (uint16x4_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 17); \
__ret; \
})
#else
-#define vrshr_n_u16(__p0, __p1) __extension__ ({ \
+#define vqshl_n_u16(__p0, __p1) __extension__ ({ \
uint16x4_t __ret; \
uint16x4_t __s0 = __p0; \
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vrshr_n_v((int8x8_t)__rev0, __p1, 17); \
+ __ret = (uint16x4_t) __builtin_neon_vqshl_n_v((int8x8_t)__rev0, __p1, 17); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrshr_n_s8(__p0, __p1) __extension__ ({ \
+#define vqshl_n_s8(__p0, __p1) __extension__ ({ \
int8x8_t __ret; \
int8x8_t __s0 = __p0; \
- __ret = (int8x8_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 0); \
__ret; \
})
#else
-#define vrshr_n_s8(__p0, __p1) __extension__ ({ \
+#define vqshl_n_s8(__p0, __p1) __extension__ ({ \
int8x8_t __ret; \
int8x8_t __s0 = __p0; \
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x8_t) __builtin_neon_vrshr_n_v((int8x8_t)__rev0, __p1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vqshl_n_v((int8x8_t)__rev0, __p1, 0); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrshr_n_s32(__p0, __p1) __extension__ ({ \
+#define vqshl_n_s32(__p0, __p1) __extension__ ({ \
int32x2_t __ret; \
int32x2_t __s0 = __p0; \
- __ret = (int32x2_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 2); \
+ __ret = (int32x2_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 2); \
__ret; \
})
#else
-#define vrshr_n_s32(__p0, __p1) __extension__ ({ \
+#define vqshl_n_s32(__p0, __p1) __extension__ ({ \
int32x2_t __ret; \
int32x2_t __s0 = __p0; \
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vrshr_n_v((int8x8_t)__rev0, __p1, 2); \
+ __ret = (int32x2_t) __builtin_neon_vqshl_n_v((int8x8_t)__rev0, __p1, 2); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
-#define vrshr_n_s64(__p0, __p1) __extension__ ({ \
+#define vqshl_n_s64(__p0, __p1) __extension__ ({ \
int64x1_t __ret; \
int64x1_t __s0 = __p0; \
- __ret = (int64x1_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 3); \
+ __ret = (int64x1_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 3); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vrshr_n_s16(__p0, __p1) __extension__ ({ \
+#define vqshl_n_s16(__p0, __p1) __extension__ ({ \
int16x4_t __ret; \
int16x4_t __s0 = __p0; \
- __ret = (int16x4_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 1); \
+ __ret = (int16x4_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 1); \
__ret; \
})
#else
-#define vrshr_n_s16(__p0, __p1) __extension__ ({ \
+#define vqshl_n_s16(__p0, __p1) __extension__ ({ \
int16x4_t __ret; \
int16x4_t __s0 = __p0; \
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vrshr_n_v((int8x8_t)__rev0, __p1, 1); \
+ __ret = (int16x4_t) __builtin_neon_vqshl_n_v((int8x8_t)__rev0, __p1, 1); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrshrn_n_u32(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 17); \
+#define vqshluq_n_s8(__p0, __p1) __extension__ ({ \
+ uint8x16_t __ret; \
+ int8x16_t __s0 = __p0; \
+ __ret = (uint8x16_t) __builtin_neon_vqshluq_n_v((int8x16_t)__s0, __p1, 48); \
__ret; \
})
#else
-#define vrshrn_n_u32(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vrshrn_n_v((int8x16_t)__rev0, __p1, 17); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vrshrn_n_u32(__p0, __p1) __extension__ ({ \
+#define vqshluq_n_s8(__p0, __p1) __extension__ ({ \
+ uint8x16_t __ret; \
+ int8x16_t __s0 = __p0; \
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x16_t) __builtin_neon_vqshluq_n_v((int8x16_t)__rev0, __p1, 48); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshluq_n_s32(__p0, __p1) __extension__ ({ \
+ uint32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (uint32x4_t) __builtin_neon_vqshluq_n_v((int8x16_t)__s0, __p1, 50); \
+ __ret; \
+})
+#else
+#define vqshluq_n_s32(__p0, __p1) __extension__ ({ \
+ uint32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint32x4_t) __builtin_neon_vqshluq_n_v((int8x16_t)__rev0, __p1, 50); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshluq_n_s64(__p0, __p1) __extension__ ({ \
+ uint64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (uint64x2_t) __builtin_neon_vqshluq_n_v((int8x16_t)__s0, __p1, 51); \
+ __ret; \
+})
+#else
+#define vqshluq_n_s64(__p0, __p1) __extension__ ({ \
+ uint64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint64x2_t) __builtin_neon_vqshluq_n_v((int8x16_t)__rev0, __p1, 51); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshluq_n_s16(__p0, __p1) __extension__ ({ \
+ uint16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (uint16x8_t) __builtin_neon_vqshluq_n_v((int8x16_t)__s0, __p1, 49); \
+ __ret; \
+})
+#else
+#define vqshluq_n_s16(__p0, __p1) __extension__ ({ \
+ uint16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint16x8_t) __builtin_neon_vqshluq_n_v((int8x16_t)__rev0, __p1, 49); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshlu_n_s8(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ __ret = (uint8x8_t) __builtin_neon_vqshlu_n_v((int8x8_t)__s0, __p1, 16); \
+ __ret; \
+})
+#else
+#define vqshlu_n_s8(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x8_t) __builtin_neon_vqshlu_n_v((int8x8_t)__rev0, __p1, 16); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshlu_n_s32(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ __ret = (uint32x2_t) __builtin_neon_vqshlu_n_v((int8x8_t)__s0, __p1, 18); \
+ __ret; \
+})
+#else
+#define vqshlu_n_s32(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint32x2_t) __builtin_neon_vqshlu_n_v((int8x8_t)__rev0, __p1, 18); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#endif
+
+#define vqshlu_n_s64(__p0, __p1) __extension__ ({ \
+ uint64x1_t __ret; \
+ int64x1_t __s0 = __p0; \
+ __ret = (uint64x1_t) __builtin_neon_vqshlu_n_v((int8x8_t)__s0, __p1, 19); \
+ __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vqshlu_n_s16(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ __ret = (uint16x4_t) __builtin_neon_vqshlu_n_v((int8x8_t)__s0, __p1, 17); \
+ __ret; \
+})
+#else
+#define vqshlu_n_s16(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint16x4_t) __builtin_neon_vqshlu_n_v((int8x8_t)__rev0, __p1, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_n_u32(__p0, __p1) __extension__ ({ \
uint16x4_t __ret; \
uint32x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 17); \
+ __ret = (uint16x4_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 17); \
+ __ret; \
+})
+#else
+#define vqshrn_n_u32(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint16x4_t) __builtin_neon_vqshrn_n_v((int8x16_t)__rev0, __p1, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vqshrn_n_u32(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ __ret = (uint16x4_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 17); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrshrn_n_u64(__p0, __p1) __extension__ ({ \
+#define vqshrn_n_u64(__p0, __p1) __extension__ ({ \
uint32x2_t __ret; \
uint64x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 18); \
+ __ret = (uint32x2_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 18); \
__ret; \
})
#else
-#define vrshrn_n_u64(__p0, __p1) __extension__ ({ \
+#define vqshrn_n_u64(__p0, __p1) __extension__ ({ \
uint32x2_t __ret; \
uint64x2_t __s0 = __p0; \
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vrshrn_n_v((int8x16_t)__rev0, __p1, 18); \
+ __ret = (uint32x2_t) __builtin_neon_vqshrn_n_v((int8x16_t)__rev0, __p1, 18); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
-#define __noswap_vrshrn_n_u64(__p0, __p1) __extension__ ({ \
+#define __noswap_vqshrn_n_u64(__p0, __p1) __extension__ ({ \
uint32x2_t __ret; \
uint64x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 18); \
+ __ret = (uint32x2_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 18); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrshrn_n_u16(__p0, __p1) __extension__ ({ \
+#define vqshrn_n_u16(__p0, __p1) __extension__ ({ \
uint8x8_t __ret; \
uint16x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 16); \
+ __ret = (uint8x8_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 16); \
__ret; \
})
#else
-#define vrshrn_n_u16(__p0, __p1) __extension__ ({ \
+#define vqshrn_n_u16(__p0, __p1) __extension__ ({ \
uint8x8_t __ret; \
uint16x8_t __s0 = __p0; \
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_vrshrn_n_v((int8x16_t)__rev0, __p1, 16); \
+ __ret = (uint8x8_t) __builtin_neon_vqshrn_n_v((int8x16_t)__rev0, __p1, 16); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
-#define __noswap_vrshrn_n_u16(__p0, __p1) __extension__ ({ \
+#define __noswap_vqshrn_n_u16(__p0, __p1) __extension__ ({ \
uint8x8_t __ret; \
uint16x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 16); \
+ __ret = (uint8x8_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 16); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrshrn_n_s32(__p0, __p1) __extension__ ({ \
+#define vqshrn_n_s32(__p0, __p1) __extension__ ({ \
int16x4_t __ret; \
int32x4_t __s0 = __p0; \
- __ret = (int16x4_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 1); \
+ __ret = (int16x4_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 1); \
__ret; \
})
#else
-#define vrshrn_n_s32(__p0, __p1) __extension__ ({ \
+#define vqshrn_n_s32(__p0, __p1) __extension__ ({ \
int16x4_t __ret; \
int32x4_t __s0 = __p0; \
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vrshrn_n_v((int8x16_t)__rev0, __p1, 1); \
+ __ret = (int16x4_t) __builtin_neon_vqshrn_n_v((int8x16_t)__rev0, __p1, 1); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
-#define __noswap_vrshrn_n_s32(__p0, __p1) __extension__ ({ \
+#define __noswap_vqshrn_n_s32(__p0, __p1) __extension__ ({ \
int16x4_t __ret; \
int32x4_t __s0 = __p0; \
- __ret = (int16x4_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 1); \
+ __ret = (int16x4_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrshrn_n_s64(__p0, __p1) __extension__ ({ \
+#define vqshrn_n_s64(__p0, __p1) __extension__ ({ \
int32x2_t __ret; \
int64x2_t __s0 = __p0; \
- __ret = (int32x2_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 2); \
+ __ret = (int32x2_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 2); \
__ret; \
})
#else
-#define vrshrn_n_s64(__p0, __p1) __extension__ ({ \
+#define vqshrn_n_s64(__p0, __p1) __extension__ ({ \
int32x2_t __ret; \
int64x2_t __s0 = __p0; \
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vrshrn_n_v((int8x16_t)__rev0, __p1, 2); \
+ __ret = (int32x2_t) __builtin_neon_vqshrn_n_v((int8x16_t)__rev0, __p1, 2); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
-#define __noswap_vrshrn_n_s64(__p0, __p1) __extension__ ({ \
+#define __noswap_vqshrn_n_s64(__p0, __p1) __extension__ ({ \
int32x2_t __ret; \
int64x2_t __s0 = __p0; \
- __ret = (int32x2_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 2); \
+ __ret = (int32x2_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 2); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrshrn_n_s16(__p0, __p1) __extension__ ({ \
+#define vqshrn_n_s16(__p0, __p1) __extension__ ({ \
int8x8_t __ret; \
int16x8_t __s0 = __p0; \
- __ret = (int8x8_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 0); \
__ret; \
})
#else
-#define vrshrn_n_s16(__p0, __p1) __extension__ ({ \
+#define vqshrn_n_s16(__p0, __p1) __extension__ ({ \
int8x8_t __ret; \
int16x8_t __s0 = __p0; \
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x8_t) __builtin_neon_vrshrn_n_v((int8x16_t)__rev0, __p1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vqshrn_n_v((int8x16_t)__rev0, __p1, 0); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
-#define __noswap_vrshrn_n_s16(__p0, __p1) __extension__ ({ \
+#define __noswap_vqshrn_n_s16(__p0, __p1) __extension__ ({ \
int8x8_t __ret; \
int16x8_t __s0 = __p0; \
- __ret = (int8x8_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrun_n_s32(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (uint16x4_t) __builtin_neon_vqshrun_n_v((int8x16_t)__s0, __p1, 17); \
+ __ret; \
+})
+#else
+#define vqshrun_n_s32(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint16x4_t) __builtin_neon_vqshrun_n_v((int8x16_t)__rev0, __p1, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vqshrun_n_s32(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (uint16x4_t) __builtin_neon_vqshrun_n_v((int8x16_t)__s0, __p1, 17); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrun_n_s64(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (uint32x2_t) __builtin_neon_vqshrun_n_v((int8x16_t)__s0, __p1, 18); \
+ __ret; \
+})
+#else
+#define vqshrun_n_s64(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint32x2_t) __builtin_neon_vqshrun_n_v((int8x16_t)__rev0, __p1, 18); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_vqshrun_n_s64(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (uint32x2_t) __builtin_neon_vqshrun_n_v((int8x16_t)__s0, __p1, 18); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrun_n_s16(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (uint8x8_t) __builtin_neon_vqshrun_n_v((int8x16_t)__s0, __p1, 16); \
+ __ret; \
+})
+#else
+#define vqshrun_n_s16(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x8_t) __builtin_neon_vqshrun_n_v((int8x16_t)__rev0, __p1, 16); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vqshrun_n_s16(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (uint8x8_t) __builtin_neon_vqshrun_n_v((int8x16_t)__s0, __p1, 16); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vrsqrteq_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint8x16_t vqsubq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqsubq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vqsubq_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vrsqrteq_v((int8x16_t)__p0, 50);
+ __ret = (uint32x4_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
return __ret;
}
#else
-__ai uint32x4_t vrsqrteq_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vqsubq_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vrsqrteq_v((int8x16_t)__rev0, 50);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vrsqrteq_f32(float32x4_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vrsqrteq_v((int8x16_t)__p0, 41);
+__ai __attribute__((target("neon"))) uint64x2_t vqsubq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
return __ret;
}
#else
-__ai float32x4_t vrsqrteq_f32(float32x4_t __p0) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vrsqrteq_v((int8x16_t)__rev0, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint64x2_t vqsubq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vrsqrte_u32(uint32x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vrsqrte_v((int8x8_t)__p0, 18);
+__ai __attribute__((target("neon"))) uint16x8_t vqsubq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
return __ret;
}
#else
-__ai uint32x2_t vrsqrte_u32(uint32x2_t __p0) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vrsqrte_v((int8x8_t)__rev0, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint16x8_t vqsubq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vrsqrte_f32(float32x2_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vrsqrte_v((int8x8_t)__p0, 9);
+__ai __attribute__((target("neon"))) int8x16_t vqsubq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
return __ret;
}
#else
-__ai float32x2_t vrsqrte_f32(float32x2_t __p0) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vrsqrte_v((int8x8_t)__rev0, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int8x16_t vqsubq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vrsqrtsq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vrsqrtsq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+__ai __attribute__((target("neon"))) int32x4_t vqsubq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
return __ret;
}
#else
-__ai float32x4_t vrsqrtsq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vrsqrtsq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+__ai __attribute__((target("neon"))) int32x4_t vqsubq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vrsqrts_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vrsqrts_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+__ai __attribute__((target("neon"))) int64x2_t vqsubq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
return __ret;
}
#else
-__ai float32x2_t vrsqrts_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vrsqrts_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+__ai __attribute__((target("neon"))) int64x2_t vqsubq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrsraq_n_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16_t __ret; \
- uint8x16_t __s0 = __p0; \
- uint8x16_t __s1 = __p1; \
- __ret = (uint8x16_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 48); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vqsubq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ return __ret;
+}
#else
-#define vrsraq_n_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16_t __ret; \
- uint8x16_t __s0 = __p0; \
- uint8x16_t __s1 = __p1; \
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x16_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 48); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vqsubq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrsraq_n_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- uint32x4_t __s1 = __p1; \
- __ret = (uint32x4_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 50); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vqsub_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ return __ret;
+}
#else
-#define vrsraq_n_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- uint32x4_t __s1 = __p1; \
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (uint32x4_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 50); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vqsub_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vqsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrsraq_n_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- uint64x2_t __s1 = __p1; \
- __ret = (uint64x2_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 51); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vqsub_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ return __ret;
+}
#else
-#define vrsraq_n_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- uint64x2_t __s1 = __p1; \
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (uint64x2_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 51); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vqsub_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vqsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vqsub_u64(uint64x1_t __p0, uint64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vrsraq_n_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- uint16x8_t __s1 = __p1; \
- __ret = (uint16x8_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 49); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vqsub_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ return __ret;
+}
#else
-#define vrsraq_n_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- uint16x8_t __s1 = __p1; \
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint16x8_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 49); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vqsub_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vqsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrsraq_n_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16_t __ret; \
- int8x16_t __s0 = __p0; \
- int8x16_t __s1 = __p1; \
- __ret = (int8x16_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 32); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vqsub_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+ return __ret;
+}
#else
-#define vrsraq_n_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16_t __ret; \
- int8x16_t __s0 = __p0; \
- int8x16_t __s1 = __p1; \
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x16_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 32); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vqsub_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vqsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vrsraq_n_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __s1 = __p1; \
- __ret = (int32x4_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
- __ret; \
-})
-#else
-#define vrsraq_n_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __s1 = __p1; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vrsraq_n_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2_t __ret; \
- int64x2_t __s0 = __p0; \
- int64x2_t __s1 = __p1; \
- __ret = (int64x2_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 35); \
- __ret; \
-})
-#else
-#define vrsraq_n_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2_t __ret; \
- int64x2_t __s0 = __p0; \
- int64x2_t __s1 = __p1; \
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (int64x2_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 35); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vrsraq_n_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __s1 = __p1; \
- __ret = (int16x8_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
- __ret; \
-})
-#else
-#define vrsraq_n_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __s1 = __p1; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vrsra_n_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8_t __ret; \
- uint8x8_t __s0 = __p0; \
- uint8x8_t __s1 = __p1; \
- __ret = (uint8x8_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 16); \
- __ret; \
-})
-#else
-#define vrsra_n_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8_t __ret; \
- uint8x8_t __s0 = __p0; \
- uint8x8_t __s1 = __p1; \
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_vrsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 16); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vrsra_n_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2_t __ret; \
- uint32x2_t __s0 = __p0; \
- uint32x2_t __s1 = __p1; \
- __ret = (uint32x2_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 18); \
- __ret; \
-})
-#else
-#define vrsra_n_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2_t __ret; \
- uint32x2_t __s0 = __p0; \
- uint32x2_t __s1 = __p1; \
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vrsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 18); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#endif
-
-#define vrsra_n_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x1_t __ret; \
- uint64x1_t __s0 = __p0; \
- uint64x1_t __s1 = __p1; \
- __ret = (uint64x1_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 19); \
- __ret; \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vrsra_n_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4_t __ret; \
- uint16x4_t __s0 = __p0; \
- uint16x4_t __s1 = __p1; \
- __ret = (uint16x4_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 17); \
- __ret; \
-})
-#else
-#define vrsra_n_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4_t __ret; \
- uint16x4_t __s0 = __p0; \
- uint16x4_t __s1 = __p1; \
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vrsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 17); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vrsra_n_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8_t __ret; \
- int8x8_t __s0 = __p0; \
- int8x8_t __s1 = __p1; \
- __ret = (int8x8_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 0); \
- __ret; \
-})
-#else
-#define vrsra_n_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8_t __ret; \
- int8x8_t __s0 = __p0; \
- int8x8_t __s1 = __p1; \
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x8_t) __builtin_neon_vrsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 0); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vrsra_n_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __s1 = __p1; \
- __ret = (int32x2_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vqsub_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+ return __ret;
+}
#else
-#define vrsra_n_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __s1 = __p1; \
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vrsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vqsub_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vqsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
-#define vrsra_n_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x1_t __ret; \
- int64x1_t __s0 = __p0; \
- int64x1_t __s1 = __p1; \
- __ret = (int64x1_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 3); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x1_t vqsub_s64(int64x1_t __p0, int64x1_t __p1) {
+ int64x1_t __ret;
+ __ret = (int64x1_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vrsra_n_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __s1 = __p1; \
- __ret = (int16x4_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vqsub_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ return __ret;
+}
#else
-#define vrsra_n_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __s1 = __p1; \
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vrsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vqsub_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vqsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vrsubhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vraddhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
+ __ret = (uint16x4_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
return __ret;
}
#else
-__ai uint16x4_t vrsubhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vraddhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint16x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vrsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 17);
+ __ret = (uint16x4_t) __builtin_neon_vraddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai uint16x4_t __noswap_vrsubhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t __noswap_vraddhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
+ __ret = (uint16x4_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vrsubhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vraddhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
+ __ret = (uint32x2_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
return __ret;
}
#else
-__ai uint32x2_t vrsubhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vraddhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
uint32x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vrsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 18);
+ __ret = (uint32x2_t) __builtin_neon_vraddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 18);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai uint32x2_t __noswap_vrsubhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t __noswap_vraddhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
+ __ret = (uint32x2_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vrsubhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vraddhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
+ __ret = (uint8x8_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
return __ret;
}
#else
-__ai uint8x8_t vrsubhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vraddhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint8x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vrsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 16);
+ __ret = (uint8x8_t) __builtin_neon_vraddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 16);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai uint8x8_t __noswap_vrsubhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t __noswap_vraddhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
+ __ret = (uint8x8_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vrsubhn_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vraddhn_s32(int32x4_t __p0, int32x4_t __p1) {
int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
+ __ret = (int16x4_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
return __ret;
}
#else
-__ai int16x4_t vrsubhn_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vraddhn_s32(int32x4_t __p0, int32x4_t __p1) {
int16x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vrsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 1);
+ __ret = (int16x4_t) __builtin_neon_vraddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int16x4_t __noswap_vrsubhn_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vraddhn_s32(int32x4_t __p0, int32x4_t __p1) {
int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
+ __ret = (int16x4_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vrsubhn_s64(int64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vraddhn_s64(int64x2_t __p0, int64x2_t __p1) {
int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
+ __ret = (int32x2_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
return __ret;
}
#else
-__ai int32x2_t vrsubhn_s64(int64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vraddhn_s64(int64x2_t __p0, int64x2_t __p1) {
int32x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vrsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 2);
+ __ret = (int32x2_t) __builtin_neon_vraddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 2);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai int32x2_t __noswap_vrsubhn_s64(int64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vraddhn_s64(int64x2_t __p0, int64x2_t __p1) {
int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
+ __ret = (int32x2_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vrsubhn_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vraddhn_s16(int16x8_t __p0, int16x8_t __p1) {
int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
+ __ret = (int8x8_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
return __ret;
}
#else
-__ai int8x8_t vrsubhn_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vraddhn_s16(int16x8_t __p0, int16x8_t __p1) {
int8x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vrsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 0);
+ __ret = (int8x8_t) __builtin_neon_vraddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 0);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai int8x8_t __noswap_vrsubhn_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t __noswap_vraddhn_s16(int16x8_t __p0, int16x8_t __p1) {
int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
+ __ret = (int8x8_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vset_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8_t __ret; \
- poly8_t __s0 = __p0; \
- poly8x8_t __s1 = __p1; \
- __ret = (poly8x8_t) __builtin_neon_vset_lane_i8(__s0, (poly8x8_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vrecpeq_u32(uint32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vrecpeq_v((int8x16_t)__p0, 50);
+ return __ret;
+}
#else
-#define vset_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8_t __ret; \
- poly8_t __s0 = __p0; \
- poly8x8_t __s1 = __p1; \
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly8x8_t) __builtin_neon_vset_lane_i8(__s0, (poly8x8_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vset_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8_t __ret; \
- poly8_t __s0 = __p0; \
- poly8x8_t __s1 = __p1; \
- __ret = (poly8x8_t) __builtin_neon_vset_lane_i8(__s0, (poly8x8_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vrecpeq_u32(uint32x4_t __p0) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vrecpeq_v((int8x16_t)__rev0, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vset_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4_t __ret; \
- poly16_t __s0 = __p0; \
- poly16x4_t __s1 = __p1; \
- __ret = (poly16x4_t) __builtin_neon_vset_lane_i16(__s0, (poly16x4_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vrecpeq_f32(float32x4_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vrecpeq_v((int8x16_t)__p0, 41);
+ return __ret;
+}
#else
-#define vset_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4_t __ret; \
- poly16_t __s0 = __p0; \
- poly16x4_t __s1 = __p1; \
- poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (poly16x4_t) __builtin_neon_vset_lane_i16(__s0, (poly16x4_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vset_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4_t __ret; \
- poly16_t __s0 = __p0; \
- poly16x4_t __s1 = __p1; \
- __ret = (poly16x4_t) __builtin_neon_vset_lane_i16(__s0, (poly16x4_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vrecpeq_f32(float32x4_t __p0) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vrecpeq_v((int8x16_t)__rev0, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsetq_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16_t __ret; \
- poly8_t __s0 = __p0; \
- poly8x16_t __s1 = __p1; \
- __ret = (poly8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (poly8x16_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vrecpe_u32(uint32x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vrecpe_v((int8x8_t)__p0, 18);
+ return __ret;
+}
#else
-#define vsetq_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16_t __ret; \
- poly8_t __s0 = __p0; \
- poly8x16_t __s1 = __p1; \
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (poly8x16_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vsetq_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16_t __ret; \
- poly8_t __s0 = __p0; \
- poly8x16_t __s1 = __p1; \
- __ret = (poly8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (poly8x16_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vrecpe_u32(uint32x2_t __p0) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vrecpe_v((int8x8_t)__rev0, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsetq_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8_t __ret; \
- poly16_t __s0 = __p0; \
- poly16x8_t __s1 = __p1; \
- __ret = (poly16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (poly16x8_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vrecpe_f32(float32x2_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vrecpe_v((int8x8_t)__p0, 9);
+ return __ret;
+}
#else
-#define vsetq_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8_t __ret; \
- poly16_t __s0 = __p0; \
- poly16x8_t __s1 = __p1; \
- poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (poly16x8_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vsetq_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8_t __ret; \
- poly16_t __s0 = __p0; \
- poly16x8_t __s1 = __p1; \
- __ret = (poly16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (poly16x8_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vrecpe_f32(float32x2_t __p0) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vrecpe_v((int8x8_t)__rev0, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsetq_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16_t __ret; \
- uint8_t __s0 = __p0; \
- uint8x16_t __s1 = __p1; \
- __ret = (uint8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (int8x16_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vrecpsq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vrecpsq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+ return __ret;
+}
#else
-#define vsetq_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16_t __ret; \
- uint8_t __s0 = __p0; \
- uint8x16_t __s1 = __p1; \
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (int8x16_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vsetq_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16_t __ret; \
- uint8_t __s0 = __p0; \
- uint8x16_t __s1 = __p1; \
- __ret = (uint8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (int8x16_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vrecpsq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vrecpsq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsetq_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4_t __ret; \
- uint32_t __s0 = __p0; \
- uint32x4_t __s1 = __p1; \
- __ret = (uint32x4_t) __builtin_neon_vsetq_lane_i32(__s0, (int32x4_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vrecps_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vrecps_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+ return __ret;
+}
#else
-#define vsetq_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4_t __ret; \
- uint32_t __s0 = __p0; \
- uint32x4_t __s1 = __p1; \
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (uint32x4_t) __builtin_neon_vsetq_lane_i32(__s0, (int32x4_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vsetq_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4_t __ret; \
- uint32_t __s0 = __p0; \
- uint32x4_t __s1 = __p1; \
- __ret = (uint32x4_t) __builtin_neon_vsetq_lane_i32(__s0, (int32x4_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vrecps_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vrecps_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsetq_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2_t __ret; \
- uint64_t __s0 = __p0; \
- uint64x2_t __s1 = __p1; \
- __ret = (uint64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (int64x2_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x8_t vrev16_p8(poly8x8_t __p0) {
+ poly8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6);
+ return __ret;
+}
#else
-#define vsetq_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2_t __ret; \
- uint64_t __s0 = __p0; \
- uint64x2_t __s1 = __p1; \
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (uint64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (int64x2_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_vsetq_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2_t __ret; \
- uint64_t __s0 = __p0; \
- uint64x2_t __s1 = __p1; \
- __ret = (uint64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (int64x2_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x8_t vrev16_p8(poly8x8_t __p0) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsetq_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8_t __ret; \
- uint16_t __s0 = __p0; \
- uint16x8_t __s1 = __p1; \
- __ret = (uint16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (int16x8_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x16_t vrev16q_p8(poly8x16_t __p0) {
+ poly8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+ return __ret;
+}
#else
-#define vsetq_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8_t __ret; \
- uint16_t __s0 = __p0; \
- uint16x8_t __s1 = __p1; \
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (int16x8_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vsetq_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8_t __ret; \
- uint16_t __s0 = __p0; \
- uint16x8_t __s1 = __p1; \
- __ret = (uint16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (int16x8_t)__s1, __p2); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vsetq_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16_t __ret; \
- int8_t __s0 = __p0; \
- int8x16_t __s1 = __p1; \
- __ret = (int8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (int8x16_t)__s1, __p2); \
- __ret; \
-})
-#else
-#define vsetq_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16_t __ret; \
- int8_t __s0 = __p0; \
- int8x16_t __s1 = __p1; \
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (int8x16_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vsetq_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16_t __ret; \
- int8_t __s0 = __p0; \
- int8x16_t __s1 = __p1; \
- __ret = (int8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (int8x16_t)__s1, __p2); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vsetq_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x4_t __ret; \
- float32_t __s0 = __p0; \
- float32x4_t __s1 = __p1; \
- __ret = (float32x4_t) __builtin_neon_vsetq_lane_f32(__s0, (float32x4_t)__s1, __p2); \
- __ret; \
-})
-#else
-#define vsetq_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x4_t __ret; \
- float32_t __s0 = __p0; \
- float32x4_t __s1 = __p1; \
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (float32x4_t) __builtin_neon_vsetq_lane_f32(__s0, (float32x4_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vsetq_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x4_t __ret; \
- float32_t __s0 = __p0; \
- float32x4_t __s1 = __p1; \
- __ret = (float32x4_t) __builtin_neon_vsetq_lane_f32(__s0, (float32x4_t)__s1, __p2); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vsetq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32_t __s0 = __p0; \
- int32x4_t __s1 = __p1; \
- __ret = (int32x4_t) __builtin_neon_vsetq_lane_i32(__s0, (int32x4_t)__s1, __p2); \
- __ret; \
-})
-#else
-#define vsetq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32_t __s0 = __p0; \
- int32x4_t __s1 = __p1; \
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_vsetq_lane_i32(__s0, (int32x4_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vsetq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32_t __s0 = __p0; \
- int32x4_t __s1 = __p1; \
- __ret = (int32x4_t) __builtin_neon_vsetq_lane_i32(__s0, (int32x4_t)__s1, __p2); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vsetq_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2_t __ret; \
- int64_t __s0 = __p0; \
- int64x2_t __s1 = __p1; \
- __ret = (int64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (int64x2_t)__s1, __p2); \
- __ret; \
-})
-#else
-#define vsetq_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2_t __ret; \
- int64_t __s0 = __p0; \
- int64x2_t __s1 = __p1; \
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (int64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (int64x2_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_vsetq_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2_t __ret; \
- int64_t __s0 = __p0; \
- int64x2_t __s1 = __p1; \
- __ret = (int64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (int64x2_t)__s1, __p2); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vsetq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16_t __s0 = __p0; \
- int16x8_t __s1 = __p1; \
- __ret = (int16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (int16x8_t)__s1, __p2); \
- __ret; \
-})
-#else
-#define vsetq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16_t __s0 = __p0; \
- int16x8_t __s1 = __p1; \
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (int16x8_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vsetq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16_t __s0 = __p0; \
- int16x8_t __s1 = __p1; \
- __ret = (int16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (int16x8_t)__s1, __p2); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vset_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8_t __ret; \
- uint8_t __s0 = __p0; \
- uint8x8_t __s1 = __p1; \
- __ret = (uint8x8_t) __builtin_neon_vset_lane_i8(__s0, (int8x8_t)__s1, __p2); \
- __ret; \
-})
-#else
-#define vset_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8_t __ret; \
- uint8_t __s0 = __p0; \
- uint8x8_t __s1 = __p1; \
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_vset_lane_i8(__s0, (int8x8_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vset_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8_t __ret; \
- uint8_t __s0 = __p0; \
- uint8x8_t __s1 = __p1; \
- __ret = (uint8x8_t) __builtin_neon_vset_lane_i8(__s0, (int8x8_t)__s1, __p2); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vset_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2_t __ret; \
- uint32_t __s0 = __p0; \
- uint32x2_t __s1 = __p1; \
- __ret = (uint32x2_t) __builtin_neon_vset_lane_i32(__s0, (int32x2_t)__s1, __p2); \
- __ret; \
-})
-#else
-#define vset_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2_t __ret; \
- uint32_t __s0 = __p0; \
- uint32x2_t __s1 = __p1; \
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vset_lane_i32(__s0, (int32x2_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_vset_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2_t __ret; \
- uint32_t __s0 = __p0; \
- uint32x2_t __s1 = __p1; \
- __ret = (uint32x2_t) __builtin_neon_vset_lane_i32(__s0, (int32x2_t)__s1, __p2); \
- __ret; \
-})
-#endif
-
-#define vset_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x1_t __ret; \
- uint64_t __s0 = __p0; \
- uint64x1_t __s1 = __p1; \
- __ret = (uint64x1_t) __builtin_neon_vset_lane_i64(__s0, (int64x1_t)__s1, __p2); \
- __ret; \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vset_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4_t __ret; \
- uint16_t __s0 = __p0; \
- uint16x4_t __s1 = __p1; \
- __ret = (uint16x4_t) __builtin_neon_vset_lane_i16(__s0, (int16x4_t)__s1, __p2); \
- __ret; \
-})
-#else
-#define vset_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4_t __ret; \
- uint16_t __s0 = __p0; \
- uint16x4_t __s1 = __p1; \
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vset_lane_i16(__s0, (int16x4_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vset_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4_t __ret; \
- uint16_t __s0 = __p0; \
- uint16x4_t __s1 = __p1; \
- __ret = (uint16x4_t) __builtin_neon_vset_lane_i16(__s0, (int16x4_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x16_t vrev16q_p8(poly8x16_t __p0) {
+ poly8x16_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vset_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8_t __ret; \
- int8_t __s0 = __p0; \
- int8x8_t __s1 = __p1; \
- __ret = (int8x8_t) __builtin_neon_vset_lane_i8(__s0, (int8x8_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vrev16q_u8(uint8x16_t __p0) {
+ uint8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+ return __ret;
+}
#else
-#define vset_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8_t __ret; \
- int8_t __s0 = __p0; \
- int8x8_t __s1 = __p1; \
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x8_t) __builtin_neon_vset_lane_i8(__s0, (int8x8_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vset_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8_t __ret; \
- int8_t __s0 = __p0; \
- int8x8_t __s1 = __p1; \
- __ret = (int8x8_t) __builtin_neon_vset_lane_i8(__s0, (int8x8_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vrev16q_u8(uint8x16_t __p0) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vset_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x2_t __ret; \
- float32_t __s0 = __p0; \
- float32x2_t __s1 = __p1; \
- __ret = (float32x2_t) __builtin_neon_vset_lane_f32(__s0, (float32x2_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vrev16q_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+ return __ret;
+}
#else
-#define vset_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x2_t __ret; \
- float32_t __s0 = __p0; \
- float32x2_t __s1 = __p1; \
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (float32x2_t) __builtin_neon_vset_lane_f32(__s0, (float32x2_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_vset_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x2_t __ret; \
- float32_t __s0 = __p0; \
- float32x2_t __s1 = __p1; \
- __ret = (float32x2_t) __builtin_neon_vset_lane_f32(__s0, (float32x2_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vrev16q_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vset_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32_t __s0 = __p0; \
- int32x2_t __s1 = __p1; \
- __ret = (int32x2_t) __builtin_neon_vset_lane_i32(__s0, (int32x2_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vrev16_u8(uint8x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6);
+ return __ret;
+}
#else
-#define vset_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32_t __s0 = __p0; \
- int32x2_t __s1 = __p1; \
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vset_lane_i32(__s0, (int32x2_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_vset_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32_t __s0 = __p0; \
- int32x2_t __s1 = __p1; \
- __ret = (int32x2_t) __builtin_neon_vset_lane_i32(__s0, (int32x2_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vrev16_u8(uint8x8_t __p0) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vset_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x1_t __ret; \
- int64_t __s0 = __p0; \
- int64x1_t __s1 = __p1; \
- __ret = (int64x1_t) __builtin_neon_vset_lane_i64(__s0, (int64x1_t)__s1, __p2); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vset_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16_t __s0 = __p0; \
- int16x4_t __s1 = __p1; \
- __ret = (int16x4_t) __builtin_neon_vset_lane_i16(__s0, (int16x4_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vrev16_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6);
+ return __ret;
+}
#else
-#define vset_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16_t __s0 = __p0; \
- int16x4_t __s1 = __p1; \
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vset_lane_i16(__s0, (int16x4_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vset_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16_t __s0 = __p0; \
- int16x4_t __s1 = __p1; \
- __ret = (int16x4_t) __builtin_neon_vset_lane_i16(__s0, (int16x4_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vrev16_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+__ai __attribute__((target("neon"))) poly8x8_t vrev32_p8(poly8x8_t __p0) {
+ poly8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
return __ret;
}
#else
-__ai uint8x16_t vshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly8x8_t vrev32_p8(poly8x8_t __p0) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+__ai __attribute__((target("neon"))) poly16x4_t vrev32_p16(poly16x4_t __p0) {
+ poly16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2);
return __ret;
}
#else
-__ai uint32x4_t vshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+__ai __attribute__((target("neon"))) poly16x4_t vrev32_p16(poly16x4_t __p0) {
+ poly16x4_t __ret;
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+__ai __attribute__((target("neon"))) poly8x16_t vrev32q_p8(poly8x16_t __p0) {
+ poly8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
return __ret;
}
#else
-__ai uint64x2_t vshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) poly8x16_t vrev32q_p8(poly8x16_t __p0) {
+ poly8x16_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+__ai __attribute__((target("neon"))) poly16x8_t vrev32q_p16(poly16x8_t __p0) {
+ poly16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6);
return __ret;
}
#else
-__ai uint16x8_t vshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+__ai __attribute__((target("neon"))) poly16x8_t vrev32q_p16(poly16x8_t __p0) {
+ poly16x8_t __ret;
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vshlq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+__ai __attribute__((target("neon"))) uint8x16_t vrev32q_u8(uint8x16_t __p0) {
+ uint8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
return __ret;
}
#else
-__ai int8x16_t vshlq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+__ai __attribute__((target("neon"))) uint8x16_t vrev32q_u8(uint8x16_t __p0) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vshlq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+__ai __attribute__((target("neon"))) uint16x8_t vrev32q_u16(uint16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6);
return __ret;
}
#else
-__ai int32x4_t vshlq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint16x8_t vrev32q_u16(uint16x8_t __p0) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vshlq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+__ai __attribute__((target("neon"))) int8x16_t vrev32q_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
return __ret;
}
#else
-__ai int64x2_t vshlq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int8x16_t vrev32q_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vshlq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vrev32q_s16(int16x8_t __p0) {
int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6);
return __ret;
}
#else
-__ai int16x8_t vshlq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vrev32q_s16(int16x8_t __p0) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vrev32_u8(uint8x8_t __p0) {
uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
return __ret;
}
#else
-__ai uint8x8_t vshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vrev32_u8(uint8x8_t __p0) {
uint8x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vshl_u32(uint32x2_t __p0, int32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
- return __ret;
-}
-#else
-__ai uint32x2_t vshl_u32(uint32x2_t __p0, int32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-__ai uint64x1_t vshl_u64(uint64x1_t __p0, int64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
- return __ret;
-}
-#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vrev32_u16(uint16x4_t __p0) {
uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2);
return __ret;
}
#else
-__ai uint16x4_t vshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vrev32_u16(uint16x4_t __p0) {
uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vshl_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vrev32_s8(int8x8_t __p0) {
int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+ __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
return __ret;
}
#else
-__ai int8x8_t vshl_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vrev32_s8(int8x8_t __p0) {
int8x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vshl_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
- return __ret;
-}
-#else
-__ai int32x2_t vshl_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-__ai int64x1_t vshl_s64(int64x1_t __p0, int64x1_t __p1) {
- int64x1_t __ret;
- __ret = (int64x1_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
- return __ret;
-}
-#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vshl_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vrev32_s16(int16x4_t __p0) {
int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2);
return __ret;
}
#else
-__ai int16x4_t vshl_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vrev32_s16(int16x4_t __p0) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshlq_n_u8(__p0, __p1) __extension__ ({ \
- uint8x16_t __ret; \
- uint8x16_t __s0 = __p0; \
- __ret = (uint8x16_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 48); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x8_t vrev64_p8(poly8x8_t __p0) {
+ poly8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#else
-#define vshlq_n_u8(__p0, __p1) __extension__ ({ \
- uint8x16_t __ret; \
- uint8x16_t __s0 = __p0; \
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x16_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 48); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x8_t vrev64_p8(poly8x8_t __p0) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshlq_n_u32(__p0, __p1) __extension__ ({ \
- uint32x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- __ret = (uint32x4_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 50); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x4_t vrev64_p16(poly16x4_t __p0) {
+ poly16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ return __ret;
+}
#else
-#define vshlq_n_u32(__p0, __p1) __extension__ ({ \
- uint32x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint32x4_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 50); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x4_t vrev64_p16(poly16x4_t __p0) {
+ poly16x4_t __ret;
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshlq_n_u64(__p0, __p1) __extension__ ({ \
- uint64x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- __ret = (uint64x2_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 51); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x16_t vrev64q_p8(poly8x16_t __p0) {
+ poly8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
+ return __ret;
+}
#else
-#define vshlq_n_u64(__p0, __p1) __extension__ ({ \
- uint64x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint64x2_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 51); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x16_t vrev64q_p8(poly8x16_t __p0) {
+ poly8x16_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshlq_n_u16(__p0, __p1) __extension__ ({ \
- uint16x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- __ret = (uint16x8_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 49); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x8_t vrev64q_p16(poly16x8_t __p0) {
+ poly16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
+ return __ret;
+}
#else
-#define vshlq_n_u16(__p0, __p1) __extension__ ({ \
- uint16x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint16x8_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 49); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x8_t vrev64q_p16(poly16x8_t __p0) {
+ poly16x8_t __ret;
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshlq_n_s8(__p0, __p1) __extension__ ({ \
- int8x16_t __ret; \
- int8x16_t __s0 = __p0; \
- __ret = (int8x16_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 32); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vrev64q_u8(uint8x16_t __p0) {
+ uint8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
+ return __ret;
+}
#else
-#define vshlq_n_s8(__p0, __p1) __extension__ ({ \
- int8x16_t __ret; \
- int8x16_t __s0 = __p0; \
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x16_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 32); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vrev64q_u8(uint8x16_t __p0) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshlq_n_s32(__p0, __p1) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (int32x4_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 34); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vrev64q_u32(uint32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2);
+ return __ret;
+}
#else
-#define vshlq_n_s32(__p0, __p1) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 34); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vrev64q_u32(uint32x4_t __p0) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshlq_n_s64(__p0, __p1) __extension__ ({ \
- int64x2_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (int64x2_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 35); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vrev64q_u16(uint16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
+ return __ret;
+}
#else
-#define vshlq_n_s64(__p0, __p1) __extension__ ({ \
- int64x2_t __ret; \
- int64x2_t __s0 = __p0; \
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int64x2_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 35); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vrev64q_u16(uint16x8_t __p0) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshlq_n_s16(__p0, __p1) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (int16x8_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 33); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vrev64q_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
+ return __ret;
+}
#else
-#define vshlq_n_s16(__p0, __p1) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 33); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vrev64q_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshl_n_u8(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- uint8x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 16); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vrev64q_f32(float32x4_t __p0) {
+ float32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2);
+ return __ret;
+}
#else
-#define vshl_n_u8(__p0, __p1) __extension__ ({ \
- uint8x8_t __ret; \
- uint8x8_t __s0 = __p0; \
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_vshl_n_v((int8x8_t)__rev0, __p1, 16); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vrev64q_f32(float32x4_t __p0) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshl_n_u32(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- uint32x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 18); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vrev64q_s32(int32x4_t __p0) {
+ int32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2);
+ return __ret;
+}
#else
-#define vshl_n_u32(__p0, __p1) __extension__ ({ \
- uint32x2_t __ret; \
- uint32x2_t __s0 = __p0; \
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vshl_n_v((int8x8_t)__rev0, __p1, 18); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vrev64q_s32(int32x4_t __p0) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vshl_n_u64(__p0, __p1) __extension__ ({ \
- uint64x1_t __ret; \
- uint64x1_t __s0 = __p0; \
- __ret = (uint64x1_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 19); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vshl_n_u16(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- uint16x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 17); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vrev64q_s16(int16x8_t __p0) {
+ int16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
+ return __ret;
+}
#else
-#define vshl_n_u16(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- uint16x4_t __s0 = __p0; \
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vshl_n_v((int8x8_t)__rev0, __p1, 17); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vrev64q_s16(int16x8_t __p0) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshl_n_s8(__p0, __p1) __extension__ ({ \
- int8x8_t __ret; \
- int8x8_t __s0 = __p0; \
- __ret = (int8x8_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vrev64_u8(uint8x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#else
-#define vshl_n_s8(__p0, __p1) __extension__ ({ \
- int8x8_t __ret; \
- int8x8_t __s0 = __p0; \
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x8_t) __builtin_neon_vshl_n_v((int8x8_t)__rev0, __p1, 0); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vrev64_u8(uint8x8_t __p0) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshl_n_s32(__p0, __p1) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- __ret = (int32x2_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vrev64_u32(uint32x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1, 0);
+ return __ret;
+}
#else
-#define vshl_n_s32(__p0, __p1) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vshl_n_v((int8x8_t)__rev0, __p1, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vrev64_u32(uint32x2_t __p0) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
-#define vshl_n_s64(__p0, __p1) __extension__ ({ \
- int64x1_t __ret; \
- int64x1_t __s0 = __p0; \
- __ret = (int64x1_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 3); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vshl_n_s16(__p0, __p1) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- __ret = (int16x4_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vrev64_u16(uint16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ return __ret;
+}
#else
-#define vshl_n_s16(__p0, __p1) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vshl_n_v((int8x8_t)__rev0, __p1, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vrev64_u16(uint16x4_t __p0) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshll_n_u8(__p0, __p1) __extension__ ({ \
- uint16x8_t __ret; \
- uint8x8_t __s0 = __p0; \
- __ret = (uint16x8_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 49); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vrev64_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#else
-#define vshll_n_u8(__p0, __p1) __extension__ ({ \
- uint16x8_t __ret; \
- uint8x8_t __s0 = __p0; \
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint16x8_t) __builtin_neon_vshll_n_v((int8x8_t)__rev0, __p1, 49); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vshll_n_u8(__p0, __p1) __extension__ ({ \
- uint16x8_t __ret; \
- uint8x8_t __s0 = __p0; \
- __ret = (uint16x8_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 49); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vrev64_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshll_n_u32(__p0, __p1) __extension__ ({ \
- uint64x2_t __ret; \
- uint32x2_t __s0 = __p0; \
- __ret = (uint64x2_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 51); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vrev64_f32(float32x2_t __p0) {
+ float32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1, 0);
+ return __ret;
+}
#else
-#define vshll_n_u32(__p0, __p1) __extension__ ({ \
- uint64x2_t __ret; \
- uint32x2_t __s0 = __p0; \
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint64x2_t) __builtin_neon_vshll_n_v((int8x8_t)__rev0, __p1, 51); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_vshll_n_u32(__p0, __p1) __extension__ ({ \
- uint64x2_t __ret; \
- uint32x2_t __s0 = __p0; \
- __ret = (uint64x2_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 51); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vrev64_f32(float32x2_t __p0) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshll_n_u16(__p0, __p1) __extension__ ({ \
- uint32x4_t __ret; \
- uint16x4_t __s0 = __p0; \
- __ret = (uint32x4_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 50); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vrev64_s32(int32x2_t __p0) {
+ int32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1, 0);
+ return __ret;
+}
#else
-#define vshll_n_u16(__p0, __p1) __extension__ ({ \
- uint32x4_t __ret; \
- uint16x4_t __s0 = __p0; \
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint32x4_t) __builtin_neon_vshll_n_v((int8x8_t)__rev0, __p1, 50); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vshll_n_u16(__p0, __p1) __extension__ ({ \
- uint32x4_t __ret; \
- uint16x4_t __s0 = __p0; \
- __ret = (uint32x4_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 50); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vrev64_s32(int32x2_t __p0) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshll_n_s8(__p0, __p1) __extension__ ({ \
- int16x8_t __ret; \
- int8x8_t __s0 = __p0; \
- __ret = (int16x8_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 33); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vrev64_s16(int16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ return __ret;
+}
#else
-#define vshll_n_s8(__p0, __p1) __extension__ ({ \
- int16x8_t __ret; \
- int8x8_t __s0 = __p0; \
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_vshll_n_v((int8x8_t)__rev0, __p1, 33); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vshll_n_s8(__p0, __p1) __extension__ ({ \
- int16x8_t __ret; \
- int8x8_t __s0 = __p0; \
- __ret = (int16x8_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 33); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vrev64_s16(int16x4_t __p0) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshll_n_s32(__p0, __p1) __extension__ ({ \
- int64x2_t __ret; \
- int32x2_t __s0 = __p0; \
- __ret = (int64x2_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 35); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float16x8_t vrev64q_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
+ return __ret;
+}
#else
-#define vshll_n_s32(__p0, __p1) __extension__ ({ \
- int64x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int64x2_t) __builtin_neon_vshll_n_v((int8x8_t)__rev0, __p1, 35); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_vshll_n_s32(__p0, __p1) __extension__ ({ \
- int64x2_t __ret; \
- int32x2_t __s0 = __p0; \
- __ret = (int64x2_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 35); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float16x8_t vrev64q_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshll_n_s16(__p0, __p1) __extension__ ({ \
- int32x4_t __ret; \
- int16x4_t __s0 = __p0; \
- __ret = (int32x4_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 34); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float16x4_t vrev64_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ return __ret;
+}
#else
-#define vshll_n_s16(__p0, __p1) __extension__ ({ \
- int32x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_vshll_n_v((int8x8_t)__rev0, __p1, 34); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vshll_n_s16(__p0, __p1) __extension__ ({ \
- int32x4_t __ret; \
- int16x4_t __s0 = __p0; \
- __ret = (int32x4_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 34); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float16x4_t vrev64_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshrq_n_u8(__p0, __p1) __extension__ ({ \
+__ai __attribute__((target("neon"))) uint8x16_t vrhaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vrhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vrhaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vrhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vrhaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vrhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vrhaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vrhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vrhaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vrhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vrhaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vrhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vrhaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vrhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vrhaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vrhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vrhaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vrhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vrhaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vrhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vrhaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vrhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vrhaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vrhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vrhadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vrhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vrhadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vrhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vrhadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vrhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vrhadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vrhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vrhadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vrhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vrhadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vrhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vrhadd_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vrhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vrhadd_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vrhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vrhadd_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vrhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vrhadd_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vrhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vrhadd_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vrhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vrhadd_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vrhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vrshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vrshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vrshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vrshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vrshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vrshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vrshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vrshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vrshlq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vrshlq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vrshlq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vrshlq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vrshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vrshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vrshlq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vrshlq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vrshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vrshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vrshl_u32(uint32x2_t __p0, int32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vrshl_u32(uint32x2_t __p0, int32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vrshl_u64(uint64x1_t __p0, int64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+ return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vrshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vrshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vrshl_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vrshl_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vrshl_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vrshl_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vrshl_s64(int64x1_t __p0, int64x1_t __p1) {
+ int64x1_t __ret;
+ __ret = (int64x1_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
+ return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vrshl_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vrshl_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrq_n_u8(__p0, __p1) __extension__ ({ \
uint8x16_t __ret; \
uint8x16_t __s0 = __p0; \
- __ret = (uint8x16_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 48); \
+ __ret = (uint8x16_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 48); \
__ret; \
})
#else
-#define vshrq_n_u8(__p0, __p1) __extension__ ({ \
+#define vrshrq_n_u8(__p0, __p1) __extension__ ({ \
uint8x16_t __ret; \
uint8x16_t __s0 = __p0; \
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x16_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 48); \
+ __ret = (uint8x16_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 48); \
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshrq_n_u32(__p0, __p1) __extension__ ({ \
+#define vrshrq_n_u32(__p0, __p1) __extension__ ({ \
uint32x4_t __ret; \
uint32x4_t __s0 = __p0; \
- __ret = (uint32x4_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 50); \
+ __ret = (uint32x4_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 50); \
__ret; \
})
#else
-#define vshrq_n_u32(__p0, __p1) __extension__ ({ \
+#define vrshrq_n_u32(__p0, __p1) __extension__ ({ \
uint32x4_t __ret; \
uint32x4_t __s0 = __p0; \
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint32x4_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 50); \
+ __ret = (uint32x4_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 50); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshrq_n_u64(__p0, __p1) __extension__ ({ \
+#define vrshrq_n_u64(__p0, __p1) __extension__ ({ \
uint64x2_t __ret; \
uint64x2_t __s0 = __p0; \
- __ret = (uint64x2_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 51); \
+ __ret = (uint64x2_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 51); \
__ret; \
})
#else
-#define vshrq_n_u64(__p0, __p1) __extension__ ({ \
+#define vrshrq_n_u64(__p0, __p1) __extension__ ({ \
uint64x2_t __ret; \
uint64x2_t __s0 = __p0; \
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint64x2_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 51); \
+ __ret = (uint64x2_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 51); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshrq_n_u16(__p0, __p1) __extension__ ({ \
+#define vrshrq_n_u16(__p0, __p1) __extension__ ({ \
uint16x8_t __ret; \
uint16x8_t __s0 = __p0; \
- __ret = (uint16x8_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 49); \
+ __ret = (uint16x8_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 49); \
__ret; \
})
#else
-#define vshrq_n_u16(__p0, __p1) __extension__ ({ \
+#define vrshrq_n_u16(__p0, __p1) __extension__ ({ \
uint16x8_t __ret; \
uint16x8_t __s0 = __p0; \
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint16x8_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 49); \
+ __ret = (uint16x8_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 49); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshrq_n_s8(__p0, __p1) __extension__ ({ \
+#define vrshrq_n_s8(__p0, __p1) __extension__ ({ \
int8x16_t __ret; \
int8x16_t __s0 = __p0; \
- __ret = (int8x16_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 32); \
+ __ret = (int8x16_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 32); \
__ret; \
})
#else
-#define vshrq_n_s8(__p0, __p1) __extension__ ({ \
+#define vrshrq_n_s8(__p0, __p1) __extension__ ({ \
int8x16_t __ret; \
int8x16_t __s0 = __p0; \
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x16_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 32); \
+ __ret = (int8x16_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 32); \
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshrq_n_s32(__p0, __p1) __extension__ ({ \
+#define vrshrq_n_s32(__p0, __p1) __extension__ ({ \
int32x4_t __ret; \
int32x4_t __s0 = __p0; \
- __ret = (int32x4_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 34); \
+ __ret = (int32x4_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 34); \
__ret; \
})
#else
-#define vshrq_n_s32(__p0, __p1) __extension__ ({ \
+#define vrshrq_n_s32(__p0, __p1) __extension__ ({ \
int32x4_t __ret; \
int32x4_t __s0 = __p0; \
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 34); \
+ __ret = (int32x4_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 34); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshrq_n_s64(__p0, __p1) __extension__ ({ \
+#define vrshrq_n_s64(__p0, __p1) __extension__ ({ \
int64x2_t __ret; \
int64x2_t __s0 = __p0; \
- __ret = (int64x2_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 35); \
+ __ret = (int64x2_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 35); \
__ret; \
})
#else
-#define vshrq_n_s64(__p0, __p1) __extension__ ({ \
+#define vrshrq_n_s64(__p0, __p1) __extension__ ({ \
int64x2_t __ret; \
int64x2_t __s0 = __p0; \
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int64x2_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 35); \
+ __ret = (int64x2_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 35); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshrq_n_s16(__p0, __p1) __extension__ ({ \
+#define vrshrq_n_s16(__p0, __p1) __extension__ ({ \
int16x8_t __ret; \
int16x8_t __s0 = __p0; \
- __ret = (int16x8_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 33); \
+ __ret = (int16x8_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 33); \
__ret; \
})
#else
-#define vshrq_n_s16(__p0, __p1) __extension__ ({ \
+#define vrshrq_n_s16(__p0, __p1) __extension__ ({ \
int16x8_t __ret; \
int16x8_t __s0 = __p0; \
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 33); \
+ __ret = (int16x8_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 33); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshr_n_u8(__p0, __p1) __extension__ ({ \
+#define vrshr_n_u8(__p0, __p1) __extension__ ({ \
uint8x8_t __ret; \
uint8x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 16); \
+ __ret = (uint8x8_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 16); \
__ret; \
})
#else
-#define vshr_n_u8(__p0, __p1) __extension__ ({ \
+#define vrshr_n_u8(__p0, __p1) __extension__ ({ \
uint8x8_t __ret; \
uint8x8_t __s0 = __p0; \
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_vshr_n_v((int8x8_t)__rev0, __p1, 16); \
+ __ret = (uint8x8_t) __builtin_neon_vrshr_n_v((int8x8_t)__rev0, __p1, 16); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshr_n_u32(__p0, __p1) __extension__ ({ \
+#define vrshr_n_u32(__p0, __p1) __extension__ ({ \
uint32x2_t __ret; \
uint32x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 18); \
+ __ret = (uint32x2_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 18); \
__ret; \
})
#else
-#define vshr_n_u32(__p0, __p1) __extension__ ({ \
+#define vrshr_n_u32(__p0, __p1) __extension__ ({ \
uint32x2_t __ret; \
uint32x2_t __s0 = __p0; \
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vshr_n_v((int8x8_t)__rev0, __p1, 18); \
+ __ret = (uint32x2_t) __builtin_neon_vrshr_n_v((int8x8_t)__rev0, __p1, 18); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
-#define vshr_n_u64(__p0, __p1) __extension__ ({ \
+#define vrshr_n_u64(__p0, __p1) __extension__ ({ \
uint64x1_t __ret; \
uint64x1_t __s0 = __p0; \
- __ret = (uint64x1_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 19); \
+ __ret = (uint64x1_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 19); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vshr_n_u16(__p0, __p1) __extension__ ({ \
+#define vrshr_n_u16(__p0, __p1) __extension__ ({ \
uint16x4_t __ret; \
uint16x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 17); \
+ __ret = (uint16x4_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 17); \
__ret; \
})
#else
-#define vshr_n_u16(__p0, __p1) __extension__ ({ \
+#define vrshr_n_u16(__p0, __p1) __extension__ ({ \
uint16x4_t __ret; \
uint16x4_t __s0 = __p0; \
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vshr_n_v((int8x8_t)__rev0, __p1, 17); \
+ __ret = (uint16x4_t) __builtin_neon_vrshr_n_v((int8x8_t)__rev0, __p1, 17); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshr_n_s8(__p0, __p1) __extension__ ({ \
+#define vrshr_n_s8(__p0, __p1) __extension__ ({ \
int8x8_t __ret; \
int8x8_t __s0 = __p0; \
- __ret = (int8x8_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 0); \
__ret; \
})
#else
-#define vshr_n_s8(__p0, __p1) __extension__ ({ \
+#define vrshr_n_s8(__p0, __p1) __extension__ ({ \
int8x8_t __ret; \
int8x8_t __s0 = __p0; \
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x8_t) __builtin_neon_vshr_n_v((int8x8_t)__rev0, __p1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vrshr_n_v((int8x8_t)__rev0, __p1, 0); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshr_n_s32(__p0, __p1) __extension__ ({ \
+#define vrshr_n_s32(__p0, __p1) __extension__ ({ \
int32x2_t __ret; \
int32x2_t __s0 = __p0; \
- __ret = (int32x2_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 2); \
+ __ret = (int32x2_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 2); \
__ret; \
})
#else
-#define vshr_n_s32(__p0, __p1) __extension__ ({ \
+#define vrshr_n_s32(__p0, __p1) __extension__ ({ \
int32x2_t __ret; \
int32x2_t __s0 = __p0; \
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vshr_n_v((int8x8_t)__rev0, __p1, 2); \
+ __ret = (int32x2_t) __builtin_neon_vrshr_n_v((int8x8_t)__rev0, __p1, 2); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
-#define vshr_n_s64(__p0, __p1) __extension__ ({ \
+#define vrshr_n_s64(__p0, __p1) __extension__ ({ \
int64x1_t __ret; \
int64x1_t __s0 = __p0; \
- __ret = (int64x1_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 3); \
+ __ret = (int64x1_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 3); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vshr_n_s16(__p0, __p1) __extension__ ({ \
+#define vrshr_n_s16(__p0, __p1) __extension__ ({ \
int16x4_t __ret; \
int16x4_t __s0 = __p0; \
- __ret = (int16x4_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 1); \
+ __ret = (int16x4_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 1); \
__ret; \
})
#else
-#define vshr_n_s16(__p0, __p1) __extension__ ({ \
+#define vrshr_n_s16(__p0, __p1) __extension__ ({ \
int16x4_t __ret; \
int16x4_t __s0 = __p0; \
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vshr_n_v((int8x8_t)__rev0, __p1, 1); \
+ __ret = (int16x4_t) __builtin_neon_vrshr_n_v((int8x8_t)__rev0, __p1, 1); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshrn_n_u32(__p0, __p1) __extension__ ({ \
+#define vrshrn_n_u32(__p0, __p1) __extension__ ({ \
uint16x4_t __ret; \
uint32x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 17); \
+ __ret = (uint16x4_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 17); \
__ret; \
})
#else
-#define vshrn_n_u32(__p0, __p1) __extension__ ({ \
+#define vrshrn_n_u32(__p0, __p1) __extension__ ({ \
uint16x4_t __ret; \
uint32x4_t __s0 = __p0; \
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vshrn_n_v((int8x16_t)__rev0, __p1, 17); \
+ __ret = (uint16x4_t) __builtin_neon_vrshrn_n_v((int8x16_t)__rev0, __p1, 17); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
-#define __noswap_vshrn_n_u32(__p0, __p1) __extension__ ({ \
+#define __noswap_vrshrn_n_u32(__p0, __p1) __extension__ ({ \
uint16x4_t __ret; \
uint32x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 17); \
+ __ret = (uint16x4_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 17); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshrn_n_u64(__p0, __p1) __extension__ ({ \
+#define vrshrn_n_u64(__p0, __p1) __extension__ ({ \
uint32x2_t __ret; \
uint64x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 18); \
+ __ret = (uint32x2_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 18); \
__ret; \
})
#else
-#define vshrn_n_u64(__p0, __p1) __extension__ ({ \
+#define vrshrn_n_u64(__p0, __p1) __extension__ ({ \
uint32x2_t __ret; \
uint64x2_t __s0 = __p0; \
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vshrn_n_v((int8x16_t)__rev0, __p1, 18); \
+ __ret = (uint32x2_t) __builtin_neon_vrshrn_n_v((int8x16_t)__rev0, __p1, 18); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
-#define __noswap_vshrn_n_u64(__p0, __p1) __extension__ ({ \
+#define __noswap_vrshrn_n_u64(__p0, __p1) __extension__ ({ \
uint32x2_t __ret; \
uint64x2_t __s0 = __p0; \
- __ret = (uint32x2_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 18); \
+ __ret = (uint32x2_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 18); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshrn_n_u16(__p0, __p1) __extension__ ({ \
+#define vrshrn_n_u16(__p0, __p1) __extension__ ({ \
uint8x8_t __ret; \
uint16x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 16); \
+ __ret = (uint8x8_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 16); \
__ret; \
})
#else
-#define vshrn_n_u16(__p0, __p1) __extension__ ({ \
+#define vrshrn_n_u16(__p0, __p1) __extension__ ({ \
uint8x8_t __ret; \
uint16x8_t __s0 = __p0; \
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_vshrn_n_v((int8x16_t)__rev0, __p1, 16); \
+ __ret = (uint8x8_t) __builtin_neon_vrshrn_n_v((int8x16_t)__rev0, __p1, 16); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
-#define __noswap_vshrn_n_u16(__p0, __p1) __extension__ ({ \
+#define __noswap_vrshrn_n_u16(__p0, __p1) __extension__ ({ \
uint8x8_t __ret; \
uint16x8_t __s0 = __p0; \
- __ret = (uint8x8_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 16); \
+ __ret = (uint8x8_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 16); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshrn_n_s32(__p0, __p1) __extension__ ({ \
+#define vrshrn_n_s32(__p0, __p1) __extension__ ({ \
int16x4_t __ret; \
int32x4_t __s0 = __p0; \
- __ret = (int16x4_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 1); \
+ __ret = (int16x4_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 1); \
__ret; \
})
#else
-#define vshrn_n_s32(__p0, __p1) __extension__ ({ \
+#define vrshrn_n_s32(__p0, __p1) __extension__ ({ \
int16x4_t __ret; \
int32x4_t __s0 = __p0; \
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vshrn_n_v((int8x16_t)__rev0, __p1, 1); \
+ __ret = (int16x4_t) __builtin_neon_vrshrn_n_v((int8x16_t)__rev0, __p1, 1); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
-#define __noswap_vshrn_n_s32(__p0, __p1) __extension__ ({ \
+#define __noswap_vrshrn_n_s32(__p0, __p1) __extension__ ({ \
int16x4_t __ret; \
int32x4_t __s0 = __p0; \
- __ret = (int16x4_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 1); \
+ __ret = (int16x4_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshrn_n_s64(__p0, __p1) __extension__ ({ \
+#define vrshrn_n_s64(__p0, __p1) __extension__ ({ \
int32x2_t __ret; \
int64x2_t __s0 = __p0; \
- __ret = (int32x2_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 2); \
+ __ret = (int32x2_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 2); \
__ret; \
})
#else
-#define vshrn_n_s64(__p0, __p1) __extension__ ({ \
+#define vrshrn_n_s64(__p0, __p1) __extension__ ({ \
int32x2_t __ret; \
int64x2_t __s0 = __p0; \
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vshrn_n_v((int8x16_t)__rev0, __p1, 2); \
+ __ret = (int32x2_t) __builtin_neon_vrshrn_n_v((int8x16_t)__rev0, __p1, 2); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
-#define __noswap_vshrn_n_s64(__p0, __p1) __extension__ ({ \
+#define __noswap_vrshrn_n_s64(__p0, __p1) __extension__ ({ \
int32x2_t __ret; \
int64x2_t __s0 = __p0; \
- __ret = (int32x2_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 2); \
+ __ret = (int32x2_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 2); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vshrn_n_s16(__p0, __p1) __extension__ ({ \
+#define vrshrn_n_s16(__p0, __p1) __extension__ ({ \
int8x8_t __ret; \
int16x8_t __s0 = __p0; \
- __ret = (int8x8_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 0); \
__ret; \
})
#else
-#define vshrn_n_s16(__p0, __p1) __extension__ ({ \
+#define vrshrn_n_s16(__p0, __p1) __extension__ ({ \
int8x8_t __ret; \
int16x8_t __s0 = __p0; \
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x8_t) __builtin_neon_vshrn_n_v((int8x16_t)__rev0, __p1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vrshrn_n_v((int8x16_t)__rev0, __p1, 0); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
-#define __noswap_vshrn_n_s16(__p0, __p1) __extension__ ({ \
+#define __noswap_vrshrn_n_s16(__p0, __p1) __extension__ ({ \
int8x8_t __ret; \
int16x8_t __s0 = __p0; \
- __ret = (int8x8_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsli_n_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8_t __ret; \
- poly8x8_t __s0 = __p0; \
- poly8x8_t __s1 = __p1; \
- __ret = (poly8x8_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 4); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vrsqrteq_u32(uint32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vrsqrteq_v((int8x16_t)__p0, 50);
+ return __ret;
+}
#else
-#define vsli_n_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8_t __ret; \
- poly8x8_t __s0 = __p0; \
- poly8x8_t __s1 = __p1; \
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly8x8_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 4); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vrsqrteq_u32(uint32x4_t __p0) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vrsqrteq_v((int8x16_t)__rev0, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsli_n_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4_t __ret; \
- poly16x4_t __s0 = __p0; \
- poly16x4_t __s1 = __p1; \
- __ret = (poly16x4_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 5); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vrsqrteq_f32(float32x4_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vrsqrteq_v((int8x16_t)__p0, 41);
+ return __ret;
+}
#else
-#define vsli_n_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4_t __ret; \
- poly16x4_t __s0 = __p0; \
- poly16x4_t __s1 = __p1; \
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (poly16x4_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 5); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vrsqrteq_f32(float32x4_t __p0) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vrsqrteq_v((int8x16_t)__rev0, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsliq_n_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16_t __ret; \
- poly8x16_t __s0 = __p0; \
- poly8x16_t __s1 = __p1; \
- __ret = (poly8x16_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 36); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vrsqrte_u32(uint32x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vrsqrte_v((int8x8_t)__p0, 18);
+ return __ret;
+}
#else
-#define vsliq_n_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16_t __ret; \
- poly8x16_t __s0 = __p0; \
- poly8x16_t __s1 = __p1; \
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly8x16_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 36); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vrsqrte_u32(uint32x2_t __p0) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vrsqrte_v((int8x8_t)__rev0, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsliq_n_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8_t __ret; \
- poly16x8_t __s0 = __p0; \
- poly16x8_t __s1 = __p1; \
- __ret = (poly16x8_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 37); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vrsqrte_f32(float32x2_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vrsqrte_v((int8x8_t)__p0, 9);
+ return __ret;
+}
#else
-#define vsliq_n_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8_t __ret; \
- poly16x8_t __s0 = __p0; \
- poly16x8_t __s1 = __p1; \
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly16x8_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 37); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vrsqrte_f32(float32x2_t __p0) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vrsqrte_v((int8x8_t)__rev0, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsliq_n_u8(__p0, __p1, __p2) __extension__ ({ \
+__ai __attribute__((target("neon"))) float32x4_t vrsqrtsq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vrsqrtsq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vrsqrtsq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vrsqrtsq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vrsqrts_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vrsqrts_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vrsqrts_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vrsqrts_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrsraq_n_u8(__p0, __p1, __p2) __extension__ ({ \
uint8x16_t __ret; \
uint8x16_t __s0 = __p0; \
uint8x16_t __s1 = __p1; \
- __ret = (uint8x16_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 48); \
+ __ret = (uint8x16_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 48); \
__ret; \
})
#else
-#define vsliq_n_u8(__p0, __p1, __p2) __extension__ ({ \
+#define vrsraq_n_u8(__p0, __p1, __p2) __extension__ ({ \
uint8x16_t __ret; \
uint8x16_t __s0 = __p0; \
uint8x16_t __s1 = __p1; \
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x16_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 48); \
+ __ret = (uint8x16_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 48); \
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsliq_n_u32(__p0, __p1, __p2) __extension__ ({ \
+#define vrsraq_n_u32(__p0, __p1, __p2) __extension__ ({ \
uint32x4_t __ret; \
uint32x4_t __s0 = __p0; \
uint32x4_t __s1 = __p1; \
- __ret = (uint32x4_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 50); \
+ __ret = (uint32x4_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 50); \
__ret; \
})
#else
-#define vsliq_n_u32(__p0, __p1, __p2) __extension__ ({ \
+#define vrsraq_n_u32(__p0, __p1, __p2) __extension__ ({ \
uint32x4_t __ret; \
uint32x4_t __s0 = __p0; \
uint32x4_t __s1 = __p1; \
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (uint32x4_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 50); \
+ __ret = (uint32x4_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 50); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsliq_n_u64(__p0, __p1, __p2) __extension__ ({ \
+#define vrsraq_n_u64(__p0, __p1, __p2) __extension__ ({ \
uint64x2_t __ret; \
uint64x2_t __s0 = __p0; \
uint64x2_t __s1 = __p1; \
- __ret = (uint64x2_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 51); \
+ __ret = (uint64x2_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 51); \
__ret; \
})
#else
-#define vsliq_n_u64(__p0, __p1, __p2) __extension__ ({ \
+#define vrsraq_n_u64(__p0, __p1, __p2) __extension__ ({ \
uint64x2_t __ret; \
uint64x2_t __s0 = __p0; \
uint64x2_t __s1 = __p1; \
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (uint64x2_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 51); \
+ __ret = (uint64x2_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 51); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsliq_n_u16(__p0, __p1, __p2) __extension__ ({ \
+#define vrsraq_n_u16(__p0, __p1, __p2) __extension__ ({ \
uint16x8_t __ret; \
uint16x8_t __s0 = __p0; \
uint16x8_t __s1 = __p1; \
- __ret = (uint16x8_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 49); \
+ __ret = (uint16x8_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 49); \
__ret; \
})
#else
-#define vsliq_n_u16(__p0, __p1, __p2) __extension__ ({ \
+#define vrsraq_n_u16(__p0, __p1, __p2) __extension__ ({ \
uint16x8_t __ret; \
uint16x8_t __s0 = __p0; \
uint16x8_t __s1 = __p1; \
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint16x8_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 49); \
+ __ret = (uint16x8_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 49); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsliq_n_s8(__p0, __p1, __p2) __extension__ ({ \
+#define vrsraq_n_s8(__p0, __p1, __p2) __extension__ ({ \
int8x16_t __ret; \
int8x16_t __s0 = __p0; \
int8x16_t __s1 = __p1; \
- __ret = (int8x16_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 32); \
+ __ret = (int8x16_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 32); \
__ret; \
})
#else
-#define vsliq_n_s8(__p0, __p1, __p2) __extension__ ({ \
+#define vrsraq_n_s8(__p0, __p1, __p2) __extension__ ({ \
int8x16_t __ret; \
int8x16_t __s0 = __p0; \
int8x16_t __s1 = __p1; \
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x16_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 32); \
+ __ret = (int8x16_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 32); \
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsliq_n_s32(__p0, __p1, __p2) __extension__ ({ \
+#define vrsraq_n_s32(__p0, __p1, __p2) __extension__ ({ \
int32x4_t __ret; \
int32x4_t __s0 = __p0; \
int32x4_t __s1 = __p1; \
- __ret = (int32x4_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
+ __ret = (int32x4_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
__ret; \
})
#else
-#define vsliq_n_s32(__p0, __p1, __p2) __extension__ ({ \
+#define vrsraq_n_s32(__p0, __p1, __p2) __extension__ ({ \
int32x4_t __ret; \
int32x4_t __s0 = __p0; \
int32x4_t __s1 = __p1; \
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
+ __ret = (int32x4_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsliq_n_s64(__p0, __p1, __p2) __extension__ ({ \
+#define vrsraq_n_s64(__p0, __p1, __p2) __extension__ ({ \
int64x2_t __ret; \
int64x2_t __s0 = __p0; \
int64x2_t __s1 = __p1; \
- __ret = (int64x2_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 35); \
+ __ret = (int64x2_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 35); \
__ret; \
})
#else
-#define vsliq_n_s64(__p0, __p1, __p2) __extension__ ({ \
+#define vrsraq_n_s64(__p0, __p1, __p2) __extension__ ({ \
int64x2_t __ret; \
int64x2_t __s0 = __p0; \
int64x2_t __s1 = __p1; \
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
int64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (int64x2_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 35); \
+ __ret = (int64x2_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 35); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsliq_n_s16(__p0, __p1, __p2) __extension__ ({ \
+#define vrsraq_n_s16(__p0, __p1, __p2) __extension__ ({ \
int16x8_t __ret; \
int16x8_t __s0 = __p0; \
int16x8_t __s1 = __p1; \
- __ret = (int16x8_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
+ __ret = (int16x8_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
__ret; \
})
#else
-#define vsliq_n_s16(__p0, __p1, __p2) __extension__ ({ \
+#define vrsraq_n_s16(__p0, __p1, __p2) __extension__ ({ \
int16x8_t __ret; \
int16x8_t __s0 = __p0; \
int16x8_t __s1 = __p1; \
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
+ __ret = (int16x8_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsli_n_u8(__p0, __p1, __p2) __extension__ ({ \
+#define vrsra_n_u8(__p0, __p1, __p2) __extension__ ({ \
uint8x8_t __ret; \
uint8x8_t __s0 = __p0; \
uint8x8_t __s1 = __p1; \
- __ret = (uint8x8_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 16); \
+ __ret = (uint8x8_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 16); \
__ret; \
})
#else
-#define vsli_n_u8(__p0, __p1, __p2) __extension__ ({ \
+#define vrsra_n_u8(__p0, __p1, __p2) __extension__ ({ \
uint8x8_t __ret; \
uint8x8_t __s0 = __p0; \
uint8x8_t __s1 = __p1; \
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 16); \
+ __ret = (uint8x8_t) __builtin_neon_vrsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 16); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsli_n_u32(__p0, __p1, __p2) __extension__ ({ \
+#define vrsra_n_u32(__p0, __p1, __p2) __extension__ ({ \
uint32x2_t __ret; \
uint32x2_t __s0 = __p0; \
uint32x2_t __s1 = __p1; \
- __ret = (uint32x2_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 18); \
+ __ret = (uint32x2_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 18); \
__ret; \
})
#else
-#define vsli_n_u32(__p0, __p1, __p2) __extension__ ({ \
+#define vrsra_n_u32(__p0, __p1, __p2) __extension__ ({ \
uint32x2_t __ret; \
uint32x2_t __s0 = __p0; \
uint32x2_t __s1 = __p1; \
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 18); \
+ __ret = (uint32x2_t) __builtin_neon_vrsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 18); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
-#define vsli_n_u64(__p0, __p1, __p2) __extension__ ({ \
+#define vrsra_n_u64(__p0, __p1, __p2) __extension__ ({ \
uint64x1_t __ret; \
uint64x1_t __s0 = __p0; \
uint64x1_t __s1 = __p1; \
- __ret = (uint64x1_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 19); \
+ __ret = (uint64x1_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 19); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vsli_n_u16(__p0, __p1, __p2) __extension__ ({ \
+#define vrsra_n_u16(__p0, __p1, __p2) __extension__ ({ \
uint16x4_t __ret; \
uint16x4_t __s0 = __p0; \
uint16x4_t __s1 = __p1; \
- __ret = (uint16x4_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 17); \
+ __ret = (uint16x4_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 17); \
__ret; \
})
#else
-#define vsli_n_u16(__p0, __p1, __p2) __extension__ ({ \
+#define vrsra_n_u16(__p0, __p1, __p2) __extension__ ({ \
uint16x4_t __ret; \
uint16x4_t __s0 = __p0; \
uint16x4_t __s1 = __p1; \
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 17); \
+ __ret = (uint16x4_t) __builtin_neon_vrsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 17); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsli_n_s8(__p0, __p1, __p2) __extension__ ({ \
+#define vrsra_n_s8(__p0, __p1, __p2) __extension__ ({ \
int8x8_t __ret; \
int8x8_t __s0 = __p0; \
int8x8_t __s1 = __p1; \
- __ret = (int8x8_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 0); \
+ __ret = (int8x8_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 0); \
__ret; \
})
#else
-#define vsli_n_s8(__p0, __p1, __p2) __extension__ ({ \
+#define vrsra_n_s8(__p0, __p1, __p2) __extension__ ({ \
int8x8_t __ret; \
int8x8_t __s0 = __p0; \
int8x8_t __s1 = __p1; \
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x8_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 0); \
+ __ret = (int8x8_t) __builtin_neon_vrsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 0); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsli_n_s32(__p0, __p1, __p2) __extension__ ({ \
+#define vrsra_n_s32(__p0, __p1, __p2) __extension__ ({ \
int32x2_t __ret; \
int32x2_t __s0 = __p0; \
int32x2_t __s1 = __p1; \
- __ret = (int32x2_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
+ __ret = (int32x2_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
__ret; \
})
#else
-#define vsli_n_s32(__p0, __p1, __p2) __extension__ ({ \
+#define vrsra_n_s32(__p0, __p1, __p2) __extension__ ({ \
int32x2_t __ret; \
int32x2_t __s0 = __p0; \
int32x2_t __s1 = __p1; \
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+ __ret = (int32x2_t) __builtin_neon_vrsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
-#define vsli_n_s64(__p0, __p1, __p2) __extension__ ({ \
+#define vrsra_n_s64(__p0, __p1, __p2) __extension__ ({ \
int64x1_t __ret; \
int64x1_t __s0 = __p0; \
int64x1_t __s1 = __p1; \
- __ret = (int64x1_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 3); \
+ __ret = (int64x1_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 3); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vsli_n_s16(__p0, __p1, __p2) __extension__ ({ \
+#define vrsra_n_s16(__p0, __p1, __p2) __extension__ ({ \
int16x4_t __ret; \
int16x4_t __s0 = __p0; \
int16x4_t __s1 = __p1; \
- __ret = (int16x4_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
+ __ret = (int16x4_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
__ret; \
})
#else
-#define vsli_n_s16(__p0, __p1, __p2) __extension__ ({ \
+#define vrsra_n_s16(__p0, __p1, __p2) __extension__ ({ \
int16x4_t __ret; \
int16x4_t __s0 = __p0; \
int16x4_t __s1 = __p1; \
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+ __ret = (int16x4_t) __builtin_neon_vrsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsraq_n_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16_t __ret; \
- uint8x16_t __s0 = __p0; \
- uint8x16_t __s1 = __p1; \
- __ret = (uint8x16_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 48); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vrsubhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
+ return __ret;
+}
#else
-#define vsraq_n_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16_t __ret; \
- uint8x16_t __s0 = __p0; \
- uint8x16_t __s1 = __p1; \
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x16_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 48); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vrsubhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint16x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vrsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t __noswap_vrsubhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsraq_n_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- uint32x4_t __s1 = __p1; \
- __ret = (uint32x4_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 50); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vrsubhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
+ return __ret;
+}
#else
-#define vsraq_n_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4_t __ret; \
- uint32x4_t __s0 = __p0; \
- uint32x4_t __s1 = __p1; \
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (uint32x4_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 50); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vrsubhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint32x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vrsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t __noswap_vrsubhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsraq_n_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- uint64x2_t __s1 = __p1; \
- __ret = (uint64x2_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 51); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vrsubhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
+ return __ret;
+}
#else
-#define vsraq_n_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- uint64x2_t __s1 = __p1; \
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (uint64x2_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 51); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vrsubhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint8x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vrsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t __noswap_vrsubhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsraq_n_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- uint16x8_t __s1 = __p1; \
- __ret = (uint16x8_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 49); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vrsubhn_s32(int32x4_t __p0, int32x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
+ return __ret;
+}
#else
-#define vsraq_n_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- uint16x8_t __s1 = __p1; \
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint16x8_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 49); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vrsubhn_s32(int32x4_t __p0, int32x4_t __p1) {
+ int16x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vrsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vrsubhn_s32(int32x4_t __p0, int32x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsraq_n_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16_t __ret; \
- int8x16_t __s0 = __p0; \
- int8x16_t __s1 = __p1; \
- __ret = (int8x16_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 32); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vrsubhn_s64(int64x2_t __p0, int64x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
+ return __ret;
+}
#else
-#define vsraq_n_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16_t __ret; \
- int8x16_t __s0 = __p0; \
- int8x16_t __s1 = __p1; \
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x16_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 32); \
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vrsubhn_s64(int64x2_t __p0, int64x2_t __p1) {
+ int32x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vrsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vrsubhn_s64(int64x2_t __p0, int64x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsraq_n_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __s1 = __p1; \
- __ret = (int32x4_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
- __ret; \
-})
-#else
-#define vsraq_n_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __s1 = __p1; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vsraq_n_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2_t __ret; \
- int64x2_t __s0 = __p0; \
- int64x2_t __s1 = __p1; \
- __ret = (int64x2_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 35); \
- __ret; \
-})
-#else
-#define vsraq_n_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2_t __ret; \
- int64x2_t __s0 = __p0; \
- int64x2_t __s1 = __p1; \
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (int64x2_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 35); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vsraq_n_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __s1 = __p1; \
- __ret = (int16x8_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
- __ret; \
-})
-#else
-#define vsraq_n_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __s1 = __p1; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vsra_n_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8_t __ret; \
- uint8x8_t __s0 = __p0; \
- uint8x8_t __s1 = __p1; \
- __ret = (uint8x8_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 16); \
- __ret; \
-})
-#else
-#define vsra_n_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8_t __ret; \
- uint8x8_t __s0 = __p0; \
- uint8x8_t __s1 = __p1; \
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_vsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 16); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vsra_n_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2_t __ret; \
- uint32x2_t __s0 = __p0; \
- uint32x2_t __s1 = __p1; \
- __ret = (uint32x2_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 18); \
- __ret; \
-})
-#else
-#define vsra_n_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2_t __ret; \
- uint32x2_t __s0 = __p0; \
- uint32x2_t __s1 = __p1; \
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 18); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#endif
-
-#define vsra_n_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x1_t __ret; \
- uint64x1_t __s0 = __p0; \
- uint64x1_t __s1 = __p1; \
- __ret = (uint64x1_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 19); \
- __ret; \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vsra_n_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4_t __ret; \
- uint16x4_t __s0 = __p0; \
- uint16x4_t __s1 = __p1; \
- __ret = (uint16x4_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 17); \
- __ret; \
-})
-#else
-#define vsra_n_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4_t __ret; \
- uint16x4_t __s0 = __p0; \
- uint16x4_t __s1 = __p1; \
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 17); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vsra_n_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8_t __ret; \
- int8x8_t __s0 = __p0; \
- int8x8_t __s1 = __p1; \
- __ret = (int8x8_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 0); \
- __ret; \
-})
-#else
-#define vsra_n_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8_t __ret; \
- int8x8_t __s0 = __p0; \
- int8x8_t __s1 = __p1; \
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x8_t) __builtin_neon_vsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 0); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vsra_n_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __s1 = __p1; \
- __ret = (int32x2_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
- __ret; \
-})
-#else
-#define vsra_n_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __s1 = __p1; \
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#endif
-
-#define vsra_n_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x1_t __ret; \
- int64x1_t __s0 = __p0; \
- int64x1_t __s1 = __p1; \
- __ret = (int64x1_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 3); \
- __ret; \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vsra_n_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __s1 = __p1; \
- __ret = (int16x4_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vrsubhn_s16(int16x8_t __p0, int16x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
+ return __ret;
+}
#else
-#define vsra_n_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __s1 = __p1; \
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vrsubhn_s16(int16x8_t __p0, int16x8_t __p1) {
+ int8x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vrsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t __noswap_vrsubhn_s16(int16x8_t __p0, int16x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsri_n_p8(__p0, __p1, __p2) __extension__ ({ \
+#define vset_lane_p8(__p0, __p1, __p2) __extension__ ({ \
poly8x8_t __ret; \
- poly8x8_t __s0 = __p0; \
+ poly8_t __s0 = __p0; \
poly8x8_t __s1 = __p1; \
- __ret = (poly8x8_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 4); \
+ __ret = (poly8x8_t) __builtin_neon_vset_lane_i8(__s0, (poly8x8_t)__s1, __p2); \
__ret; \
})
#else
-#define vsri_n_p8(__p0, __p1, __p2) __extension__ ({ \
+#define vset_lane_p8(__p0, __p1, __p2) __extension__ ({ \
poly8x8_t __ret; \
- poly8x8_t __s0 = __p0; \
+ poly8_t __s0 = __p0; \
poly8x8_t __s1 = __p1; \
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly8x8_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 4); \
+ __ret = (poly8x8_t) __builtin_neon_vset_lane_i8(__s0, (poly8x8_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
+#define __noswap_vset_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8_t __ret; \
+ poly8_t __s0 = __p0; \
+ poly8x8_t __s1 = __p1; \
+ __ret = (poly8x8_t) __builtin_neon_vset_lane_i8(__s0, (poly8x8_t)__s1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsri_n_p16(__p0, __p1, __p2) __extension__ ({ \
+#define vset_lane_p16(__p0, __p1, __p2) __extension__ ({ \
poly16x4_t __ret; \
- poly16x4_t __s0 = __p0; \
+ poly16_t __s0 = __p0; \
poly16x4_t __s1 = __p1; \
- __ret = (poly16x4_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 5); \
+ __ret = (poly16x4_t) __builtin_neon_vset_lane_i16(__s0, (poly16x4_t)__s1, __p2); \
__ret; \
})
#else
-#define vsri_n_p16(__p0, __p1, __p2) __extension__ ({ \
+#define vset_lane_p16(__p0, __p1, __p2) __extension__ ({ \
poly16x4_t __ret; \
- poly16x4_t __s0 = __p0; \
+ poly16_t __s0 = __p0; \
poly16x4_t __s1 = __p1; \
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (poly16x4_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 5); \
+ __ret = (poly16x4_t) __builtin_neon_vset_lane_i16(__s0, (poly16x4_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
+#define __noswap_vset_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4_t __ret; \
+ poly16_t __s0 = __p0; \
+ poly16x4_t __s1 = __p1; \
+ __ret = (poly16x4_t) __builtin_neon_vset_lane_i16(__s0, (poly16x4_t)__s1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsriq_n_p8(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_p8(__p0, __p1, __p2) __extension__ ({ \
poly8x16_t __ret; \
- poly8x16_t __s0 = __p0; \
+ poly8_t __s0 = __p0; \
poly8x16_t __s1 = __p1; \
- __ret = (poly8x16_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 36); \
+ __ret = (poly8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (poly8x16_t)__s1, __p2); \
__ret; \
})
#else
-#define vsriq_n_p8(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_p8(__p0, __p1, __p2) __extension__ ({ \
poly8x16_t __ret; \
- poly8x16_t __s0 = __p0; \
+ poly8_t __s0 = __p0; \
poly8x16_t __s1 = __p1; \
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly8x16_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 36); \
+ __ret = (poly8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (poly8x16_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
+#define __noswap_vsetq_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16_t __ret; \
+ poly8_t __s0 = __p0; \
+ poly8x16_t __s1 = __p1; \
+ __ret = (poly8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (poly8x16_t)__s1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsriq_n_p16(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_p16(__p0, __p1, __p2) __extension__ ({ \
poly16x8_t __ret; \
- poly16x8_t __s0 = __p0; \
+ poly16_t __s0 = __p0; \
poly16x8_t __s1 = __p1; \
- __ret = (poly16x8_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 37); \
+ __ret = (poly16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (poly16x8_t)__s1, __p2); \
__ret; \
})
#else
-#define vsriq_n_p16(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_p16(__p0, __p1, __p2) __extension__ ({ \
poly16x8_t __ret; \
- poly16x8_t __s0 = __p0; \
+ poly16_t __s0 = __p0; \
poly16x8_t __s1 = __p1; \
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly16x8_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 37); \
+ __ret = (poly16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (poly16x8_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
+#define __noswap_vsetq_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8_t __ret; \
+ poly16_t __s0 = __p0; \
+ poly16x8_t __s1 = __p1; \
+ __ret = (poly16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (poly16x8_t)__s1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsriq_n_u8(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_u8(__p0, __p1, __p2) __extension__ ({ \
uint8x16_t __ret; \
- uint8x16_t __s0 = __p0; \
+ uint8_t __s0 = __p0; \
uint8x16_t __s1 = __p1; \
- __ret = (uint8x16_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 48); \
+ __ret = (uint8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (int8x16_t)__s1, __p2); \
__ret; \
})
#else
-#define vsriq_n_u8(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_u8(__p0, __p1, __p2) __extension__ ({ \
uint8x16_t __ret; \
- uint8x16_t __s0 = __p0; \
+ uint8_t __s0 = __p0; \
uint8x16_t __s1 = __p1; \
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x16_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 48); \
+ __ret = (uint8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (int8x16_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
+#define __noswap_vsetq_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8_t __s0 = __p0; \
+ uint8x16_t __s1 = __p1; \
+ __ret = (uint8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (int8x16_t)__s1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsriq_n_u32(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_u32(__p0, __p1, __p2) __extension__ ({ \
uint32x4_t __ret; \
- uint32x4_t __s0 = __p0; \
+ uint32_t __s0 = __p0; \
uint32x4_t __s1 = __p1; \
- __ret = (uint32x4_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 50); \
+ __ret = (uint32x4_t) __builtin_neon_vsetq_lane_i32(__s0, (int32x4_t)__s1, __p2); \
__ret; \
})
#else
-#define vsriq_n_u32(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_u32(__p0, __p1, __p2) __extension__ ({ \
uint32x4_t __ret; \
- uint32x4_t __s0 = __p0; \
+ uint32_t __s0 = __p0; \
uint32x4_t __s1 = __p1; \
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (uint32x4_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 50); \
+ __ret = (uint32x4_t) __builtin_neon_vsetq_lane_i32(__s0, (int32x4_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
+#define __noswap_vsetq_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32_t __s0 = __p0; \
+ uint32x4_t __s1 = __p1; \
+ __ret = (uint32x4_t) __builtin_neon_vsetq_lane_i32(__s0, (int32x4_t)__s1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsriq_n_u64(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_u64(__p0, __p1, __p2) __extension__ ({ \
uint64x2_t __ret; \
- uint64x2_t __s0 = __p0; \
+ uint64_t __s0 = __p0; \
uint64x2_t __s1 = __p1; \
- __ret = (uint64x2_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 51); \
+ __ret = (uint64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (int64x2_t)__s1, __p2); \
__ret; \
})
#else
-#define vsriq_n_u64(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_u64(__p0, __p1, __p2) __extension__ ({ \
uint64x2_t __ret; \
- uint64x2_t __s0 = __p0; \
+ uint64_t __s0 = __p0; \
uint64x2_t __s1 = __p1; \
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (uint64x2_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 51); \
+ __ret = (uint64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (int64x2_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
+#define __noswap_vsetq_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64_t __s0 = __p0; \
+ uint64x2_t __s1 = __p1; \
+ __ret = (uint64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (int64x2_t)__s1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsriq_n_u16(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_u16(__p0, __p1, __p2) __extension__ ({ \
uint16x8_t __ret; \
- uint16x8_t __s0 = __p0; \
+ uint16_t __s0 = __p0; \
uint16x8_t __s1 = __p1; \
- __ret = (uint16x8_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 49); \
+ __ret = (uint16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (int16x8_t)__s1, __p2); \
__ret; \
})
#else
-#define vsriq_n_u16(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_u16(__p0, __p1, __p2) __extension__ ({ \
uint16x8_t __ret; \
- uint16x8_t __s0 = __p0; \
+ uint16_t __s0 = __p0; \
uint16x8_t __s1 = __p1; \
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint16x8_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 49); \
+ __ret = (uint16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (int16x8_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
+#define __noswap_vsetq_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16_t __s0 = __p0; \
+ uint16x8_t __s1 = __p1; \
+ __ret = (uint16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (int16x8_t)__s1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsriq_n_s8(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_s8(__p0, __p1, __p2) __extension__ ({ \
int8x16_t __ret; \
- int8x16_t __s0 = __p0; \
+ int8_t __s0 = __p0; \
int8x16_t __s1 = __p1; \
- __ret = (int8x16_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 32); \
+ __ret = (int8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (int8x16_t)__s1, __p2); \
__ret; \
})
#else
-#define vsriq_n_s8(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_s8(__p0, __p1, __p2) __extension__ ({ \
int8x16_t __ret; \
- int8x16_t __s0 = __p0; \
+ int8_t __s0 = __p0; \
int8x16_t __s1 = __p1; \
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x16_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 32); \
+ __ret = (int8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (int8x16_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
+#define __noswap_vsetq_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16_t __ret; \
+ int8_t __s0 = __p0; \
+ int8x16_t __s1 = __p1; \
+ __ret = (int8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (int8x16_t)__s1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsriq_n_s32(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4_t __ret; \
+ float32_t __s0 = __p0; \
+ float32x4_t __s1 = __p1; \
+ __ret = (float32x4_t) __builtin_neon_vsetq_lane_f32(__s0, (float32x4_t)__s1, __p2); \
+ __ret; \
+})
+#else
+#define vsetq_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4_t __ret; \
+ float32_t __s0 = __p0; \
+ float32x4_t __s1 = __p1; \
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (float32x4_t) __builtin_neon_vsetq_lane_f32(__s0, (float32x4_t)__rev1, __p2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vsetq_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4_t __ret; \
+ float32_t __s0 = __p0; \
+ float32x4_t __s1 = __p1; \
+ __ret = (float32x4_t) __builtin_neon_vsetq_lane_f32(__s0, (float32x4_t)__s1, __p2); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsetq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
+ int32_t __s0 = __p0; \
int32x4_t __s1 = __p1; \
- __ret = (int32x4_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
+ __ret = (int32x4_t) __builtin_neon_vsetq_lane_i32(__s0, (int32x4_t)__s1, __p2); \
__ret; \
})
#else
-#define vsriq_n_s32(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
+ int32_t __s0 = __p0; \
int32x4_t __s1 = __p1; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
+ __ret = (int32x4_t) __builtin_neon_vsetq_lane_i32(__s0, (int32x4_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
+#define __noswap_vsetq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32_t __s0 = __p0; \
+ int32x4_t __s1 = __p1; \
+ __ret = (int32x4_t) __builtin_neon_vsetq_lane_i32(__s0, (int32x4_t)__s1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsriq_n_s64(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_s64(__p0, __p1, __p2) __extension__ ({ \
int64x2_t __ret; \
- int64x2_t __s0 = __p0; \
+ int64_t __s0 = __p0; \
int64x2_t __s1 = __p1; \
- __ret = (int64x2_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 35); \
+ __ret = (int64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (int64x2_t)__s1, __p2); \
__ret; \
})
#else
-#define vsriq_n_s64(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_s64(__p0, __p1, __p2) __extension__ ({ \
int64x2_t __ret; \
- int64x2_t __s0 = __p0; \
+ int64_t __s0 = __p0; \
int64x2_t __s1 = __p1; \
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
int64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (int64x2_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 35); \
+ __ret = (int64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (int64x2_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
+#define __noswap_vsetq_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2_t __ret; \
+ int64_t __s0 = __p0; \
+ int64x2_t __s1 = __p1; \
+ __ret = (int64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (int64x2_t)__s1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsriq_n_s16(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
+ int16_t __s0 = __p0; \
int16x8_t __s1 = __p1; \
- __ret = (int16x8_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
+ __ret = (int16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (int16x8_t)__s1, __p2); \
__ret; \
})
#else
-#define vsriq_n_s16(__p0, __p1, __p2) __extension__ ({ \
+#define vsetq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
+ int16_t __s0 = __p0; \
int16x8_t __s1 = __p1; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
+ __ret = (int16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (int16x8_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
+#define __noswap_vsetq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16_t __s0 = __p0; \
+ int16x8_t __s1 = __p1; \
+ __ret = (int16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (int16x8_t)__s1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsri_n_u8(__p0, __p1, __p2) __extension__ ({ \
+#define vset_lane_u8(__p0, __p1, __p2) __extension__ ({ \
uint8x8_t __ret; \
- uint8x8_t __s0 = __p0; \
+ uint8_t __s0 = __p0; \
uint8x8_t __s1 = __p1; \
- __ret = (uint8x8_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 16); \
+ __ret = (uint8x8_t) __builtin_neon_vset_lane_i8(__s0, (int8x8_t)__s1, __p2); \
__ret; \
})
#else
-#define vsri_n_u8(__p0, __p1, __p2) __extension__ ({ \
+#define vset_lane_u8(__p0, __p1, __p2) __extension__ ({ \
uint8x8_t __ret; \
- uint8x8_t __s0 = __p0; \
+ uint8_t __s0 = __p0; \
uint8x8_t __s1 = __p1; \
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8x8_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 16); \
+ __ret = (uint8x8_t) __builtin_neon_vset_lane_i8(__s0, (int8x8_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
+#define __noswap_vset_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8_t __s0 = __p0; \
+ uint8x8_t __s1 = __p1; \
+ __ret = (uint8x8_t) __builtin_neon_vset_lane_i8(__s0, (int8x8_t)__s1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsri_n_u32(__p0, __p1, __p2) __extension__ ({ \
+#define vset_lane_u32(__p0, __p1, __p2) __extension__ ({ \
uint32x2_t __ret; \
- uint32x2_t __s0 = __p0; \
+ uint32_t __s0 = __p0; \
uint32x2_t __s1 = __p1; \
- __ret = (uint32x2_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 18); \
+ __ret = (uint32x2_t) __builtin_neon_vset_lane_i32(__s0, (int32x2_t)__s1, __p2); \
__ret; \
})
#else
-#define vsri_n_u32(__p0, __p1, __p2) __extension__ ({ \
+#define vset_lane_u32(__p0, __p1, __p2) __extension__ ({ \
uint32x2_t __ret; \
- uint32x2_t __s0 = __p0; \
+ uint32_t __s0 = __p0; \
uint32x2_t __s1 = __p1; \
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (uint32x2_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 18); \
+ __ret = (uint32x2_t) __builtin_neon_vset_lane_i32(__s0, (int32x2_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
+#define __noswap_vset_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32_t __s0 = __p0; \
+ uint32x2_t __s1 = __p1; \
+ __ret = (uint32x2_t) __builtin_neon_vset_lane_i32(__s0, (int32x2_t)__s1, __p2); \
+ __ret; \
+})
#endif
-#define vsri_n_u64(__p0, __p1, __p2) __extension__ ({ \
+#define vset_lane_u64(__p0, __p1, __p2) __extension__ ({ \
uint64x1_t __ret; \
- uint64x1_t __s0 = __p0; \
+ uint64_t __s0 = __p0; \
uint64x1_t __s1 = __p1; \
- __ret = (uint64x1_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 19); \
+ __ret = (uint64x1_t) __builtin_neon_vset_lane_i64(__s0, (int64x1_t)__s1, __p2); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vsri_n_u16(__p0, __p1, __p2) __extension__ ({ \
+#define vset_lane_u16(__p0, __p1, __p2) __extension__ ({ \
uint16x4_t __ret; \
- uint16x4_t __s0 = __p0; \
+ uint16_t __s0 = __p0; \
uint16x4_t __s1 = __p1; \
- __ret = (uint16x4_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 17); \
+ __ret = (uint16x4_t) __builtin_neon_vset_lane_i16(__s0, (int16x4_t)__s1, __p2); \
__ret; \
})
#else
-#define vsri_n_u16(__p0, __p1, __p2) __extension__ ({ \
+#define vset_lane_u16(__p0, __p1, __p2) __extension__ ({ \
uint16x4_t __ret; \
- uint16x4_t __s0 = __p0; \
+ uint16_t __s0 = __p0; \
uint16x4_t __s1 = __p1; \
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 17); \
+ __ret = (uint16x4_t) __builtin_neon_vset_lane_i16(__s0, (int16x4_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
+#define __noswap_vset_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16_t __s0 = __p0; \
+ uint16x4_t __s1 = __p1; \
+ __ret = (uint16x4_t) __builtin_neon_vset_lane_i16(__s0, (int16x4_t)__s1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsri_n_s8(__p0, __p1, __p2) __extension__ ({ \
+#define vset_lane_s8(__p0, __p1, __p2) __extension__ ({ \
int8x8_t __ret; \
- int8x8_t __s0 = __p0; \
+ int8_t __s0 = __p0; \
int8x8_t __s1 = __p1; \
- __ret = (int8x8_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 0); \
+ __ret = (int8x8_t) __builtin_neon_vset_lane_i8(__s0, (int8x8_t)__s1, __p2); \
__ret; \
})
#else
-#define vsri_n_s8(__p0, __p1, __p2) __extension__ ({ \
+#define vset_lane_s8(__p0, __p1, __p2) __extension__ ({ \
int8x8_t __ret; \
- int8x8_t __s0 = __p0; \
+ int8_t __s0 = __p0; \
int8x8_t __s1 = __p1; \
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8x8_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 0); \
+ __ret = (int8x8_t) __builtin_neon_vset_lane_i8(__s0, (int8x8_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
+#define __noswap_vset_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8_t __ret; \
+ int8_t __s0 = __p0; \
+ int8x8_t __s1 = __p1; \
+ __ret = (int8x8_t) __builtin_neon_vset_lane_i8(__s0, (int8x8_t)__s1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsri_n_s32(__p0, __p1, __p2) __extension__ ({ \
+#define vset_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2_t __ret; \
+ float32_t __s0 = __p0; \
+ float32x2_t __s1 = __p1; \
+ __ret = (float32x2_t) __builtin_neon_vset_lane_f32(__s0, (float32x2_t)__s1, __p2); \
+ __ret; \
+})
+#else
+#define vset_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2_t __ret; \
+ float32_t __s0 = __p0; \
+ float32x2_t __s1 = __p1; \
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (float32x2_t) __builtin_neon_vset_lane_f32(__s0, (float32x2_t)__rev1, __p2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_vset_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2_t __ret; \
+ float32_t __s0 = __p0; \
+ float32x2_t __s1 = __p1; \
+ __ret = (float32x2_t) __builtin_neon_vset_lane_f32(__s0, (float32x2_t)__s1, __p2); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vset_lane_s32(__p0, __p1, __p2) __extension__ ({ \
int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
+ int32_t __s0 = __p0; \
int32x2_t __s1 = __p1; \
- __ret = (int32x2_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
+ __ret = (int32x2_t) __builtin_neon_vset_lane_i32(__s0, (int32x2_t)__s1, __p2); \
__ret; \
})
#else
-#define vsri_n_s32(__p0, __p1, __p2) __extension__ ({ \
+#define vset_lane_s32(__p0, __p1, __p2) __extension__ ({ \
int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
+ int32_t __s0 = __p0; \
int32x2_t __s1 = __p1; \
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+ __ret = (int32x2_t) __builtin_neon_vset_lane_i32(__s0, (int32x2_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
+#define __noswap_vset_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32_t __s0 = __p0; \
+ int32x2_t __s1 = __p1; \
+ __ret = (int32x2_t) __builtin_neon_vset_lane_i32(__s0, (int32x2_t)__s1, __p2); \
+ __ret; \
+})
#endif
-#define vsri_n_s64(__p0, __p1, __p2) __extension__ ({ \
+#define vset_lane_s64(__p0, __p1, __p2) __extension__ ({ \
int64x1_t __ret; \
- int64x1_t __s0 = __p0; \
+ int64_t __s0 = __p0; \
int64x1_t __s1 = __p1; \
- __ret = (int64x1_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 3); \
+ __ret = (int64x1_t) __builtin_neon_vset_lane_i64(__s0, (int64x1_t)__s1, __p2); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vsri_n_s16(__p0, __p1, __p2) __extension__ ({ \
+#define vset_lane_s16(__p0, __p1, __p2) __extension__ ({ \
int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
+ int16_t __s0 = __p0; \
int16x4_t __s1 = __p1; \
- __ret = (int16x4_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
+ __ret = (int16x4_t) __builtin_neon_vset_lane_i16(__s0, (int16x4_t)__s1, __p2); \
__ret; \
})
#else
-#define vsri_n_s16(__p0, __p1, __p2) __extension__ ({ \
+#define vset_lane_s16(__p0, __p1, __p2) __extension__ ({ \
int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
+ int16_t __s0 = __p0; \
int16x4_t __s1 = __p1; \
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+ __ret = (int16x4_t) __builtin_neon_vset_lane_i16(__s0, (int16x4_t)__rev1, __p2); \
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
+#define __noswap_vset_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16_t __s0 = __p0; \
+ int16x4_t __s1 = __p1; \
+ __ret = (int16x4_t) __builtin_neon_vset_lane_i16(__s0, (int16x4_t)__s1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_p8(__p0, __p1) __extension__ ({ \
- poly8x8_t __s1 = __p1; \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 4); \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ return __ret;
+}
#else
-#define vst1_p8(__p0, __p1) __extension__ ({ \
- poly8x8_t __s1 = __p1; \
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 4); \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_p16(__p0, __p1) __extension__ ({ \
- poly16x4_t __s1 = __p1; \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 5); \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+ return __ret;
+}
#else
-#define vst1_p16(__p0, __p1) __extension__ ({ \
- poly16x4_t __s1 = __p1; \
- poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 5); \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_p8(__p0, __p1) __extension__ ({ \
- poly8x16_t __s1 = __p1; \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 36); \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+ return __ret;
+}
#else
-#define vst1q_p8(__p0, __p1) __extension__ ({ \
- poly8x16_t __s1 = __p1; \
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 36); \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_p16(__p0, __p1) __extension__ ({ \
- poly16x8_t __s1 = __p1; \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 37); \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ return __ret;
+}
#else
-#define vst1q_p16(__p0, __p1) __extension__ ({ \
- poly16x8_t __s1 = __p1; \
- poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 37); \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_u8(__p0, __p1) __extension__ ({ \
- uint8x16_t __s1 = __p1; \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 48); \
-})
+__ai __attribute__((target("neon"))) int8x16_t vshlq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+ return __ret;
+}
#else
-#define vst1q_u8(__p0, __p1) __extension__ ({ \
- uint8x16_t __s1 = __p1; \
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 48); \
-})
+__ai __attribute__((target("neon"))) int8x16_t vshlq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_u32(__p0, __p1) __extension__ ({ \
- uint32x4_t __s1 = __p1; \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 50); \
-})
+__ai __attribute__((target("neon"))) int32x4_t vshlq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+ return __ret;
+}
#else
-#define vst1q_u32(__p0, __p1) __extension__ ({ \
- uint32x4_t __s1 = __p1; \
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 50); \
-})
+__ai __attribute__((target("neon"))) int32x4_t vshlq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_u64(__p0, __p1) __extension__ ({ \
- uint64x2_t __s1 = __p1; \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 51); \
-})
+__ai __attribute__((target("neon"))) int64x2_t vshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+ return __ret;
+}
#else
-#define vst1q_u64(__p0, __p1) __extension__ ({ \
- uint64x2_t __s1 = __p1; \
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 51); \
-})
+__ai __attribute__((target("neon"))) int64x2_t vshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_u16(__p0, __p1) __extension__ ({ \
- uint16x8_t __s1 = __p1; \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 49); \
-})
+__ai __attribute__((target("neon"))) int16x8_t vshlq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ return __ret;
+}
#else
-#define vst1q_u16(__p0, __p1) __extension__ ({ \
- uint16x8_t __s1 = __p1; \
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 49); \
-})
+__ai __attribute__((target("neon"))) int16x8_t vshlq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_s8(__p0, __p1) __extension__ ({ \
- int8x16_t __s1 = __p1; \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 32); \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ return __ret;
+}
#else
-#define vst1q_s8(__p0, __p1) __extension__ ({ \
- int8x16_t __s1 = __p1; \
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 32); \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_f32(__p0, __p1) __extension__ ({ \
- float32x4_t __s1 = __p1; \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 41); \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vshl_u32(uint32x2_t __p0, int32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ return __ret;
+}
#else
-#define vst1q_f32(__p0, __p1) __extension__ ({ \
- float32x4_t __s1 = __p1; \
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 41); \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vshl_u32(uint32x2_t __p0, int32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vshl_u64(uint64x1_t __p0, int64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vst1q_s32(__p0, __p1) __extension__ ({ \
- int32x4_t __s1 = __p1; \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 34); \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ return __ret;
+}
#else
-#define vst1q_s32(__p0, __p1) __extension__ ({ \
- int32x4_t __s1 = __p1; \
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 34); \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_s64(__p0, __p1) __extension__ ({ \
- int64x2_t __s1 = __p1; \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 35); \
-})
+__ai __attribute__((target("neon"))) int8x8_t vshl_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+ return __ret;
+}
#else
-#define vst1q_s64(__p0, __p1) __extension__ ({ \
- int64x2_t __s1 = __p1; \
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 35); \
-})
+__ai __attribute__((target("neon"))) int8x8_t vshl_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_s16(__p0, __p1) __extension__ ({ \
- int16x8_t __s1 = __p1; \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 33); \
-})
+__ai __attribute__((target("neon"))) int32x2_t vshl_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+ return __ret;
+}
#else
-#define vst1q_s16(__p0, __p1) __extension__ ({ \
- int16x8_t __s1 = __p1; \
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 33); \
-})
+__ai __attribute__((target("neon"))) int32x2_t vshl_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) int64x1_t vshl_s64(int64x1_t __p0, int64x1_t __p1) {
+ int64x1_t __ret;
+ __ret = (int64x1_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vst1_u8(__p0, __p1) __extension__ ({ \
- uint8x8_t __s1 = __p1; \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 16); \
-})
+__ai __attribute__((target("neon"))) int16x4_t vshl_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+ return __ret;
+}
#else
-#define vst1_u8(__p0, __p1) __extension__ ({ \
- uint8x8_t __s1 = __p1; \
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 16); \
-})
+__ai __attribute__((target("neon"))) int16x4_t vshl_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_u32(__p0, __p1) __extension__ ({ \
- uint32x2_t __s1 = __p1; \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 18); \
+#define vshlq_n_u8(__p0, __p1) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ __ret = (uint8x16_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 48); \
+ __ret; \
})
#else
-#define vst1_u32(__p0, __p1) __extension__ ({ \
- uint32x2_t __s1 = __p1; \
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 18); \
+#define vshlq_n_u8(__p0, __p1) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x16_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 48); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
-#define vst1_u64(__p0, __p1) __extension__ ({ \
- uint64x1_t __s1 = __p1; \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 19); \
-})
#ifdef __LITTLE_ENDIAN__
-#define vst1_u16(__p0, __p1) __extension__ ({ \
- uint16x4_t __s1 = __p1; \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 17); \
+#define vshlq_n_u32(__p0, __p1) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ __ret = (uint32x4_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 50); \
+ __ret; \
})
#else
-#define vst1_u16(__p0, __p1) __extension__ ({ \
- uint16x4_t __s1 = __p1; \
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 17); \
+#define vshlq_n_u32(__p0, __p1) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint32x4_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 50); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_s8(__p0, __p1) __extension__ ({ \
- int8x8_t __s1 = __p1; \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 0); \
+#define vshlq_n_u64(__p0, __p1) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ __ret = (uint64x2_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 51); \
+ __ret; \
})
#else
-#define vst1_s8(__p0, __p1) __extension__ ({ \
- int8x8_t __s1 = __p1; \
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 0); \
+#define vshlq_n_u64(__p0, __p1) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint64x2_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 51); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_f32(__p0, __p1) __extension__ ({ \
- float32x2_t __s1 = __p1; \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 9); \
+#define vshlq_n_u16(__p0, __p1) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ __ret = (uint16x8_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 49); \
+ __ret; \
})
#else
-#define vst1_f32(__p0, __p1) __extension__ ({ \
- float32x2_t __s1 = __p1; \
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 9); \
+#define vshlq_n_u16(__p0, __p1) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint16x8_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 49); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_s32(__p0, __p1) __extension__ ({ \
- int32x2_t __s1 = __p1; \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 2); \
+#define vshlq_n_s8(__p0, __p1) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x16_t __s0 = __p0; \
+ __ret = (int8x16_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 32); \
+ __ret; \
})
#else
-#define vst1_s32(__p0, __p1) __extension__ ({ \
- int32x2_t __s1 = __p1; \
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 2); \
-})
-#endif
-
-#define vst1_s64(__p0, __p1) __extension__ ({ \
- int64x1_t __s1 = __p1; \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 3); \
+#define vshlq_n_s8(__p0, __p1) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x16_t __s0 = __p0; \
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x16_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 32); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
+#endif
+
#ifdef __LITTLE_ENDIAN__
-#define vst1_s16(__p0, __p1) __extension__ ({ \
- int16x4_t __s1 = __p1; \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 1); \
+#define vshlq_n_s32(__p0, __p1) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (int32x4_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 34); \
+ __ret; \
})
#else
-#define vst1_s16(__p0, __p1) __extension__ ({ \
- int16x4_t __s1 = __p1; \
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 1); \
+#define vshlq_n_s32(__p0, __p1) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (int32x4_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 34); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8_t __s1 = __p1; \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 4); \
+#define vshlq_n_s64(__p0, __p1) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (int64x2_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 35); \
+ __ret; \
})
#else
-#define vst1_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8_t __s1 = __p1; \
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 4); \
+#define vshlq_n_s64(__p0, __p1) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (int64x2_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 35); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4_t __s1 = __p1; \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 5); \
+#define vshlq_n_s16(__p0, __p1) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (int16x8_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 33); \
+ __ret; \
})
#else
-#define vst1_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4_t __s1 = __p1; \
- poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 5); \
+#define vshlq_n_s16(__p0, __p1) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int16x8_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 33); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16_t __s1 = __p1; \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 36); \
+#define vshl_n_u8(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ __ret = (uint8x8_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 16); \
+ __ret; \
})
#else
-#define vst1q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16_t __s1 = __p1; \
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 36); \
+#define vshl_n_u8(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x8_t) __builtin_neon_vshl_n_v((int8x8_t)__rev0, __p1, 16); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8_t __s1 = __p1; \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 37); \
+#define vshl_n_u32(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ __ret = (uint32x2_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 18); \
+ __ret; \
})
#else
-#define vst1q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8_t __s1 = __p1; \
- poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 37); \
+#define vshl_n_u32(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint32x2_t) __builtin_neon_vshl_n_v((int8x8_t)__rev0, __p1, 18); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
+#define vshl_n_u64(__p0, __p1) __extension__ ({ \
+ uint64x1_t __ret; \
+ uint64x1_t __s0 = __p0; \
+ __ret = (uint64x1_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 19); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vst1q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16_t __s1 = __p1; \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 48); \
+#define vshl_n_u16(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ __ret = (uint16x4_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 17); \
+ __ret; \
})
#else
-#define vst1q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16_t __s1 = __p1; \
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 48); \
+#define vshl_n_u16(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint16x4_t) __builtin_neon_vshl_n_v((int8x8_t)__rev0, __p1, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4_t __s1 = __p1; \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 50); \
+#define vshl_n_s8(__p0, __p1) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ __ret = (int8x8_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 0); \
+ __ret; \
})
#else
-#define vst1q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4_t __s1 = __p1; \
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 50); \
+#define vshl_n_s8(__p0, __p1) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vshl_n_v((int8x8_t)__rev0, __p1, 0); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2_t __s1 = __p1; \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 51); \
+#define vshl_n_s32(__p0, __p1) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ __ret = (int32x2_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 2); \
+ __ret; \
})
#else
-#define vst1q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2_t __s1 = __p1; \
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 51); \
+#define vshl_n_s32(__p0, __p1) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (int32x2_t) __builtin_neon_vshl_n_v((int8x8_t)__rev0, __p1, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
+#define vshl_n_s64(__p0, __p1) __extension__ ({ \
+ int64x1_t __ret; \
+ int64x1_t __s0 = __p0; \
+ __ret = (int64x1_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 3); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vst1q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8_t __s1 = __p1; \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 49); \
+#define vshl_n_s16(__p0, __p1) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ __ret = (int16x4_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 1); \
+ __ret; \
})
#else
-#define vst1q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8_t __s1 = __p1; \
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 49); \
+#define vshl_n_s16(__p0, __p1) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (int16x4_t) __builtin_neon_vshl_n_v((int8x8_t)__rev0, __p1, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16_t __s1 = __p1; \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 32); \
+#define vshll_n_u8(__p0, __p1) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ __ret = (uint16x8_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 49); \
+ __ret; \
})
#else
-#define vst1q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16_t __s1 = __p1; \
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 32); \
+#define vshll_n_u8(__p0, __p1) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint16x8_t) __builtin_neon_vshll_n_v((int8x8_t)__rev0, __p1, 49); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vshll_n_u8(__p0, __p1) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ __ret = (uint16x8_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 49); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x4_t __s1 = __p1; \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 41); \
+#define vshll_n_u32(__p0, __p1) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ __ret = (uint64x2_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 51); \
+ __ret; \
})
#else
-#define vst1q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x4_t __s1 = __p1; \
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 41); \
+#define vshll_n_u32(__p0, __p1) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint64x2_t) __builtin_neon_vshll_n_v((int8x8_t)__rev0, __p1, 51); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_vshll_n_u32(__p0, __p1) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ __ret = (uint64x2_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 51); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __s1 = __p1; \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 34); \
+#define vshll_n_u16(__p0, __p1) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ __ret = (uint32x4_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 50); \
+ __ret; \
})
#else
-#define vst1q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __s1 = __p1; \
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 34); \
+#define vshll_n_u16(__p0, __p1) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint32x4_t) __builtin_neon_vshll_n_v((int8x8_t)__rev0, __p1, 50); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vshll_n_u16(__p0, __p1) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ __ret = (uint32x4_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 50); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2_t __s1 = __p1; \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 35); \
+#define vshll_n_s8(__p0, __p1) __extension__ ({ \
+ int16x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ __ret = (int16x8_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 33); \
+ __ret; \
})
#else
-#define vst1q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2_t __s1 = __p1; \
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 35); \
+#define vshll_n_s8(__p0, __p1) __extension__ ({ \
+ int16x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int16x8_t) __builtin_neon_vshll_n_v((int8x8_t)__rev0, __p1, 33); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vshll_n_s8(__p0, __p1) __extension__ ({ \
+ int16x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ __ret = (int16x8_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 33); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __s1 = __p1; \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 33); \
+#define vshll_n_s32(__p0, __p1) __extension__ ({ \
+ int64x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ __ret = (int64x2_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 35); \
+ __ret; \
})
#else
-#define vst1q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __s1 = __p1; \
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 33); \
+#define vshll_n_s32(__p0, __p1) __extension__ ({ \
+ int64x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (int64x2_t) __builtin_neon_vshll_n_v((int8x8_t)__rev0, __p1, 35); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_vshll_n_s32(__p0, __p1) __extension__ ({ \
+ int64x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ __ret = (int64x2_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 35); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8_t __s1 = __p1; \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 16); \
+#define vshll_n_s16(__p0, __p1) __extension__ ({ \
+ int32x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ __ret = (int32x4_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 34); \
+ __ret; \
})
#else
-#define vst1_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8_t __s1 = __p1; \
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 16); \
+#define vshll_n_s16(__p0, __p1) __extension__ ({ \
+ int32x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (int32x4_t) __builtin_neon_vshll_n_v((int8x8_t)__rev0, __p1, 34); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vshll_n_s16(__p0, __p1) __extension__ ({ \
+ int32x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ __ret = (int32x4_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 34); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2_t __s1 = __p1; \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 18); \
+#define vshrq_n_u8(__p0, __p1) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ __ret = (uint8x16_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 48); \
+ __ret; \
})
#else
-#define vst1_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2_t __s1 = __p1; \
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 18); \
+#define vshrq_n_u8(__p0, __p1) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x16_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 48); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
-#define vst1_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x1_t __s1 = __p1; \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 19); \
-})
#ifdef __LITTLE_ENDIAN__
-#define vst1_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4_t __s1 = __p1; \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 17); \
+#define vshrq_n_u32(__p0, __p1) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ __ret = (uint32x4_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 50); \
+ __ret; \
})
#else
-#define vst1_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4_t __s1 = __p1; \
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 17); \
+#define vshrq_n_u32(__p0, __p1) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint32x4_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 50); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8_t __s1 = __p1; \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 0); \
+#define vshrq_n_u64(__p0, __p1) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ __ret = (uint64x2_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 51); \
+ __ret; \
})
#else
-#define vst1_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8_t __s1 = __p1; \
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 0); \
+#define vshrq_n_u64(__p0, __p1) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint64x2_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 51); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x2_t __s1 = __p1; \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 9); \
+#define vshrq_n_u16(__p0, __p1) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ __ret = (uint16x8_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 49); \
+ __ret; \
})
#else
-#define vst1_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x2_t __s1 = __p1; \
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 9); \
+#define vshrq_n_u16(__p0, __p1) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint16x8_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 49); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __s1 = __p1; \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 2); \
+#define vshrq_n_s8(__p0, __p1) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x16_t __s0 = __p0; \
+ __ret = (int8x16_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 32); \
+ __ret; \
})
#else
-#define vst1_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __s1 = __p1; \
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 2); \
+#define vshrq_n_s8(__p0, __p1) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x16_t __s0 = __p0; \
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x16_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 32); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
-#define vst1_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x1_t __s1 = __p1; \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 3); \
-})
#ifdef __LITTLE_ENDIAN__
-#define vst1_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __s1 = __p1; \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 1); \
+#define vshrq_n_s32(__p0, __p1) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (int32x4_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 34); \
+ __ret; \
})
#else
-#define vst1_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __s1 = __p1; \
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 1); \
+#define vshrq_n_s32(__p0, __p1) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (int32x4_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 34); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_p8_x2(__p0, __p1) __extension__ ({ \
- poly8x8x2_t __s1 = __p1; \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 4); \
+#define vshrq_n_s64(__p0, __p1) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (int64x2_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 35); \
+ __ret; \
})
#else
-#define vst1_p8_x2(__p0, __p1) __extension__ ({ \
- poly8x8x2_t __s1 = __p1; \
- poly8x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 4); \
+#define vshrq_n_s64(__p0, __p1) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (int64x2_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 35); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_p16_x2(__p0, __p1) __extension__ ({ \
- poly16x4x2_t __s1 = __p1; \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 5); \
+#define vshrq_n_s16(__p0, __p1) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (int16x8_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 33); \
+ __ret; \
})
#else
-#define vst1_p16_x2(__p0, __p1) __extension__ ({ \
- poly16x4x2_t __s1 = __p1; \
- poly16x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 5); \
+#define vshrq_n_s16(__p0, __p1) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int16x8_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 33); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_p8_x2(__p0, __p1) __extension__ ({ \
- poly8x16x2_t __s1 = __p1; \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 36); \
-})
-#else
-#define vst1q_p8_x2(__p0, __p1) __extension__ ({ \
- poly8x16x2_t __s1 = __p1; \
- poly8x16x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 36); \
+#define vshr_n_u8(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ __ret = (uint8x8_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 16); \
+ __ret; \
+})
+#else
+#define vshr_n_u8(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x8_t) __builtin_neon_vshr_n_v((int8x8_t)__rev0, __p1, 16); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_p16_x2(__p0, __p1) __extension__ ({ \
- poly16x8x2_t __s1 = __p1; \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 37); \
+#define vshr_n_u32(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ __ret = (uint32x2_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 18); \
+ __ret; \
})
#else
-#define vst1q_p16_x2(__p0, __p1) __extension__ ({ \
- poly16x8x2_t __s1 = __p1; \
- poly16x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 37); \
+#define vshr_n_u32(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint32x2_t) __builtin_neon_vshr_n_v((int8x8_t)__rev0, __p1, 18); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
+#define vshr_n_u64(__p0, __p1) __extension__ ({ \
+ uint64x1_t __ret; \
+ uint64x1_t __s0 = __p0; \
+ __ret = (uint64x1_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 19); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vst1q_u8_x2(__p0, __p1) __extension__ ({ \
- uint8x16x2_t __s1 = __p1; \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 48); \
+#define vshr_n_u16(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ __ret = (uint16x4_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 17); \
+ __ret; \
})
#else
-#define vst1q_u8_x2(__p0, __p1) __extension__ ({ \
- uint8x16x2_t __s1 = __p1; \
- uint8x16x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 48); \
+#define vshr_n_u16(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint16x4_t) __builtin_neon_vshr_n_v((int8x8_t)__rev0, __p1, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_u32_x2(__p0, __p1) __extension__ ({ \
- uint32x4x2_t __s1 = __p1; \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 50); \
+#define vshr_n_s8(__p0, __p1) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ __ret = (int8x8_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 0); \
+ __ret; \
})
#else
-#define vst1q_u32_x2(__p0, __p1) __extension__ ({ \
- uint32x4x2_t __s1 = __p1; \
- uint32x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 50); \
+#define vshr_n_s8(__p0, __p1) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vshr_n_v((int8x8_t)__rev0, __p1, 0); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_u64_x2(__p0, __p1) __extension__ ({ \
- uint64x2x2_t __s1 = __p1; \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 51); \
+#define vshr_n_s32(__p0, __p1) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ __ret = (int32x2_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 2); \
+ __ret; \
})
#else
-#define vst1q_u64_x2(__p0, __p1) __extension__ ({ \
- uint64x2x2_t __s1 = __p1; \
- uint64x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 51); \
+#define vshr_n_s32(__p0, __p1) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (int32x2_t) __builtin_neon_vshr_n_v((int8x8_t)__rev0, __p1, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
+#define vshr_n_s64(__p0, __p1) __extension__ ({ \
+ int64x1_t __ret; \
+ int64x1_t __s0 = __p0; \
+ __ret = (int64x1_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 3); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vst1q_u16_x2(__p0, __p1) __extension__ ({ \
- uint16x8x2_t __s1 = __p1; \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 49); \
+#define vshr_n_s16(__p0, __p1) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ __ret = (int16x4_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 1); \
+ __ret; \
})
#else
-#define vst1q_u16_x2(__p0, __p1) __extension__ ({ \
- uint16x8x2_t __s1 = __p1; \
- uint16x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 49); \
+#define vshr_n_s16(__p0, __p1) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (int16x4_t) __builtin_neon_vshr_n_v((int8x8_t)__rev0, __p1, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_s8_x2(__p0, __p1) __extension__ ({ \
- int8x16x2_t __s1 = __p1; \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 32); \
+#define vshrn_n_u32(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ __ret = (uint16x4_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 17); \
+ __ret; \
})
#else
-#define vst1q_s8_x2(__p0, __p1) __extension__ ({ \
- int8x16x2_t __s1 = __p1; \
- int8x16x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 32); \
+#define vshrn_n_u32(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint16x4_t) __builtin_neon_vshrn_n_v((int8x16_t)__rev0, __p1, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vshrn_n_u32(__p0, __p1) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ __ret = (uint16x4_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 17); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_f32_x2(__p0, __p1) __extension__ ({ \
- float32x4x2_t __s1 = __p1; \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 41); \
+#define vshrn_n_u64(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ __ret = (uint32x2_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 18); \
+ __ret; \
})
#else
-#define vst1q_f32_x2(__p0, __p1) __extension__ ({ \
- float32x4x2_t __s1 = __p1; \
- float32x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 41); \
+#define vshrn_n_u64(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint32x2_t) __builtin_neon_vshrn_n_v((int8x16_t)__rev0, __p1, 18); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_vshrn_n_u64(__p0, __p1) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ __ret = (uint32x2_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 18); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_s32_x2(__p0, __p1) __extension__ ({ \
- int32x4x2_t __s1 = __p1; \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 34); \
+#define vshrn_n_u16(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ __ret = (uint8x8_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 16); \
+ __ret; \
})
#else
-#define vst1q_s32_x2(__p0, __p1) __extension__ ({ \
- int32x4x2_t __s1 = __p1; \
- int32x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 34); \
+#define vshrn_n_u16(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x8_t) __builtin_neon_vshrn_n_v((int8x16_t)__rev0, __p1, 16); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vshrn_n_u16(__p0, __p1) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ __ret = (uint8x8_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 16); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_s64_x2(__p0, __p1) __extension__ ({ \
- int64x2x2_t __s1 = __p1; \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 35); \
+#define vshrn_n_s32(__p0, __p1) __extension__ ({ \
+ int16x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (int16x4_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 1); \
+ __ret; \
})
#else
-#define vst1q_s64_x2(__p0, __p1) __extension__ ({ \
- int64x2x2_t __s1 = __p1; \
- int64x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 35); \
+#define vshrn_n_s32(__p0, __p1) __extension__ ({ \
+ int16x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (int16x4_t) __builtin_neon_vshrn_n_v((int8x16_t)__rev0, __p1, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vshrn_n_s32(__p0, __p1) __extension__ ({ \
+ int16x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (int16x4_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 1); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_s16_x2(__p0, __p1) __extension__ ({ \
- int16x8x2_t __s1 = __p1; \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 33); \
+#define vshrn_n_s64(__p0, __p1) __extension__ ({ \
+ int32x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (int32x2_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 2); \
+ __ret; \
})
#else
-#define vst1q_s16_x2(__p0, __p1) __extension__ ({ \
- int16x8x2_t __s1 = __p1; \
- int16x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 33); \
+#define vshrn_n_s64(__p0, __p1) __extension__ ({ \
+ int32x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (int32x2_t) __builtin_neon_vshrn_n_v((int8x16_t)__rev0, __p1, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_vshrn_n_s64(__p0, __p1) __extension__ ({ \
+ int32x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (int32x2_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 2); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_u8_x2(__p0, __p1) __extension__ ({ \
- uint8x8x2_t __s1 = __p1; \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 16); \
+#define vshrn_n_s16(__p0, __p1) __extension__ ({ \
+ int8x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (int8x8_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 0); \
+ __ret; \
})
#else
-#define vst1_u8_x2(__p0, __p1) __extension__ ({ \
- uint8x8x2_t __s1 = __p1; \
- uint8x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 16); \
+#define vshrn_n_s16(__p0, __p1) __extension__ ({ \
+ int8x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vshrn_n_v((int8x16_t)__rev0, __p1, 0); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vshrn_n_s16(__p0, __p1) __extension__ ({ \
+ int8x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (int8x8_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_u32_x2(__p0, __p1) __extension__ ({ \
- uint32x2x2_t __s1 = __p1; \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 18); \
+#define vsli_n_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8_t __ret; \
+ poly8x8_t __s0 = __p0; \
+ poly8x8_t __s1 = __p1; \
+ __ret = (poly8x8_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 4); \
+ __ret; \
})
#else
-#define vst1_u32_x2(__p0, __p1) __extension__ ({ \
- uint32x2x2_t __s1 = __p1; \
- uint32x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 18); \
+#define vsli_n_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8_t __ret; \
+ poly8x8_t __s0 = __p0; \
+ poly8x8_t __s1 = __p1; \
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly8x8_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 4); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
-#define vst1_u64_x2(__p0, __p1) __extension__ ({ \
- uint64x1x2_t __s1 = __p1; \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 19); \
-})
#ifdef __LITTLE_ENDIAN__
-#define vst1_u16_x2(__p0, __p1) __extension__ ({ \
- uint16x4x2_t __s1 = __p1; \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 17); \
+#define vsli_n_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4_t __ret; \
+ poly16x4_t __s0 = __p0; \
+ poly16x4_t __s1 = __p1; \
+ __ret = (poly16x4_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 5); \
+ __ret; \
})
#else
-#define vst1_u16_x2(__p0, __p1) __extension__ ({ \
- uint16x4x2_t __s1 = __p1; \
- uint16x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 17); \
+#define vsli_n_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4_t __ret; \
+ poly16x4_t __s0 = __p0; \
+ poly16x4_t __s1 = __p1; \
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (poly16x4_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 5); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_s8_x2(__p0, __p1) __extension__ ({ \
- int8x8x2_t __s1 = __p1; \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 0); \
+#define vsliq_n_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16_t __ret; \
+ poly8x16_t __s0 = __p0; \
+ poly8x16_t __s1 = __p1; \
+ __ret = (poly8x16_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 36); \
+ __ret; \
})
#else
-#define vst1_s8_x2(__p0, __p1) __extension__ ({ \
- int8x8x2_t __s1 = __p1; \
- int8x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 0); \
+#define vsliq_n_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16_t __ret; \
+ poly8x16_t __s0 = __p0; \
+ poly8x16_t __s1 = __p1; \
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly8x16_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 36); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_f32_x2(__p0, __p1) __extension__ ({ \
- float32x2x2_t __s1 = __p1; \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 9); \
+#define vsliq_n_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8_t __ret; \
+ poly16x8_t __s0 = __p0; \
+ poly16x8_t __s1 = __p1; \
+ __ret = (poly16x8_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 37); \
+ __ret; \
})
#else
-#define vst1_f32_x2(__p0, __p1) __extension__ ({ \
- float32x2x2_t __s1 = __p1; \
- float32x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 9); \
+#define vsliq_n_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8_t __ret; \
+ poly16x8_t __s0 = __p0; \
+ poly16x8_t __s1 = __p1; \
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly16x8_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 37); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_s32_x2(__p0, __p1) __extension__ ({ \
- int32x2x2_t __s1 = __p1; \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 2); \
+#define vsliq_n_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ uint8x16_t __s1 = __p1; \
+ __ret = (uint8x16_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 48); \
+ __ret; \
})
#else
-#define vst1_s32_x2(__p0, __p1) __extension__ ({ \
- int32x2x2_t __s1 = __p1; \
- int32x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 2); \
+#define vsliq_n_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ uint8x16_t __s1 = __p1; \
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x16_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 48); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
-#define vst1_s64_x2(__p0, __p1) __extension__ ({ \
- int64x1x2_t __s1 = __p1; \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 3); \
-})
#ifdef __LITTLE_ENDIAN__
-#define vst1_s16_x2(__p0, __p1) __extension__ ({ \
- int16x4x2_t __s1 = __p1; \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 1); \
+#define vsliq_n_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ uint32x4_t __s1 = __p1; \
+ __ret = (uint32x4_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 50); \
+ __ret; \
})
#else
-#define vst1_s16_x2(__p0, __p1) __extension__ ({ \
- int16x4x2_t __s1 = __p1; \
- int16x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 1); \
+#define vsliq_n_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ uint32x4_t __s1 = __p1; \
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (uint32x4_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 50); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_p8_x3(__p0, __p1) __extension__ ({ \
- poly8x8x3_t __s1 = __p1; \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 4); \
+#define vsliq_n_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ uint64x2_t __s1 = __p1; \
+ __ret = (uint64x2_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 51); \
+ __ret; \
})
#else
-#define vst1_p8_x3(__p0, __p1) __extension__ ({ \
- poly8x8x3_t __s1 = __p1; \
- poly8x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 4); \
+#define vsliq_n_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ uint64x2_t __s1 = __p1; \
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (uint64x2_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 51); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_p16_x3(__p0, __p1) __extension__ ({ \
- poly16x4x3_t __s1 = __p1; \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 5); \
+#define vsliq_n_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ uint16x8_t __s1 = __p1; \
+ __ret = (uint16x8_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 49); \
+ __ret; \
})
#else
-#define vst1_p16_x3(__p0, __p1) __extension__ ({ \
- poly16x4x3_t __s1 = __p1; \
- poly16x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 5); \
+#define vsliq_n_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ uint16x8_t __s1 = __p1; \
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint16x8_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 49); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_p8_x3(__p0, __p1) __extension__ ({ \
- poly8x16x3_t __s1 = __p1; \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 36); \
+#define vsliq_n_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x16_t __s0 = __p0; \
+ int8x16_t __s1 = __p1; \
+ __ret = (int8x16_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 32); \
+ __ret; \
})
#else
-#define vst1q_p8_x3(__p0, __p1) __extension__ ({ \
- poly8x16x3_t __s1 = __p1; \
- poly8x16x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 36); \
+#define vsliq_n_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x16_t __s0 = __p0; \
+ int8x16_t __s1 = __p1; \
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x16_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 32); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_p16_x3(__p0, __p1) __extension__ ({ \
- poly16x8x3_t __s1 = __p1; \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 37); \
+#define vsliq_n_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __s1 = __p1; \
+ __ret = (int32x4_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
+ __ret; \
})
#else
-#define vst1q_p16_x3(__p0, __p1) __extension__ ({ \
- poly16x8x3_t __s1 = __p1; \
- poly16x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 37); \
+#define vsliq_n_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __s1 = __p1; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (int32x4_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_u8_x3(__p0, __p1) __extension__ ({ \
- uint8x16x3_t __s1 = __p1; \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 48); \
+#define vsliq_n_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __s1 = __p1; \
+ __ret = (int64x2_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 35); \
+ __ret; \
})
#else
-#define vst1q_u8_x3(__p0, __p1) __extension__ ({ \
- uint8x16x3_t __s1 = __p1; \
- uint8x16x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 48); \
+#define vsliq_n_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __s1 = __p1; \
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (int64x2_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 35); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_u32_x3(__p0, __p1) __extension__ ({ \
- uint32x4x3_t __s1 = __p1; \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 50); \
+#define vsliq_n_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __s1 = __p1; \
+ __ret = (int16x8_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
+ __ret; \
})
#else
-#define vst1q_u32_x3(__p0, __p1) __extension__ ({ \
- uint32x4x3_t __s1 = __p1; \
- uint32x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 50); \
+#define vsliq_n_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __s1 = __p1; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int16x8_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_u64_x3(__p0, __p1) __extension__ ({ \
- uint64x2x3_t __s1 = __p1; \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 51); \
+#define vsli_n_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ uint8x8_t __s1 = __p1; \
+ __ret = (uint8x8_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 16); \
+ __ret; \
})
#else
-#define vst1q_u64_x3(__p0, __p1) __extension__ ({ \
- uint64x2x3_t __s1 = __p1; \
- uint64x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 51); \
+#define vsli_n_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ uint8x8_t __s1 = __p1; \
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x8_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 16); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_u16_x3(__p0, __p1) __extension__ ({ \
- uint16x8x3_t __s1 = __p1; \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 49); \
+#define vsli_n_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ uint32x2_t __s1 = __p1; \
+ __ret = (uint32x2_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 18); \
+ __ret; \
})
#else
-#define vst1q_u16_x3(__p0, __p1) __extension__ ({ \
- uint16x8x3_t __s1 = __p1; \
- uint16x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 49); \
+#define vsli_n_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ uint32x2_t __s1 = __p1; \
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (uint32x2_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 18); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
-#ifdef __LITTLE_ENDIAN__
-#define vst1q_s8_x3(__p0, __p1) __extension__ ({ \
- int8x16x3_t __s1 = __p1; \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 32); \
-})
-#else
-#define vst1q_s8_x3(__p0, __p1) __extension__ ({ \
- int8x16x3_t __s1 = __p1; \
- int8x16x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 32); \
+#define vsli_n_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x1_t __ret; \
+ uint64x1_t __s0 = __p0; \
+ uint64x1_t __s1 = __p1; \
+ __ret = (uint64x1_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 19); \
+ __ret; \
})
-#endif
-
#ifdef __LITTLE_ENDIAN__
-#define vst1q_f32_x3(__p0, __p1) __extension__ ({ \
- float32x4x3_t __s1 = __p1; \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 41); \
+#define vsli_n_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ uint16x4_t __s1 = __p1; \
+ __ret = (uint16x4_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 17); \
+ __ret; \
})
#else
-#define vst1q_f32_x3(__p0, __p1) __extension__ ({ \
- float32x4x3_t __s1 = __p1; \
- float32x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 41); \
+#define vsli_n_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ uint16x4_t __s1 = __p1; \
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (uint16x4_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_s32_x3(__p0, __p1) __extension__ ({ \
- int32x4x3_t __s1 = __p1; \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 34); \
+#define vsli_n_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ int8x8_t __s1 = __p1; \
+ __ret = (int8x8_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 0); \
+ __ret; \
})
#else
-#define vst1q_s32_x3(__p0, __p1) __extension__ ({ \
- int32x4x3_t __s1 = __p1; \
- int32x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 34); \
+#define vsli_n_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ int8x8_t __s1 = __p1; \
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 0); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_s64_x3(__p0, __p1) __extension__ ({ \
- int64x2x3_t __s1 = __p1; \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 35); \
+#define vsli_n_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __s1 = __p1; \
+ __ret = (int32x2_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
+ __ret; \
})
#else
-#define vst1q_s64_x3(__p0, __p1) __extension__ ({ \
- int64x2x3_t __s1 = __p1; \
- int64x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 35); \
+#define vsli_n_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __s1 = __p1; \
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (int32x2_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
+#define vsli_n_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x1_t __ret; \
+ int64x1_t __s0 = __p0; \
+ int64x1_t __s1 = __p1; \
+ __ret = (int64x1_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 3); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vst1q_s16_x3(__p0, __p1) __extension__ ({ \
- int16x8x3_t __s1 = __p1; \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 33); \
+#define vsli_n_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __s1 = __p1; \
+ __ret = (int16x4_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
+ __ret; \
})
#else
-#define vst1q_s16_x3(__p0, __p1) __extension__ ({ \
- int16x8x3_t __s1 = __p1; \
- int16x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 33); \
+#define vsli_n_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __s1 = __p1; \
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (int16x4_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_u8_x3(__p0, __p1) __extension__ ({ \
- uint8x8x3_t __s1 = __p1; \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 16); \
+#define vsraq_n_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ uint8x16_t __s1 = __p1; \
+ __ret = (uint8x16_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 48); \
+ __ret; \
})
#else
-#define vst1_u8_x3(__p0, __p1) __extension__ ({ \
- uint8x8x3_t __s1 = __p1; \
- uint8x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 16); \
+#define vsraq_n_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ uint8x16_t __s1 = __p1; \
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x16_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 48); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_u32_x3(__p0, __p1) __extension__ ({ \
- uint32x2x3_t __s1 = __p1; \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 18); \
+#define vsraq_n_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ uint32x4_t __s1 = __p1; \
+ __ret = (uint32x4_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 50); \
+ __ret; \
})
#else
-#define vst1_u32_x3(__p0, __p1) __extension__ ({ \
- uint32x2x3_t __s1 = __p1; \
- uint32x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 18); \
+#define vsraq_n_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ uint32x4_t __s1 = __p1; \
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (uint32x4_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 50); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
-#define vst1_u64_x3(__p0, __p1) __extension__ ({ \
- uint64x1x3_t __s1 = __p1; \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 19); \
-})
#ifdef __LITTLE_ENDIAN__
-#define vst1_u16_x3(__p0, __p1) __extension__ ({ \
- uint16x4x3_t __s1 = __p1; \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 17); \
+#define vsraq_n_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ uint64x2_t __s1 = __p1; \
+ __ret = (uint64x2_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 51); \
+ __ret; \
})
#else
-#define vst1_u16_x3(__p0, __p1) __extension__ ({ \
- uint16x4x3_t __s1 = __p1; \
- uint16x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 17); \
+#define vsraq_n_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ uint64x2_t __s1 = __p1; \
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (uint64x2_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 51); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_s8_x3(__p0, __p1) __extension__ ({ \
- int8x8x3_t __s1 = __p1; \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 0); \
+#define vsraq_n_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ uint16x8_t __s1 = __p1; \
+ __ret = (uint16x8_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 49); \
+ __ret; \
})
#else
-#define vst1_s8_x3(__p0, __p1) __extension__ ({ \
- int8x8x3_t __s1 = __p1; \
- int8x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 0); \
+#define vsraq_n_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ uint16x8_t __s1 = __p1; \
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint16x8_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 49); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_f32_x3(__p0, __p1) __extension__ ({ \
- float32x2x3_t __s1 = __p1; \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 9); \
+#define vsraq_n_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x16_t __s0 = __p0; \
+ int8x16_t __s1 = __p1; \
+ __ret = (int8x16_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 32); \
+ __ret; \
})
#else
-#define vst1_f32_x3(__p0, __p1) __extension__ ({ \
- float32x2x3_t __s1 = __p1; \
- float32x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 9); \
+#define vsraq_n_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x16_t __s0 = __p0; \
+ int8x16_t __s1 = __p1; \
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x16_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 32); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_s32_x3(__p0, __p1) __extension__ ({ \
- int32x2x3_t __s1 = __p1; \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 2); \
+#define vsraq_n_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __s1 = __p1; \
+ __ret = (int32x4_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
+ __ret; \
})
#else
-#define vst1_s32_x3(__p0, __p1) __extension__ ({ \
- int32x2x3_t __s1 = __p1; \
- int32x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 2); \
+#define vsraq_n_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __s1 = __p1; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (int32x4_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
-#define vst1_s64_x3(__p0, __p1) __extension__ ({ \
- int64x1x3_t __s1 = __p1; \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 3); \
-})
#ifdef __LITTLE_ENDIAN__
-#define vst1_s16_x3(__p0, __p1) __extension__ ({ \
- int16x4x3_t __s1 = __p1; \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 1); \
+#define vsraq_n_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __s1 = __p1; \
+ __ret = (int64x2_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 35); \
+ __ret; \
})
#else
-#define vst1_s16_x3(__p0, __p1) __extension__ ({ \
- int16x4x3_t __s1 = __p1; \
- int16x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 1); \
+#define vsraq_n_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __s1 = __p1; \
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (int64x2_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 35); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_p8_x4(__p0, __p1) __extension__ ({ \
- poly8x8x4_t __s1 = __p1; \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 4); \
+#define vsraq_n_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __s1 = __p1; \
+ __ret = (int16x8_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
+ __ret; \
})
#else
-#define vst1_p8_x4(__p0, __p1) __extension__ ({ \
- poly8x8x4_t __s1 = __p1; \
- poly8x8x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 4); \
+#define vsraq_n_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __s1 = __p1; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int16x8_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_p16_x4(__p0, __p1) __extension__ ({ \
- poly16x4x4_t __s1 = __p1; \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 5); \
+#define vsra_n_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ uint8x8_t __s1 = __p1; \
+ __ret = (uint8x8_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 16); \
+ __ret; \
})
#else
-#define vst1_p16_x4(__p0, __p1) __extension__ ({ \
- poly16x4x4_t __s1 = __p1; \
- poly16x4x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 5); \
+#define vsra_n_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ uint8x8_t __s1 = __p1; \
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x8_t) __builtin_neon_vsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 16); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_p8_x4(__p0, __p1) __extension__ ({ \
- poly8x16x4_t __s1 = __p1; \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 36); \
+#define vsra_n_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ uint32x2_t __s1 = __p1; \
+ __ret = (uint32x2_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 18); \
+ __ret; \
})
#else
-#define vst1q_p8_x4(__p0, __p1) __extension__ ({ \
- poly8x16x4_t __s1 = __p1; \
- poly8x16x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 36); \
+#define vsra_n_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ uint32x2_t __s1 = __p1; \
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (uint32x2_t) __builtin_neon_vsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 18); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
+#define vsra_n_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x1_t __ret; \
+ uint64x1_t __s0 = __p0; \
+ uint64x1_t __s1 = __p1; \
+ __ret = (uint64x1_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 19); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vst1q_p16_x4(__p0, __p1) __extension__ ({ \
- poly16x8x4_t __s1 = __p1; \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 37); \
+#define vsra_n_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ uint16x4_t __s1 = __p1; \
+ __ret = (uint16x4_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 17); \
+ __ret; \
})
#else
-#define vst1q_p16_x4(__p0, __p1) __extension__ ({ \
- poly16x8x4_t __s1 = __p1; \
- poly16x8x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 37); \
+#define vsra_n_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ uint16x4_t __s1 = __p1; \
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (uint16x4_t) __builtin_neon_vsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_u8_x4(__p0, __p1) __extension__ ({ \
- uint8x16x4_t __s1 = __p1; \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 48); \
+#define vsra_n_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ int8x8_t __s1 = __p1; \
+ __ret = (int8x8_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 0); \
+ __ret; \
})
#else
-#define vst1q_u8_x4(__p0, __p1) __extension__ ({ \
- uint8x16x4_t __s1 = __p1; \
- uint8x16x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 48); \
+#define vsra_n_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ int8x8_t __s1 = __p1; \
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 0); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_u32_x4(__p0, __p1) __extension__ ({ \
- uint32x4x4_t __s1 = __p1; \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 50); \
+#define vsra_n_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __s1 = __p1; \
+ __ret = (int32x2_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
+ __ret; \
})
#else
-#define vst1q_u32_x4(__p0, __p1) __extension__ ({ \
- uint32x4x4_t __s1 = __p1; \
- uint32x4x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 50); \
+#define vsra_n_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __s1 = __p1; \
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (int32x2_t) __builtin_neon_vsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
+#define vsra_n_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x1_t __ret; \
+ int64x1_t __s0 = __p0; \
+ int64x1_t __s1 = __p1; \
+ __ret = (int64x1_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 3); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vst1q_u64_x4(__p0, __p1) __extension__ ({ \
- uint64x2x4_t __s1 = __p1; \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 51); \
+#define vsra_n_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __s1 = __p1; \
+ __ret = (int16x4_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
+ __ret; \
})
#else
-#define vst1q_u64_x4(__p0, __p1) __extension__ ({ \
- uint64x2x4_t __s1 = __p1; \
- uint64x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 51); \
+#define vsra_n_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __s1 = __p1; \
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (int16x4_t) __builtin_neon_vsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_u16_x4(__p0, __p1) __extension__ ({ \
- uint16x8x4_t __s1 = __p1; \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 49); \
+#define vsri_n_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8_t __ret; \
+ poly8x8_t __s0 = __p0; \
+ poly8x8_t __s1 = __p1; \
+ __ret = (poly8x8_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 4); \
+ __ret; \
})
#else
-#define vst1q_u16_x4(__p0, __p1) __extension__ ({ \
- uint16x8x4_t __s1 = __p1; \
- uint16x8x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 49); \
+#define vsri_n_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8_t __ret; \
+ poly8x8_t __s0 = __p0; \
+ poly8x8_t __s1 = __p1; \
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly8x8_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 4); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_s8_x4(__p0, __p1) __extension__ ({ \
- int8x16x4_t __s1 = __p1; \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 32); \
+#define vsri_n_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4_t __ret; \
+ poly16x4_t __s0 = __p0; \
+ poly16x4_t __s1 = __p1; \
+ __ret = (poly16x4_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 5); \
+ __ret; \
})
#else
-#define vst1q_s8_x4(__p0, __p1) __extension__ ({ \
- int8x16x4_t __s1 = __p1; \
- int8x16x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 32); \
+#define vsri_n_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4_t __ret; \
+ poly16x4_t __s0 = __p0; \
+ poly16x4_t __s1 = __p1; \
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (poly16x4_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 5); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_f32_x4(__p0, __p1) __extension__ ({ \
- float32x4x4_t __s1 = __p1; \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 41); \
+#define vsriq_n_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16_t __ret; \
+ poly8x16_t __s0 = __p0; \
+ poly8x16_t __s1 = __p1; \
+ __ret = (poly8x16_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 36); \
+ __ret; \
})
#else
-#define vst1q_f32_x4(__p0, __p1) __extension__ ({ \
- float32x4x4_t __s1 = __p1; \
- float32x4x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 41); \
+#define vsriq_n_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16_t __ret; \
+ poly8x16_t __s0 = __p0; \
+ poly8x16_t __s1 = __p1; \
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly8x16_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 36); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_s32_x4(__p0, __p1) __extension__ ({ \
- int32x4x4_t __s1 = __p1; \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 34); \
+#define vsriq_n_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8_t __ret; \
+ poly16x8_t __s0 = __p0; \
+ poly16x8_t __s1 = __p1; \
+ __ret = (poly16x8_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 37); \
+ __ret; \
})
#else
-#define vst1q_s32_x4(__p0, __p1) __extension__ ({ \
- int32x4x4_t __s1 = __p1; \
- int32x4x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 34); \
+#define vsriq_n_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8_t __ret; \
+ poly16x8_t __s0 = __p0; \
+ poly16x8_t __s1 = __p1; \
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly16x8_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 37); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_s64_x4(__p0, __p1) __extension__ ({ \
- int64x2x4_t __s1 = __p1; \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 35); \
+#define vsriq_n_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ uint8x16_t __s1 = __p1; \
+ __ret = (uint8x16_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 48); \
+ __ret; \
})
#else
-#define vst1q_s64_x4(__p0, __p1) __extension__ ({ \
- int64x2x4_t __s1 = __p1; \
- int64x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 35); \
+#define vsriq_n_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ uint8x16_t __s1 = __p1; \
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x16_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 48); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_s16_x4(__p0, __p1) __extension__ ({ \
- int16x8x4_t __s1 = __p1; \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 33); \
+#define vsriq_n_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ uint32x4_t __s1 = __p1; \
+ __ret = (uint32x4_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 50); \
+ __ret; \
})
#else
-#define vst1q_s16_x4(__p0, __p1) __extension__ ({ \
- int16x8x4_t __s1 = __p1; \
- int16x8x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 33); \
+#define vsriq_n_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ uint32x4_t __s1 = __p1; \
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (uint32x4_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 50); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_u8_x4(__p0, __p1) __extension__ ({ \
- uint8x8x4_t __s1 = __p1; \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 16); \
+#define vsriq_n_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ uint64x2_t __s1 = __p1; \
+ __ret = (uint64x2_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 51); \
+ __ret; \
})
#else
-#define vst1_u8_x4(__p0, __p1) __extension__ ({ \
- uint8x8x4_t __s1 = __p1; \
- uint8x8x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 16); \
+#define vsriq_n_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ uint64x2_t __s1 = __p1; \
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (uint64x2_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 51); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_u32_x4(__p0, __p1) __extension__ ({ \
- uint32x2x4_t __s1 = __p1; \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 18); \
+#define vsriq_n_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ uint16x8_t __s1 = __p1; \
+ __ret = (uint16x8_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 49); \
+ __ret; \
})
#else
-#define vst1_u32_x4(__p0, __p1) __extension__ ({ \
- uint32x2x4_t __s1 = __p1; \
- uint32x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 18); \
+#define vsriq_n_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ uint16x8_t __s1 = __p1; \
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint16x8_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 49); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
-#define vst1_u64_x4(__p0, __p1) __extension__ ({ \
- uint64x1x4_t __s1 = __p1; \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 19); \
-})
#ifdef __LITTLE_ENDIAN__
-#define vst1_u16_x4(__p0, __p1) __extension__ ({ \
- uint16x4x4_t __s1 = __p1; \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 17); \
+#define vsriq_n_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x16_t __s0 = __p0; \
+ int8x16_t __s1 = __p1; \
+ __ret = (int8x16_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 32); \
+ __ret; \
})
#else
-#define vst1_u16_x4(__p0, __p1) __extension__ ({ \
- uint16x4x4_t __s1 = __p1; \
- uint16x4x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 17); \
+#define vsriq_n_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16_t __ret; \
+ int8x16_t __s0 = __p0; \
+ int8x16_t __s1 = __p1; \
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x16_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 32); \
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_s8_x4(__p0, __p1) __extension__ ({ \
- int8x8x4_t __s1 = __p1; \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 0); \
+#define vsriq_n_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __s1 = __p1; \
+ __ret = (int32x4_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
+ __ret; \
})
#else
-#define vst1_s8_x4(__p0, __p1) __extension__ ({ \
- int8x8x4_t __s1 = __p1; \
- int8x8x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 0); \
+#define vsriq_n_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __s1 = __p1; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (int32x4_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_f32_x4(__p0, __p1) __extension__ ({ \
- float32x2x4_t __s1 = __p1; \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 9); \
+#define vsriq_n_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __s1 = __p1; \
+ __ret = (int64x2_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 35); \
+ __ret; \
})
#else
-#define vst1_f32_x4(__p0, __p1) __extension__ ({ \
- float32x2x4_t __s1 = __p1; \
- float32x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 9); \
+#define vsriq_n_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __s1 = __p1; \
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (int64x2_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 35); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_s32_x4(__p0, __p1) __extension__ ({ \
- int32x2x4_t __s1 = __p1; \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 2); \
+#define vsriq_n_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __s1 = __p1; \
+ __ret = (int16x8_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
+ __ret; \
})
#else
-#define vst1_s32_x4(__p0, __p1) __extension__ ({ \
- int32x2x4_t __s1 = __p1; \
- int32x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 2); \
+#define vsriq_n_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __s1 = __p1; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int16x8_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
-#define vst1_s64_x4(__p0, __p1) __extension__ ({ \
- int64x1x4_t __s1 = __p1; \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 3); \
-})
#ifdef __LITTLE_ENDIAN__
-#define vst1_s16_x4(__p0, __p1) __extension__ ({ \
- int16x4x4_t __s1 = __p1; \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 1); \
+#define vsri_n_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ uint8x8_t __s1 = __p1; \
+ __ret = (uint8x8_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 16); \
+ __ret; \
})
#else
-#define vst1_s16_x4(__p0, __p1) __extension__ ({ \
- int16x4x4_t __s1 = __p1; \
- int16x4x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 1); \
+#define vsri_n_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ uint8x8_t __s1 = __p1; \
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8x8_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 16); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2_p8(__p0, __p1) __extension__ ({ \
- poly8x8x2_t __s1 = __p1; \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 4); \
+#define vsri_n_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ uint32x2_t __s1 = __p1; \
+ __ret = (uint32x2_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 18); \
+ __ret; \
})
#else
-#define vst2_p8(__p0, __p1) __extension__ ({ \
- poly8x8x2_t __s1 = __p1; \
- poly8x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 4); \
+#define vsri_n_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ uint32x2_t __s1 = __p1; \
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (uint32x2_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 18); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
+#define vsri_n_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x1_t __ret; \
+ uint64x1_t __s0 = __p0; \
+ uint64x1_t __s1 = __p1; \
+ __ret = (uint64x1_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 19); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vst2_p16(__p0, __p1) __extension__ ({ \
- poly16x4x2_t __s1 = __p1; \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 5); \
+#define vsri_n_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ uint16x4_t __s1 = __p1; \
+ __ret = (uint16x4_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 17); \
+ __ret; \
})
#else
-#define vst2_p16(__p0, __p1) __extension__ ({ \
- poly16x4x2_t __s1 = __p1; \
- poly16x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 5); \
+#define vsri_n_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ uint16x4_t __s1 = __p1; \
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (uint16x4_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 17); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2q_p8(__p0, __p1) __extension__ ({ \
- poly8x16x2_t __s1 = __p1; \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 36); \
+#define vsri_n_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ int8x8_t __s1 = __p1; \
+ __ret = (int8x8_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 0); \
+ __ret; \
})
#else
-#define vst2q_p8(__p0, __p1) __extension__ ({ \
- poly8x16x2_t __s1 = __p1; \
- poly8x16x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 36); \
+#define vsri_n_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ int8x8_t __s1 = __p1; \
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8x8_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 0); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2q_p16(__p0, __p1) __extension__ ({ \
- poly16x8x2_t __s1 = __p1; \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 37); \
+#define vsri_n_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __s1 = __p1; \
+ __ret = (int32x2_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
+ __ret; \
})
#else
-#define vst2q_p16(__p0, __p1) __extension__ ({ \
- poly16x8x2_t __s1 = __p1; \
- poly16x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 37); \
+#define vsri_n_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __s1 = __p1; \
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (int32x2_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
+#define vsri_n_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x1_t __ret; \
+ int64x1_t __s0 = __p0; \
+ int64x1_t __s1 = __p1; \
+ __ret = (int64x1_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 3); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vst2q_u8(__p0, __p1) __extension__ ({ \
- uint8x16x2_t __s1 = __p1; \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 48); \
+#define vsri_n_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __s1 = __p1; \
+ __ret = (int16x4_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
+ __ret; \
})
#else
-#define vst2q_u8(__p0, __p1) __extension__ ({ \
- uint8x16x2_t __s1 = __p1; \
- uint8x16x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 48); \
+#define vsri_n_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __s1 = __p1; \
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (int16x4_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2q_u32(__p0, __p1) __extension__ ({ \
- uint32x4x2_t __s1 = __p1; \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 50); \
+#define vst1_p8(__p0, __p1) __extension__ ({ \
+ poly8x8_t __s1 = __p1; \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 4); \
})
#else
-#define vst2q_u32(__p0, __p1) __extension__ ({ \
- uint32x4x2_t __s1 = __p1; \
- uint32x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 50); \
+#define vst1_p8(__p0, __p1) __extension__ ({ \
+ poly8x8_t __s1 = __p1; \
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 4); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2q_u16(__p0, __p1) __extension__ ({ \
- uint16x8x2_t __s1 = __p1; \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 49); \
+#define vst1_p16(__p0, __p1) __extension__ ({ \
+ poly16x4_t __s1 = __p1; \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 5); \
})
#else
-#define vst2q_u16(__p0, __p1) __extension__ ({ \
- uint16x8x2_t __s1 = __p1; \
- uint16x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 49); \
+#define vst1_p16(__p0, __p1) __extension__ ({ \
+ poly16x4_t __s1 = __p1; \
+ poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 5); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2q_s8(__p0, __p1) __extension__ ({ \
- int8x16x2_t __s1 = __p1; \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 32); \
+#define vst1q_p8(__p0, __p1) __extension__ ({ \
+ poly8x16_t __s1 = __p1; \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 36); \
})
#else
-#define vst2q_s8(__p0, __p1) __extension__ ({ \
- int8x16x2_t __s1 = __p1; \
- int8x16x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 32); \
+#define vst1q_p8(__p0, __p1) __extension__ ({ \
+ poly8x16_t __s1 = __p1; \
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 36); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2q_f32(__p0, __p1) __extension__ ({ \
- float32x4x2_t __s1 = __p1; \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 41); \
+#define vst1q_p16(__p0, __p1) __extension__ ({ \
+ poly16x8_t __s1 = __p1; \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 37); \
})
#else
-#define vst2q_f32(__p0, __p1) __extension__ ({ \
- float32x4x2_t __s1 = __p1; \
- float32x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 41); \
+#define vst1q_p16(__p0, __p1) __extension__ ({ \
+ poly16x8_t __s1 = __p1; \
+ poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 37); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2q_s32(__p0, __p1) __extension__ ({ \
- int32x4x2_t __s1 = __p1; \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 34); \
+#define vst1q_u8(__p0, __p1) __extension__ ({ \
+ uint8x16_t __s1 = __p1; \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 48); \
})
#else
-#define vst2q_s32(__p0, __p1) __extension__ ({ \
- int32x4x2_t __s1 = __p1; \
- int32x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 34); \
+#define vst1q_u8(__p0, __p1) __extension__ ({ \
+ uint8x16_t __s1 = __p1; \
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 48); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2q_s16(__p0, __p1) __extension__ ({ \
- int16x8x2_t __s1 = __p1; \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 33); \
+#define vst1q_u32(__p0, __p1) __extension__ ({ \
+ uint32x4_t __s1 = __p1; \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 50); \
})
#else
-#define vst2q_s16(__p0, __p1) __extension__ ({ \
- int16x8x2_t __s1 = __p1; \
- int16x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 33); \
+#define vst1q_u32(__p0, __p1) __extension__ ({ \
+ uint32x4_t __s1 = __p1; \
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 50); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2_u8(__p0, __p1) __extension__ ({ \
- uint8x8x2_t __s1 = __p1; \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 16); \
+#define vst1q_u64(__p0, __p1) __extension__ ({ \
+ uint64x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 51); \
})
#else
-#define vst2_u8(__p0, __p1) __extension__ ({ \
- uint8x8x2_t __s1 = __p1; \
- uint8x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 16); \
+#define vst1q_u64(__p0, __p1) __extension__ ({ \
+ uint64x2_t __s1 = __p1; \
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 51); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2_u32(__p0, __p1) __extension__ ({ \
- uint32x2x2_t __s1 = __p1; \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 18); \
+#define vst1q_u16(__p0, __p1) __extension__ ({ \
+ uint16x8_t __s1 = __p1; \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 49); \
})
#else
-#define vst2_u32(__p0, __p1) __extension__ ({ \
- uint32x2x2_t __s1 = __p1; \
- uint32x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 18); \
+#define vst1q_u16(__p0, __p1) __extension__ ({ \
+ uint16x8_t __s1 = __p1; \
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 49); \
})
#endif
-#define vst2_u64(__p0, __p1) __extension__ ({ \
- uint64x1x2_t __s1 = __p1; \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 19); \
-})
#ifdef __LITTLE_ENDIAN__
-#define vst2_u16(__p0, __p1) __extension__ ({ \
- uint16x4x2_t __s1 = __p1; \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 17); \
+#define vst1q_s8(__p0, __p1) __extension__ ({ \
+ int8x16_t __s1 = __p1; \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 32); \
})
#else
-#define vst2_u16(__p0, __p1) __extension__ ({ \
- uint16x4x2_t __s1 = __p1; \
- uint16x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 17); \
+#define vst1q_s8(__p0, __p1) __extension__ ({ \
+ int8x16_t __s1 = __p1; \
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 32); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2_s8(__p0, __p1) __extension__ ({ \
- int8x8x2_t __s1 = __p1; \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 0); \
+#define vst1q_f32(__p0, __p1) __extension__ ({ \
+ float32x4_t __s1 = __p1; \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 41); \
})
#else
-#define vst2_s8(__p0, __p1) __extension__ ({ \
- int8x8x2_t __s1 = __p1; \
- int8x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 0); \
+#define vst1q_f32(__p0, __p1) __extension__ ({ \
+ float32x4_t __s1 = __p1; \
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 41); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2_f32(__p0, __p1) __extension__ ({ \
- float32x2x2_t __s1 = __p1; \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 9); \
+#define vst1q_s32(__p0, __p1) __extension__ ({ \
+ int32x4_t __s1 = __p1; \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 34); \
})
#else
-#define vst2_f32(__p0, __p1) __extension__ ({ \
- float32x2x2_t __s1 = __p1; \
- float32x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 9); \
+#define vst1q_s32(__p0, __p1) __extension__ ({ \
+ int32x4_t __s1 = __p1; \
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 34); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2_s32(__p0, __p1) __extension__ ({ \
- int32x2x2_t __s1 = __p1; \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 2); \
+#define vst1q_s64(__p0, __p1) __extension__ ({ \
+ int64x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 35); \
})
#else
-#define vst2_s32(__p0, __p1) __extension__ ({ \
- int32x2x2_t __s1 = __p1; \
- int32x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 2); \
+#define vst1q_s64(__p0, __p1) __extension__ ({ \
+ int64x2_t __s1 = __p1; \
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 35); \
})
#endif
-#define vst2_s64(__p0, __p1) __extension__ ({ \
- int64x1x2_t __s1 = __p1; \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 3); \
-})
#ifdef __LITTLE_ENDIAN__
-#define vst2_s16(__p0, __p1) __extension__ ({ \
- int16x4x2_t __s1 = __p1; \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 1); \
+#define vst1q_s16(__p0, __p1) __extension__ ({ \
+ int16x8_t __s1 = __p1; \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 33); \
})
#else
-#define vst2_s16(__p0, __p1) __extension__ ({ \
- int16x4x2_t __s1 = __p1; \
- int16x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 1); \
+#define vst1q_s16(__p0, __p1) __extension__ ({ \
+ int16x8_t __s1 = __p1; \
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 33); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8x2_t __s1 = __p1; \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 4); \
+#define vst1_u8(__p0, __p1) __extension__ ({ \
+ uint8x8_t __s1 = __p1; \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 16); \
})
#else
-#define vst2_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8x2_t __s1 = __p1; \
- poly8x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 4); \
+#define vst1_u8(__p0, __p1) __extension__ ({ \
+ uint8x8_t __s1 = __p1; \
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 16); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4x2_t __s1 = __p1; \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 5); \
+#define vst1_u32(__p0, __p1) __extension__ ({ \
+ uint32x2_t __s1 = __p1; \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 18); \
})
#else
-#define vst2_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4x2_t __s1 = __p1; \
- poly16x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 5); \
+#define vst1_u32(__p0, __p1) __extension__ ({ \
+ uint32x2_t __s1 = __p1; \
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 18); \
})
#endif
+#define vst1_u64(__p0, __p1) __extension__ ({ \
+ uint64x1_t __s1 = __p1; \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 19); \
+})
#ifdef __LITTLE_ENDIAN__
-#define vst2q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8x2_t __s1 = __p1; \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 37); \
+#define vst1_u16(__p0, __p1) __extension__ ({ \
+ uint16x4_t __s1 = __p1; \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 17); \
})
#else
-#define vst2q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8x2_t __s1 = __p1; \
- poly16x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 37); \
+#define vst1_u16(__p0, __p1) __extension__ ({ \
+ uint16x4_t __s1 = __p1; \
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 17); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4x2_t __s1 = __p1; \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 50); \
+#define vst1_s8(__p0, __p1) __extension__ ({ \
+ int8x8_t __s1 = __p1; \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 0); \
})
#else
-#define vst2q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4x2_t __s1 = __p1; \
- uint32x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 50); \
+#define vst1_s8(__p0, __p1) __extension__ ({ \
+ int8x8_t __s1 = __p1; \
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 0); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8x2_t __s1 = __p1; \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 49); \
+#define vst1_f32(__p0, __p1) __extension__ ({ \
+ float32x2_t __s1 = __p1; \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 9); \
})
#else
-#define vst2q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8x2_t __s1 = __p1; \
- uint16x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 49); \
+#define vst1_f32(__p0, __p1) __extension__ ({ \
+ float32x2_t __s1 = __p1; \
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 9); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x4x2_t __s1 = __p1; \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 41); \
+#define vst1_s32(__p0, __p1) __extension__ ({ \
+ int32x2_t __s1 = __p1; \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 2); \
})
#else
-#define vst2q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x4x2_t __s1 = __p1; \
- float32x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 41); \
+#define vst1_s32(__p0, __p1) __extension__ ({ \
+ int32x2_t __s1 = __p1; \
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 2); \
})
#endif
+#define vst1_s64(__p0, __p1) __extension__ ({ \
+ int64x1_t __s1 = __p1; \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 3); \
+})
#ifdef __LITTLE_ENDIAN__
-#define vst2q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4x2_t __s1 = __p1; \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 34); \
+#define vst1_s16(__p0, __p1) __extension__ ({ \
+ int16x4_t __s1 = __p1; \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 1); \
})
#else
-#define vst2q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4x2_t __s1 = __p1; \
- int32x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 34); \
+#define vst1_s16(__p0, __p1) __extension__ ({ \
+ int16x4_t __s1 = __p1; \
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 1); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8x2_t __s1 = __p1; \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 33); \
+#define vst1_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8_t __s1 = __p1; \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 4); \
})
#else
-#define vst2q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8x2_t __s1 = __p1; \
- int16x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 33); \
+#define vst1_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8_t __s1 = __p1; \
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 4); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8x2_t __s1 = __p1; \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 16); \
+#define vst1_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4_t __s1 = __p1; \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 5); \
})
#else
-#define vst2_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8x2_t __s1 = __p1; \
- uint8x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 16); \
+#define vst1_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4_t __s1 = __p1; \
+ poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 5); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2x2_t __s1 = __p1; \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 18); \
+#define vst1q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16_t __s1 = __p1; \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 36); \
})
#else
-#define vst2_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2x2_t __s1 = __p1; \
- uint32x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 18); \
+#define vst1q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16_t __s1 = __p1; \
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 36); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4x2_t __s1 = __p1; \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 17); \
+#define vst1q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8_t __s1 = __p1; \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 37); \
})
#else
-#define vst2_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4x2_t __s1 = __p1; \
- uint16x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 17); \
+#define vst1q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8_t __s1 = __p1; \
+ poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 37); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8x2_t __s1 = __p1; \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 0); \
+#define vst1q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16_t __s1 = __p1; \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 48); \
})
#else
-#define vst2_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8x2_t __s1 = __p1; \
- int8x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 0); \
+#define vst1q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16_t __s1 = __p1; \
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 48); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x2x2_t __s1 = __p1; \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 9); \
+#define vst1q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4_t __s1 = __p1; \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 50); \
})
#else
-#define vst2_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x2x2_t __s1 = __p1; \
- float32x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 9); \
+#define vst1q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4_t __s1 = __p1; \
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 50); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2x2_t __s1 = __p1; \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 2); \
+#define vst1q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 51); \
})
#else
-#define vst2_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2x2_t __s1 = __p1; \
- int32x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 2); \
+#define vst1q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2_t __s1 = __p1; \
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 51); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4x2_t __s1 = __p1; \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 1); \
+#define vst1q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8_t __s1 = __p1; \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 49); \
})
#else
-#define vst2_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4x2_t __s1 = __p1; \
- int16x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 1); \
+#define vst1q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8_t __s1 = __p1; \
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 49); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3_p8(__p0, __p1) __extension__ ({ \
- poly8x8x3_t __s1 = __p1; \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 4); \
+#define vst1q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16_t __s1 = __p1; \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 32); \
})
#else
-#define vst3_p8(__p0, __p1) __extension__ ({ \
- poly8x8x3_t __s1 = __p1; \
- poly8x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 4); \
+#define vst1q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16_t __s1 = __p1; \
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 32); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3_p16(__p0, __p1) __extension__ ({ \
- poly16x4x3_t __s1 = __p1; \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 5); \
+#define vst1q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4_t __s1 = __p1; \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 41); \
})
#else
-#define vst3_p16(__p0, __p1) __extension__ ({ \
- poly16x4x3_t __s1 = __p1; \
- poly16x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 5); \
+#define vst1q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4_t __s1 = __p1; \
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 41); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3q_p8(__p0, __p1) __extension__ ({ \
- poly8x16x3_t __s1 = __p1; \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 36); \
+#define vst1q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __s1 = __p1; \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 34); \
})
#else
-#define vst3q_p8(__p0, __p1) __extension__ ({ \
- poly8x16x3_t __s1 = __p1; \
- poly8x16x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 36); \
+#define vst1q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __s1 = __p1; \
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 34); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3q_p16(__p0, __p1) __extension__ ({ \
- poly16x8x3_t __s1 = __p1; \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 37); \
+#define vst1q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 35); \
})
#else
-#define vst3q_p16(__p0, __p1) __extension__ ({ \
- poly16x8x3_t __s1 = __p1; \
- poly16x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 37); \
+#define vst1q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2_t __s1 = __p1; \
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 35); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3q_u8(__p0, __p1) __extension__ ({ \
- uint8x16x3_t __s1 = __p1; \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 48); \
+#define vst1q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __s1 = __p1; \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 33); \
})
#else
-#define vst3q_u8(__p0, __p1) __extension__ ({ \
- uint8x16x3_t __s1 = __p1; \
- uint8x16x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 48); \
+#define vst1q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __s1 = __p1; \
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 33); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3q_u32(__p0, __p1) __extension__ ({ \
- uint32x4x3_t __s1 = __p1; \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 50); \
+#define vst1_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8_t __s1 = __p1; \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 16); \
})
#else
-#define vst3q_u32(__p0, __p1) __extension__ ({ \
- uint32x4x3_t __s1 = __p1; \
- uint32x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 50); \
+#define vst1_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8_t __s1 = __p1; \
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 16); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3q_u16(__p0, __p1) __extension__ ({ \
- uint16x8x3_t __s1 = __p1; \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 49); \
+#define vst1_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2_t __s1 = __p1; \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 18); \
})
#else
-#define vst3q_u16(__p0, __p1) __extension__ ({ \
- uint16x8x3_t __s1 = __p1; \
- uint16x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 49); \
+#define vst1_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2_t __s1 = __p1; \
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 18); \
})
#endif
+#define vst1_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x1_t __s1 = __p1; \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 19); \
+})
#ifdef __LITTLE_ENDIAN__
-#define vst3q_s8(__p0, __p1) __extension__ ({ \
- int8x16x3_t __s1 = __p1; \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 32); \
+#define vst1_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4_t __s1 = __p1; \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 17); \
})
#else
-#define vst3q_s8(__p0, __p1) __extension__ ({ \
- int8x16x3_t __s1 = __p1; \
- int8x16x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 32); \
+#define vst1_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4_t __s1 = __p1; \
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 17); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3q_f32(__p0, __p1) __extension__ ({ \
- float32x4x3_t __s1 = __p1; \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 41); \
+#define vst1_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8_t __s1 = __p1; \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 0); \
})
#else
-#define vst3q_f32(__p0, __p1) __extension__ ({ \
- float32x4x3_t __s1 = __p1; \
- float32x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 41); \
+#define vst1_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8_t __s1 = __p1; \
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 0); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3q_s32(__p0, __p1) __extension__ ({ \
- int32x4x3_t __s1 = __p1; \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 34); \
+#define vst1_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2_t __s1 = __p1; \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 9); \
})
#else
-#define vst3q_s32(__p0, __p1) __extension__ ({ \
- int32x4x3_t __s1 = __p1; \
- int32x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 34); \
+#define vst1_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2_t __s1 = __p1; \
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 9); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3q_s16(__p0, __p1) __extension__ ({ \
- int16x8x3_t __s1 = __p1; \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 33); \
+#define vst1_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __s1 = __p1; \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 2); \
})
#else
-#define vst3q_s16(__p0, __p1) __extension__ ({ \
- int16x8x3_t __s1 = __p1; \
- int16x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 33); \
+#define vst1_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __s1 = __p1; \
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 2); \
})
#endif
+#define vst1_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x1_t __s1 = __p1; \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 3); \
+})
#ifdef __LITTLE_ENDIAN__
-#define vst3_u8(__p0, __p1) __extension__ ({ \
- uint8x8x3_t __s1 = __p1; \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 16); \
+#define vst1_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __s1 = __p1; \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 1); \
})
#else
-#define vst3_u8(__p0, __p1) __extension__ ({ \
- uint8x8x3_t __s1 = __p1; \
- uint8x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 16); \
+#define vst1_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __s1 = __p1; \
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 1); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3_u32(__p0, __p1) __extension__ ({ \
- uint32x2x3_t __s1 = __p1; \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 18); \
+#define vst1_p8_x2(__p0, __p1) __extension__ ({ \
+ poly8x8x2_t __s1 = __p1; \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 4); \
})
#else
-#define vst3_u32(__p0, __p1) __extension__ ({ \
- uint32x2x3_t __s1 = __p1; \
- uint32x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 18); \
+#define vst1_p8_x2(__p0, __p1) __extension__ ({ \
+ poly8x8x2_t __s1 = __p1; \
+ poly8x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 4); \
})
#endif
-#define vst3_u64(__p0, __p1) __extension__ ({ \
- uint64x1x3_t __s1 = __p1; \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 19); \
-})
#ifdef __LITTLE_ENDIAN__
-#define vst3_u16(__p0, __p1) __extension__ ({ \
- uint16x4x3_t __s1 = __p1; \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 17); \
+#define vst1_p16_x2(__p0, __p1) __extension__ ({ \
+ poly16x4x2_t __s1 = __p1; \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 5); \
})
#else
-#define vst3_u16(__p0, __p1) __extension__ ({ \
- uint16x4x3_t __s1 = __p1; \
- uint16x4x3_t __rev1; \
+#define vst1_p16_x2(__p0, __p1) __extension__ ({ \
+ poly16x4x2_t __s1 = __p1; \
+ poly16x4x2_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 17); \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 5); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3_s8(__p0, __p1) __extension__ ({ \
- int8x8x3_t __s1 = __p1; \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 0); \
+#define vst1q_p8_x2(__p0, __p1) __extension__ ({ \
+ poly8x16x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 36); \
})
#else
-#define vst3_s8(__p0, __p1) __extension__ ({ \
- int8x8x3_t __s1 = __p1; \
- int8x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 0); \
+#define vst1q_p8_x2(__p0, __p1) __extension__ ({ \
+ poly8x16x2_t __s1 = __p1; \
+ poly8x16x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 36); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3_f32(__p0, __p1) __extension__ ({ \
- float32x2x3_t __s1 = __p1; \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 9); \
+#define vst1q_p16_x2(__p0, __p1) __extension__ ({ \
+ poly16x8x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 37); \
})
#else
-#define vst3_f32(__p0, __p1) __extension__ ({ \
- float32x2x3_t __s1 = __p1; \
- float32x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 9); \
+#define vst1q_p16_x2(__p0, __p1) __extension__ ({ \
+ poly16x8x2_t __s1 = __p1; \
+ poly16x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 37); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3_s32(__p0, __p1) __extension__ ({ \
- int32x2x3_t __s1 = __p1; \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 2); \
+#define vst1q_u8_x2(__p0, __p1) __extension__ ({ \
+ uint8x16x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 48); \
})
#else
-#define vst3_s32(__p0, __p1) __extension__ ({ \
- int32x2x3_t __s1 = __p1; \
- int32x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 2); \
+#define vst1q_u8_x2(__p0, __p1) __extension__ ({ \
+ uint8x16x2_t __s1 = __p1; \
+ uint8x16x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 48); \
})
#endif
-#define vst3_s64(__p0, __p1) __extension__ ({ \
- int64x1x3_t __s1 = __p1; \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 3); \
-})
#ifdef __LITTLE_ENDIAN__
-#define vst3_s16(__p0, __p1) __extension__ ({ \
- int16x4x3_t __s1 = __p1; \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 1); \
+#define vst1q_u32_x2(__p0, __p1) __extension__ ({ \
+ uint32x4x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 50); \
})
#else
-#define vst3_s16(__p0, __p1) __extension__ ({ \
- int16x4x3_t __s1 = __p1; \
- int16x4x3_t __rev1; \
+#define vst1q_u32_x2(__p0, __p1) __extension__ ({ \
+ uint32x4x2_t __s1 = __p1; \
+ uint32x4x2_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 1); \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 50); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8x3_t __s1 = __p1; \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 4); \
+#define vst1q_u64_x2(__p0, __p1) __extension__ ({ \
+ uint64x2x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 51); \
})
#else
-#define vst3_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x8x3_t __s1 = __p1; \
- poly8x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 4); \
+#define vst1q_u64_x2(__p0, __p1) __extension__ ({ \
+ uint64x2x2_t __s1 = __p1; \
+ uint64x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 51); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4x3_t __s1 = __p1; \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 5); \
+#define vst1q_u16_x2(__p0, __p1) __extension__ ({ \
+ uint16x8x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 49); \
})
#else
-#define vst3_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x4x3_t __s1 = __p1; \
- poly16x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 5); \
+#define vst1q_u16_x2(__p0, __p1) __extension__ ({ \
+ uint16x8x2_t __s1 = __p1; \
+ uint16x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 49); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8x3_t __s1 = __p1; \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 37); \
+#define vst1q_s8_x2(__p0, __p1) __extension__ ({ \
+ int8x16x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 32); \
})
#else
-#define vst3q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
- poly16x8x3_t __s1 = __p1; \
- poly16x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 37); \
+#define vst1q_s8_x2(__p0, __p1) __extension__ ({ \
+ int8x16x2_t __s1 = __p1; \
+ int8x16x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 32); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4x3_t __s1 = __p1; \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 50); \
+#define vst1q_f32_x2(__p0, __p1) __extension__ ({ \
+ float32x4x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 41); \
})
#else
-#define vst3q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x4x3_t __s1 = __p1; \
- uint32x4x3_t __rev1; \
+#define vst1q_f32_x2(__p0, __p1) __extension__ ({ \
+ float32x4x2_t __s1 = __p1; \
+ float32x4x2_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 50); \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 41); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8x3_t __s1 = __p1; \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 49); \
+#define vst1q_s32_x2(__p0, __p1) __extension__ ({ \
+ int32x4x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 34); \
})
#else
-#define vst3q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8x3_t __s1 = __p1; \
- uint16x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 49); \
+#define vst1q_s32_x2(__p0, __p1) __extension__ ({ \
+ int32x4x2_t __s1 = __p1; \
+ int32x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 34); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x4x3_t __s1 = __p1; \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 41); \
+#define vst1q_s64_x2(__p0, __p1) __extension__ ({ \
+ int64x2x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 35); \
})
#else
-#define vst3q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x4x3_t __s1 = __p1; \
- float32x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 41); \
+#define vst1q_s64_x2(__p0, __p1) __extension__ ({ \
+ int64x2x2_t __s1 = __p1; \
+ int64x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 35); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4x3_t __s1 = __p1; \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 34); \
+#define vst1q_s16_x2(__p0, __p1) __extension__ ({ \
+ int16x8x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 33); \
})
#else
-#define vst3q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4x3_t __s1 = __p1; \
- int32x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 34); \
+#define vst1q_s16_x2(__p0, __p1) __extension__ ({ \
+ int16x8x2_t __s1 = __p1; \
+ int16x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 33); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8x3_t __s1 = __p1; \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 33); \
-})
-#else
-#define vst3q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8x3_t __s1 = __p1; \
- int16x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 33); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst3_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8x3_t __s1 = __p1; \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 16); \
+#define vst1_u8_x2(__p0, __p1) __extension__ ({ \
+ uint8x8x2_t __s1 = __p1; \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 16); \
})
#else
-#define vst3_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x8x3_t __s1 = __p1; \
- uint8x8x3_t __rev1; \
+#define vst1_u8_x2(__p0, __p1) __extension__ ({ \
+ uint8x8x2_t __s1 = __p1; \
+ uint8x8x2_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 16); \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 16); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2x3_t __s1 = __p1; \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 18); \
+#define vst1_u32_x2(__p0, __p1) __extension__ ({ \
+ uint32x2x2_t __s1 = __p1; \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 18); \
})
#else
-#define vst3_lane_u32(__p0, __p1, __p2) __extension__ ({ \
- uint32x2x3_t __s1 = __p1; \
- uint32x2x3_t __rev1; \
+#define vst1_u32_x2(__p0, __p1) __extension__ ({ \
+ uint32x2x2_t __s1 = __p1; \
+ uint32x2x2_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 18); \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 18); \
})
#endif
+#define vst1_u64_x2(__p0, __p1) __extension__ ({ \
+ uint64x1x2_t __s1 = __p1; \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 19); \
+})
#ifdef __LITTLE_ENDIAN__
-#define vst3_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4x3_t __s1 = __p1; \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 17); \
+#define vst1_u16_x2(__p0, __p1) __extension__ ({ \
+ uint16x4x2_t __s1 = __p1; \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 17); \
})
#else
-#define vst3_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x4x3_t __s1 = __p1; \
- uint16x4x3_t __rev1; \
+#define vst1_u16_x2(__p0, __p1) __extension__ ({ \
+ uint16x4x2_t __s1 = __p1; \
+ uint16x4x2_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 17); \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 17); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8x3_t __s1 = __p1; \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 0); \
+#define vst1_s8_x2(__p0, __p1) __extension__ ({ \
+ int8x8x2_t __s1 = __p1; \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 0); \
})
#else
-#define vst3_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x8x3_t __s1 = __p1; \
- int8x8x3_t __rev1; \
+#define vst1_s8_x2(__p0, __p1) __extension__ ({ \
+ int8x8x2_t __s1 = __p1; \
+ int8x8x2_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 0); \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 0); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x2x3_t __s1 = __p1; \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 9); \
+#define vst1_f32_x2(__p0, __p1) __extension__ ({ \
+ float32x2x2_t __s1 = __p1; \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 9); \
})
#else
-#define vst3_lane_f32(__p0, __p1, __p2) __extension__ ({ \
- float32x2x3_t __s1 = __p1; \
- float32x2x3_t __rev1; \
+#define vst1_f32_x2(__p0, __p1) __extension__ ({ \
+ float32x2x2_t __s1 = __p1; \
+ float32x2x2_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 9); \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 9); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2x3_t __s1 = __p1; \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 2); \
+#define vst1_s32_x2(__p0, __p1) __extension__ ({ \
+ int32x2x2_t __s1 = __p1; \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 2); \
})
#else
-#define vst3_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2x3_t __s1 = __p1; \
- int32x2x3_t __rev1; \
+#define vst1_s32_x2(__p0, __p1) __extension__ ({ \
+ int32x2x2_t __s1 = __p1; \
+ int32x2x2_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 2); \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 2); \
})
#endif
+#define vst1_s64_x2(__p0, __p1) __extension__ ({ \
+ int64x1x2_t __s1 = __p1; \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 3); \
+})
#ifdef __LITTLE_ENDIAN__
-#define vst3_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4x3_t __s1 = __p1; \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 1); \
+#define vst1_s16_x2(__p0, __p1) __extension__ ({ \
+ int16x4x2_t __s1 = __p1; \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 1); \
})
#else
-#define vst3_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4x3_t __s1 = __p1; \
- int16x4x3_t __rev1; \
+#define vst1_s16_x2(__p0, __p1) __extension__ ({ \
+ int16x4x2_t __s1 = __p1; \
+ int16x4x2_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 1); \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 1); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4_p8(__p0, __p1) __extension__ ({ \
- poly8x8x4_t __s1 = __p1; \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 4); \
+#define vst1_p8_x3(__p0, __p1) __extension__ ({ \
+ poly8x8x3_t __s1 = __p1; \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 4); \
})
#else
-#define vst4_p8(__p0, __p1) __extension__ ({ \
- poly8x8x4_t __s1 = __p1; \
- poly8x8x4_t __rev1; \
+#define vst1_p8_x3(__p0, __p1) __extension__ ({ \
+ poly8x8x3_t __s1 = __p1; \
+ poly8x8x3_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 4); \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 4); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4_p16(__p0, __p1) __extension__ ({ \
- poly16x4x4_t __s1 = __p1; \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 5); \
+#define vst1_p16_x3(__p0, __p1) __extension__ ({ \
+ poly16x4x3_t __s1 = __p1; \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 5); \
})
#else
-#define vst4_p16(__p0, __p1) __extension__ ({ \
- poly16x4x4_t __s1 = __p1; \
- poly16x4x4_t __rev1; \
+#define vst1_p16_x3(__p0, __p1) __extension__ ({ \
+ poly16x4x3_t __s1 = __p1; \
+ poly16x4x3_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 5); \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 5); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4q_p8(__p0, __p1) __extension__ ({ \
- poly8x16x4_t __s1 = __p1; \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 36); \
+#define vst1q_p8_x3(__p0, __p1) __extension__ ({ \
+ poly8x16x3_t __s1 = __p1; \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 36); \
})
#else
-#define vst4q_p8(__p0, __p1) __extension__ ({ \
- poly8x16x4_t __s1 = __p1; \
- poly8x16x4_t __rev1; \
+#define vst1q_p8_x3(__p0, __p1) __extension__ ({ \
+ poly8x16x3_t __s1 = __p1; \
+ poly8x16x3_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 36); \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 36); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4q_p16(__p0, __p1) __extension__ ({ \
- poly16x8x4_t __s1 = __p1; \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 37); \
+#define vst1q_p16_x3(__p0, __p1) __extension__ ({ \
+ poly16x8x3_t __s1 = __p1; \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 37); \
})
#else
-#define vst4q_p16(__p0, __p1) __extension__ ({ \
- poly16x8x4_t __s1 = __p1; \
- poly16x8x4_t __rev1; \
+#define vst1q_p16_x3(__p0, __p1) __extension__ ({ \
+ poly16x8x3_t __s1 = __p1; \
+ poly16x8x3_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 37); \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 37); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4q_u8(__p0, __p1) __extension__ ({ \
- uint8x16x4_t __s1 = __p1; \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 48); \
+#define vst1q_u8_x3(__p0, __p1) __extension__ ({ \
+ uint8x16x3_t __s1 = __p1; \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 48); \
})
#else
-#define vst4q_u8(__p0, __p1) __extension__ ({ \
- uint8x16x4_t __s1 = __p1; \
- uint8x16x4_t __rev1; \
+#define vst1q_u8_x3(__p0, __p1) __extension__ ({ \
+ uint8x16x3_t __s1 = __p1; \
+ uint8x16x3_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 48); \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 48); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4q_u32(__p0, __p1) __extension__ ({ \
- uint32x4x4_t __s1 = __p1; \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 50); \
+#define vst1q_u32_x3(__p0, __p1) __extension__ ({ \
+ uint32x4x3_t __s1 = __p1; \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 50); \
})
#else
-#define vst4q_u32(__p0, __p1) __extension__ ({ \
- uint32x4x4_t __s1 = __p1; \
- uint32x4x4_t __rev1; \
+#define vst1q_u32_x3(__p0, __p1) __extension__ ({ \
+ uint32x4x3_t __s1 = __p1; \
+ uint32x4x3_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 50); \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 50); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4q_u16(__p0, __p1) __extension__ ({ \
- uint16x8x4_t __s1 = __p1; \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 49); \
+#define vst1q_u64_x3(__p0, __p1) __extension__ ({ \
+ uint64x2x3_t __s1 = __p1; \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 51); \
})
#else
-#define vst4q_u16(__p0, __p1) __extension__ ({ \
- uint16x8x4_t __s1 = __p1; \
- uint16x8x4_t __rev1; \
+#define vst1q_u64_x3(__p0, __p1) __extension__ ({ \
+ uint64x2x3_t __s1 = __p1; \
+ uint64x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 51); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u16_x3(__p0, __p1) __extension__ ({ \
+ uint16x8x3_t __s1 = __p1; \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 49); \
+})
+#else
+#define vst1q_u16_x3(__p0, __p1) __extension__ ({ \
+ uint16x8x3_t __s1 = __p1; \
+ uint16x8x3_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 49); \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 49); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4q_s8(__p0, __p1) __extension__ ({ \
- int8x16x4_t __s1 = __p1; \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 32); \
+#define vst1q_s8_x3(__p0, __p1) __extension__ ({ \
+ int8x16x3_t __s1 = __p1; \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 32); \
})
#else
-#define vst4q_s8(__p0, __p1) __extension__ ({ \
- int8x16x4_t __s1 = __p1; \
- int8x16x4_t __rev1; \
+#define vst1q_s8_x3(__p0, __p1) __extension__ ({ \
+ int8x16x3_t __s1 = __p1; \
+ int8x16x3_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 32); \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 32); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4q_f32(__p0, __p1) __extension__ ({ \
- float32x4x4_t __s1 = __p1; \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 41); \
+#define vst1q_f32_x3(__p0, __p1) __extension__ ({ \
+ float32x4x3_t __s1 = __p1; \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 41); \
})
#else
-#define vst4q_f32(__p0, __p1) __extension__ ({ \
- float32x4x4_t __s1 = __p1; \
- float32x4x4_t __rev1; \
+#define vst1q_f32_x3(__p0, __p1) __extension__ ({ \
+ float32x4x3_t __s1 = __p1; \
+ float32x4x3_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 41); \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 41); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4q_s32(__p0, __p1) __extension__ ({ \
- int32x4x4_t __s1 = __p1; \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 34); \
+#define vst1q_s32_x3(__p0, __p1) __extension__ ({ \
+ int32x4x3_t __s1 = __p1; \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 34); \
})
#else
-#define vst4q_s32(__p0, __p1) __extension__ ({ \
- int32x4x4_t __s1 = __p1; \
- int32x4x4_t __rev1; \
+#define vst1q_s32_x3(__p0, __p1) __extension__ ({ \
+ int32x4x3_t __s1 = __p1; \
+ int32x4x3_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 34); \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 34); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4q_s16(__p0, __p1) __extension__ ({ \
- int16x8x4_t __s1 = __p1; \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 33); \
+#define vst1q_s64_x3(__p0, __p1) __extension__ ({ \
+ int64x2x3_t __s1 = __p1; \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 35); \
})
#else
-#define vst4q_s16(__p0, __p1) __extension__ ({ \
- int16x8x4_t __s1 = __p1; \
- int16x8x4_t __rev1; \
+#define vst1q_s64_x3(__p0, __p1) __extension__ ({ \
+ int64x2x3_t __s1 = __p1; \
+ int64x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 35); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_s16_x3(__p0, __p1) __extension__ ({ \
+ int16x8x3_t __s1 = __p1; \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 33); \
+})
+#else
+#define vst1q_s16_x3(__p0, __p1) __extension__ ({ \
+ int16x8x3_t __s1 = __p1; \
+ int16x8x3_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 33); \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 33); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4_u8(__p0, __p1) __extension__ ({ \
- uint8x8x4_t __s1 = __p1; \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 16); \
+#define vst1_u8_x3(__p0, __p1) __extension__ ({ \
+ uint8x8x3_t __s1 = __p1; \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 16); \
})
#else
-#define vst4_u8(__p0, __p1) __extension__ ({ \
- uint8x8x4_t __s1 = __p1; \
- uint8x8x4_t __rev1; \
+#define vst1_u8_x3(__p0, __p1) __extension__ ({ \
+ uint8x8x3_t __s1 = __p1; \
+ uint8x8x3_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 16); \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 16); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4_u32(__p0, __p1) __extension__ ({ \
- uint32x2x4_t __s1 = __p1; \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 18); \
+#define vst1_u32_x3(__p0, __p1) __extension__ ({ \
+ uint32x2x3_t __s1 = __p1; \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 18); \
})
#else
-#define vst4_u32(__p0, __p1) __extension__ ({ \
- uint32x2x4_t __s1 = __p1; \
- uint32x2x4_t __rev1; \
+#define vst1_u32_x3(__p0, __p1) __extension__ ({ \
+ uint32x2x3_t __s1 = __p1; \
+ uint32x2x3_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 18); \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 18); \
})
#endif
-#define vst4_u64(__p0, __p1) __extension__ ({ \
- uint64x1x4_t __s1 = __p1; \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 19); \
+#define vst1_u64_x3(__p0, __p1) __extension__ ({ \
+ uint64x1x3_t __s1 = __p1; \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 19); \
})
#ifdef __LITTLE_ENDIAN__
-#define vst4_u16(__p0, __p1) __extension__ ({ \
- uint16x4x4_t __s1 = __p1; \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 17); \
+#define vst1_u16_x3(__p0, __p1) __extension__ ({ \
+ uint16x4x3_t __s1 = __p1; \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 17); \
})
#else
-#define vst4_u16(__p0, __p1) __extension__ ({ \
- uint16x4x4_t __s1 = __p1; \
- uint16x4x4_t __rev1; \
+#define vst1_u16_x3(__p0, __p1) __extension__ ({ \
+ uint16x4x3_t __s1 = __p1; \
+ uint16x4x3_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 17); \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 17); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4_s8(__p0, __p1) __extension__ ({ \
- int8x8x4_t __s1 = __p1; \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 0); \
+#define vst1_s8_x3(__p0, __p1) __extension__ ({ \
+ int8x8x3_t __s1 = __p1; \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 0); \
})
#else
-#define vst4_s8(__p0, __p1) __extension__ ({ \
- int8x8x4_t __s1 = __p1; \
- int8x8x4_t __rev1; \
+#define vst1_s8_x3(__p0, __p1) __extension__ ({ \
+ int8x8x3_t __s1 = __p1; \
+ int8x8x3_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 0); \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 0); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4_f32(__p0, __p1) __extension__ ({ \
- float32x2x4_t __s1 = __p1; \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 9); \
+#define vst1_f32_x3(__p0, __p1) __extension__ ({ \
+ float32x2x3_t __s1 = __p1; \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 9); \
})
#else
-#define vst4_f32(__p0, __p1) __extension__ ({ \
- float32x2x4_t __s1 = __p1; \
- float32x2x4_t __rev1; \
+#define vst1_f32_x3(__p0, __p1) __extension__ ({ \
+ float32x2x3_t __s1 = __p1; \
+ float32x2x3_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 9); \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 9); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4_s32(__p0, __p1) __extension__ ({ \
- int32x2x4_t __s1 = __p1; \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 2); \
+#define vst1_s32_x3(__p0, __p1) __extension__ ({ \
+ int32x2x3_t __s1 = __p1; \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 2); \
})
#else
-#define vst4_s32(__p0, __p1) __extension__ ({ \
- int32x2x4_t __s1 = __p1; \
- int32x2x4_t __rev1; \
+#define vst1_s32_x3(__p0, __p1) __extension__ ({ \
+ int32x2x3_t __s1 = __p1; \
+ int32x2x3_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 2); \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 2); \
})
#endif
-#define vst4_s64(__p0, __p1) __extension__ ({ \
- int64x1x4_t __s1 = __p1; \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 3); \
+#define vst1_s64_x3(__p0, __p1) __extension__ ({ \
+ int64x1x3_t __s1 = __p1; \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 3); \
})
#ifdef __LITTLE_ENDIAN__
-#define vst4_s16(__p0, __p1) __extension__ ({ \
- int16x4x4_t __s1 = __p1; \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 1); \
+#define vst1_s16_x3(__p0, __p1) __extension__ ({ \
+ int16x4x3_t __s1 = __p1; \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 1); \
})
#else
-#define vst4_s16(__p0, __p1) __extension__ ({ \
- int16x4x4_t __s1 = __p1; \
- int16x4x4_t __rev1; \
+#define vst1_s16_x3(__p0, __p1) __extension__ ({ \
+ int16x4x3_t __s1 = __p1; \
+ int16x4x3_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 1); \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 1); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+#define vst1_p8_x4(__p0, __p1) __extension__ ({ \
poly8x8x4_t __s1 = __p1; \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 4); \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 4); \
})
#else
-#define vst4_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+#define vst1_p8_x4(__p0, __p1) __extension__ ({ \
poly8x8x4_t __s1 = __p1; \
poly8x8x4_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 4); \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 4); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+#define vst1_p16_x4(__p0, __p1) __extension__ ({ \
poly16x4x4_t __s1 = __p1; \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 5); \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 5); \
})
#else
-#define vst4_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+#define vst1_p16_x4(__p0, __p1) __extension__ ({ \
poly16x4x4_t __s1 = __p1; \
poly16x4x4_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
__rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 5); \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 5); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+#define vst1q_p8_x4(__p0, __p1) __extension__ ({ \
+ poly8x16x4_t __s1 = __p1; \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 36); \
+})
+#else
+#define vst1q_p8_x4(__p0, __p1) __extension__ ({ \
+ poly8x16x4_t __s1 = __p1; \
+ poly8x16x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 36); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_p16_x4(__p0, __p1) __extension__ ({ \
poly16x8x4_t __s1 = __p1; \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 37); \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 37); \
})
#else
-#define vst4q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+#define vst1q_p16_x4(__p0, __p1) __extension__ ({ \
poly16x8x4_t __s1 = __p1; \
poly16x8x4_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 37); \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 37); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+#define vst1q_u8_x4(__p0, __p1) __extension__ ({ \
+ uint8x16x4_t __s1 = __p1; \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 48); \
+})
+#else
+#define vst1q_u8_x4(__p0, __p1) __extension__ ({ \
+ uint8x16x4_t __s1 = __p1; \
+ uint8x16x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 48); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u32_x4(__p0, __p1) __extension__ ({ \
uint32x4x4_t __s1 = __p1; \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 50); \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 50); \
})
#else
-#define vst4q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+#define vst1q_u32_x4(__p0, __p1) __extension__ ({ \
uint32x4x4_t __s1 = __p1; \
uint32x4x4_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
__rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 50); \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 50); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
- uint16x8x4_t __s1 = __p1; \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 49); \
+#define vst1q_u64_x4(__p0, __p1) __extension__ ({ \
+ uint64x2x4_t __s1 = __p1; \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 51); \
})
#else
-#define vst4q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+#define vst1q_u64_x4(__p0, __p1) __extension__ ({ \
+ uint64x2x4_t __s1 = __p1; \
+ uint64x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 51); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u16_x4(__p0, __p1) __extension__ ({ \
+ uint16x8x4_t __s1 = __p1; \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 49); \
+})
+#else
+#define vst1q_u16_x4(__p0, __p1) __extension__ ({ \
uint16x8x4_t __s1 = __p1; \
uint16x8x4_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 49); \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 49); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+#define vst1q_s8_x4(__p0, __p1) __extension__ ({ \
+ int8x16x4_t __s1 = __p1; \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 32); \
+})
+#else
+#define vst1q_s8_x4(__p0, __p1) __extension__ ({ \
+ int8x16x4_t __s1 = __p1; \
+ int8x16x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 32); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_f32_x4(__p0, __p1) __extension__ ({ \
float32x4x4_t __s1 = __p1; \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 41); \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 41); \
})
#else
-#define vst4q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+#define vst1q_f32_x4(__p0, __p1) __extension__ ({ \
float32x4x4_t __s1 = __p1; \
float32x4x4_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
__rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 41); \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 41); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+#define vst1q_s32_x4(__p0, __p1) __extension__ ({ \
int32x4x4_t __s1 = __p1; \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 34); \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 34); \
})
#else
-#define vst4q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+#define vst1q_s32_x4(__p0, __p1) __extension__ ({ \
int32x4x4_t __s1 = __p1; \
int32x4x4_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
__rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 34); \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 34); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+#define vst1q_s64_x4(__p0, __p1) __extension__ ({ \
+ int64x2x4_t __s1 = __p1; \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 35); \
+})
+#else
+#define vst1q_s64_x4(__p0, __p1) __extension__ ({ \
+ int64x2x4_t __s1 = __p1; \
+ int64x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 35); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_s16_x4(__p0, __p1) __extension__ ({ \
int16x8x4_t __s1 = __p1; \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 33); \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 33); \
})
#else
-#define vst4q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+#define vst1q_s16_x4(__p0, __p1) __extension__ ({ \
int16x8x4_t __s1 = __p1; \
int16x8x4_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 33); \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 33); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+#define vst1_u8_x4(__p0, __p1) __extension__ ({ \
uint8x8x4_t __s1 = __p1; \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 16); \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 16); \
})
#else
-#define vst4_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+#define vst1_u8_x4(__p0, __p1) __extension__ ({ \
uint8x8x4_t __s1 = __p1; \
uint8x8x4_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 16); \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 16); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+#define vst1_u32_x4(__p0, __p1) __extension__ ({ \
uint32x2x4_t __s1 = __p1; \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 18); \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 18); \
})
#else
-#define vst4_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+#define vst1_u32_x4(__p0, __p1) __extension__ ({ \
uint32x2x4_t __s1 = __p1; \
uint32x2x4_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
__rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 18); \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 18); \
})
#endif
+#define vst1_u64_x4(__p0, __p1) __extension__ ({ \
+ uint64x1x4_t __s1 = __p1; \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 19); \
+})
#ifdef __LITTLE_ENDIAN__
-#define vst4_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+#define vst1_u16_x4(__p0, __p1) __extension__ ({ \
uint16x4x4_t __s1 = __p1; \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 17); \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 17); \
})
#else
-#define vst4_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+#define vst1_u16_x4(__p0, __p1) __extension__ ({ \
uint16x4x4_t __s1 = __p1; \
uint16x4x4_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
__rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 17); \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 17); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+#define vst1_s8_x4(__p0, __p1) __extension__ ({ \
int8x8x4_t __s1 = __p1; \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 0); \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 0); \
})
#else
-#define vst4_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+#define vst1_s8_x4(__p0, __p1) __extension__ ({ \
int8x8x4_t __s1 = __p1; \
int8x8x4_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
__rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 0); \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 0); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+#define vst1_f32_x4(__p0, __p1) __extension__ ({ \
float32x2x4_t __s1 = __p1; \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 9); \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 9); \
})
#else
-#define vst4_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+#define vst1_f32_x4(__p0, __p1) __extension__ ({ \
float32x2x4_t __s1 = __p1; \
float32x2x4_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
__rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 9); \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 9); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+#define vst1_s32_x4(__p0, __p1) __extension__ ({ \
int32x2x4_t __s1 = __p1; \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 2); \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 2); \
})
#else
-#define vst4_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+#define vst1_s32_x4(__p0, __p1) __extension__ ({ \
int32x2x4_t __s1 = __p1; \
int32x2x4_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
__rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 2); \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 2); \
})
#endif
+#define vst1_s64_x4(__p0, __p1) __extension__ ({ \
+ int64x1x4_t __s1 = __p1; \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 3); \
+})
#ifdef __LITTLE_ENDIAN__
-#define vst4_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+#define vst1_s16_x4(__p0, __p1) __extension__ ({ \
int16x4x4_t __s1 = __p1; \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 1); \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 1); \
})
#else
-#define vst4_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+#define vst1_s16_x4(__p0, __p1) __extension__ ({ \
int16x4x4_t __s1 = __p1; \
int16x4x4_t __rev1; \
__rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
__rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
__rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
__rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 1); \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 1); \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vsubq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
+#define vst2_p8(__p0, __p1) __extension__ ({ \
+ poly8x8x2_t __s1 = __p1; \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 4); \
+})
#else
-__ai uint8x16_t vsubq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2_p8(__p0, __p1) __extension__ ({ \
+ poly8x8x2_t __s1 = __p1; \
+ poly8x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 4); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vsubq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
+#define vst2_p16(__p0, __p1) __extension__ ({ \
+ poly16x4x2_t __s1 = __p1; \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 5); \
+})
#else
-__ai uint32x4_t vsubq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2_p16(__p0, __p1) __extension__ ({ \
+ poly16x4x2_t __s1 = __p1; \
+ poly16x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 5); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vsubq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
+#define vst2q_p8(__p0, __p1) __extension__ ({ \
+ poly8x16x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 36); \
+})
#else
-__ai uint64x2_t vsubq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst2q_p8(__p0, __p1) __extension__ ({ \
+ poly8x16x2_t __s1 = __p1; \
+ poly8x16x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 36); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vsubq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
+#define vst2q_p16(__p0, __p1) __extension__ ({ \
+ poly16x8x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 37); \
+})
#else
-__ai uint16x8_t vsubq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2q_p16(__p0, __p1) __extension__ ({ \
+ poly16x8x2_t __s1 = __p1; \
+ poly16x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 37); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vsubq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
+#define vst2q_u8(__p0, __p1) __extension__ ({ \
+ uint8x16x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 48); \
+})
#else
-__ai int8x16_t vsubq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2q_u8(__p0, __p1) __extension__ ({ \
+ uint8x16x2_t __s1 = __p1; \
+ uint8x16x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 48); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vsubq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
+#define vst2q_u32(__p0, __p1) __extension__ ({ \
+ uint32x4x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 50); \
+})
#else
-__ai float32x4_t vsubq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2q_u32(__p0, __p1) __extension__ ({ \
+ uint32x4x2_t __s1 = __p1; \
+ uint32x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 50); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vsubq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
+#define vst2q_u16(__p0, __p1) __extension__ ({ \
+ uint16x8x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 49); \
+})
#else
-__ai int32x4_t vsubq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2q_u16(__p0, __p1) __extension__ ({ \
+ uint16x8x2_t __s1 = __p1; \
+ uint16x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 49); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vsubq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
+#define vst2q_s8(__p0, __p1) __extension__ ({ \
+ int8x16x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 32); \
+})
#else
-__ai int64x2_t vsubq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst2q_s8(__p0, __p1) __extension__ ({ \
+ int8x16x2_t __s1 = __p1; \
+ int8x16x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 32); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vsubq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
+#define vst2q_f32(__p0, __p1) __extension__ ({ \
+ float32x4x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 41); \
+})
#else
-__ai int16x8_t vsubq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2q_f32(__p0, __p1) __extension__ ({ \
+ float32x4x2_t __s1 = __p1; \
+ float32x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 41); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vsub_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
+#define vst2q_s32(__p0, __p1) __extension__ ({ \
+ int32x4x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 34); \
+})
#else
-__ai uint8x8_t vsub_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2q_s32(__p0, __p1) __extension__ ({ \
+ int32x4x2_t __s1 = __p1; \
+ int32x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 34); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vsub_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
+#define vst2q_s16(__p0, __p1) __extension__ ({ \
+ int16x8x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 33); \
+})
#else
-__ai uint32x2_t vsub_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst2q_s16(__p0, __p1) __extension__ ({ \
+ int16x8x2_t __s1 = __p1; \
+ int16x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 33); \
+})
#endif
-__ai uint64x1_t vsub_u64(uint64x1_t __p0, uint64x1_t __p1) {
- uint64x1_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vsub_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
+#define vst2_u8(__p0, __p1) __extension__ ({ \
+ uint8x8x2_t __s1 = __p1; \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 16); \
+})
#else
-__ai uint16x4_t vsub_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2_u8(__p0, __p1) __extension__ ({ \
+ uint8x8x2_t __s1 = __p1; \
+ uint8x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 16); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vsub_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
+#define vst2_u32(__p0, __p1) __extension__ ({ \
+ uint32x2x2_t __s1 = __p1; \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 18); \
+})
#else
-__ai int8x8_t vsub_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2_u32(__p0, __p1) __extension__ ({ \
+ uint32x2x2_t __s1 = __p1; \
+ uint32x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 18); \
+})
#endif
+#define vst2_u64(__p0, __p1) __extension__ ({ \
+ uint64x1x2_t __s1 = __p1; \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 19); \
+})
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vsub_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
+#define vst2_u16(__p0, __p1) __extension__ ({ \
+ uint16x4x2_t __s1 = __p1; \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 17); \
+})
#else
-__ai float32x2_t vsub_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst2_u16(__p0, __p1) __extension__ ({ \
+ uint16x4x2_t __s1 = __p1; \
+ uint16x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 17); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vsub_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
+#define vst2_s8(__p0, __p1) __extension__ ({ \
+ int8x8x2_t __s1 = __p1; \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 0); \
+})
#else
-__ai int32x2_t vsub_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst2_s8(__p0, __p1) __extension__ ({ \
+ int8x8x2_t __s1 = __p1; \
+ int8x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 0); \
+})
#endif
-__ai int64x1_t vsub_s64(int64x1_t __p0, int64x1_t __p1) {
- int64x1_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vsub_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
+#define vst2_f32(__p0, __p1) __extension__ ({ \
+ float32x2x2_t __s1 = __p1; \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 9); \
+})
#else
-__ai int16x4_t vsub_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2_f32(__p0, __p1) __extension__ ({ \
+ float32x2x2_t __s1 = __p1; \
+ float32x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 9); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vsubhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
- return __ret;
-}
-#else
-__ai uint16x4_t vsubhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint16x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai uint16x4_t __noswap_vsubhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vsubhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
- return __ret;
-}
+#define vst2_s32(__p0, __p1) __extension__ ({ \
+ int32x2x2_t __s1 = __p1; \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 2); \
+})
#else
-__ai uint32x2_t vsubhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint32x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai uint32x2_t __noswap_vsubhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
- return __ret;
-}
+#define vst2_s32(__p0, __p1) __extension__ ({ \
+ int32x2x2_t __s1 = __p1; \
+ int32x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 2); \
+})
#endif
+#define vst2_s64(__p0, __p1) __extension__ ({ \
+ int64x1x2_t __s1 = __p1; \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 3); \
+})
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vsubhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
- return __ret;
-}
+#define vst2_s16(__p0, __p1) __extension__ ({ \
+ int16x4x2_t __s1 = __p1; \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 1); \
+})
#else
-__ai uint8x8_t vsubhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint8x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-__ai uint8x8_t __noswap_vsubhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
- return __ret;
-}
+#define vst2_s16(__p0, __p1) __extension__ ({ \
+ int16x4x2_t __s1 = __p1; \
+ int16x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 1); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vsubhn_s32(int32x4_t __p0, int32x4_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
- return __ret;
-}
+#define vst2_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8x2_t __s1 = __p1; \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 4); \
+})
#else
-__ai int16x4_t vsubhn_s32(int32x4_t __p0, int32x4_t __p1) {
- int16x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai int16x4_t __noswap_vsubhn_s32(int32x4_t __p0, int32x4_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
- return __ret;
-}
+#define vst2_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8x2_t __s1 = __p1; \
+ poly8x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 4); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vsubhn_s64(int64x2_t __p0, int64x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
- return __ret;
-}
+#define vst2_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4x2_t __s1 = __p1; \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 5); \
+})
#else
-__ai int32x2_t vsubhn_s64(int64x2_t __p0, int64x2_t __p1) {
- int32x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai int32x2_t __noswap_vsubhn_s64(int64x2_t __p0, int64x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
- return __ret;
-}
+#define vst2_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4x2_t __s1 = __p1; \
+ poly16x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 5); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vsubhn_s16(int16x8_t __p0, int16x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
- return __ret;
-}
+#define vst2q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 37); \
+})
#else
-__ai int8x8_t vsubhn_s16(int16x8_t __p0, int16x8_t __p1) {
- int8x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-__ai int8x8_t __noswap_vsubhn_s16(int16x8_t __p0, int16x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
- return __ret;
-}
+#define vst2q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8x2_t __s1 = __p1; \
+ poly16x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 37); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vsubl_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint16x8_t __ret;
- __ret = vmovl_u8(__p0) - vmovl_u8(__p1);
- return __ret;
-}
+#define vst2q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 50); \
+})
#else
-__ai uint16x8_t vsubl_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint16x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vmovl_u8(__rev0) - __noswap_vmovl_u8(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4x2_t __s1 = __p1; \
+ uint32x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 50); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vsubl_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint64x2_t __ret;
- __ret = vmovl_u32(__p0) - vmovl_u32(__p1);
- return __ret;
-}
+#define vst2q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 49); \
+})
#else
-__ai uint64x2_t vsubl_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint64x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __noswap_vmovl_u32(__rev0) - __noswap_vmovl_u32(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst2q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8x2_t __s1 = __p1; \
+ uint16x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 49); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vsubl_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint32x4_t __ret;
- __ret = vmovl_u16(__p0) - vmovl_u16(__p1);
- return __ret;
-}
+#define vst2q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 41); \
+})
#else
-__ai uint32x4_t vsubl_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint32x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vmovl_u16(__rev0) - __noswap_vmovl_u16(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4x2_t __s1 = __p1; \
+ float32x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 41); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vsubl_s8(int8x8_t __p0, int8x8_t __p1) {
- int16x8_t __ret;
- __ret = vmovl_s8(__p0) - vmovl_s8(__p1);
- return __ret;
-}
+#define vst2q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 34); \
+})
#else
-__ai int16x8_t vsubl_s8(int8x8_t __p0, int8x8_t __p1) {
- int16x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vmovl_s8(__rev0) - __noswap_vmovl_s8(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4x2_t __s1 = __p1; \
+ int32x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 34); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vsubl_s32(int32x2_t __p0, int32x2_t __p1) {
- int64x2_t __ret;
- __ret = vmovl_s32(__p0) - vmovl_s32(__p1);
- return __ret;
-}
+#define vst2q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 33); \
+})
#else
-__ai int64x2_t vsubl_s32(int32x2_t __p0, int32x2_t __p1) {
- int64x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __noswap_vmovl_s32(__rev0) - __noswap_vmovl_s32(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst2q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8x2_t __s1 = __p1; \
+ int16x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 33); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vsubl_s16(int16x4_t __p0, int16x4_t __p1) {
- int32x4_t __ret;
- __ret = vmovl_s16(__p0) - vmovl_s16(__p1);
- return __ret;
-}
+#define vst2_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8x2_t __s1 = __p1; \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 16); \
+})
#else
-__ai int32x4_t vsubl_s16(int16x4_t __p0, int16x4_t __p1) {
- int32x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vmovl_s16(__rev0) - __noswap_vmovl_s16(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8x2_t __s1 = __p1; \
+ uint8x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 16); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vsubw_u8(uint16x8_t __p0, uint8x8_t __p1) {
- uint16x8_t __ret;
- __ret = __p0 - vmovl_u8(__p1);
- return __ret;
-}
+#define vst2_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2x2_t __s1 = __p1; \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 18); \
+})
#else
-__ai uint16x8_t vsubw_u8(uint16x8_t __p0, uint8x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __noswap_vmovl_u8(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2x2_t __s1 = __p1; \
+ uint32x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 18); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vsubw_u32(uint64x2_t __p0, uint32x2_t __p1) {
- uint64x2_t __ret;
- __ret = __p0 - vmovl_u32(__p1);
- return __ret;
-}
+#define vst2_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4x2_t __s1 = __p1; \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 17); \
+})
#else
-__ai uint64x2_t vsubw_u32(uint64x2_t __p0, uint32x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 - __noswap_vmovl_u32(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst2_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4x2_t __s1 = __p1; \
+ uint16x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 17); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vsubw_u16(uint32x4_t __p0, uint16x4_t __p1) {
- uint32x4_t __ret;
- __ret = __p0 - vmovl_u16(__p1);
- return __ret;
-}
+#define vst2_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8x2_t __s1 = __p1; \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 0); \
+})
#else
-__ai uint32x4_t vsubw_u16(uint32x4_t __p0, uint16x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 - __noswap_vmovl_u16(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8x2_t __s1 = __p1; \
+ int8x8x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 0); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vsubw_s8(int16x8_t __p0, int8x8_t __p1) {
- int16x8_t __ret;
- __ret = __p0 - vmovl_s8(__p1);
- return __ret;
-}
+#define vst2_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2x2_t __s1 = __p1; \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 9); \
+})
#else
-__ai int16x8_t vsubw_s8(int16x8_t __p0, int8x8_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __noswap_vmovl_s8(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2x2_t __s1 = __p1; \
+ float32x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 9); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vsubw_s32(int64x2_t __p0, int32x2_t __p1) {
- int64x2_t __ret;
- __ret = __p0 - vmovl_s32(__p1);
- return __ret;
-}
+#define vst2_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2x2_t __s1 = __p1; \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 2); \
+})
#else
-__ai int64x2_t vsubw_s32(int64x2_t __p0, int32x2_t __p1) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 - __noswap_vmovl_s32(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst2_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2x2_t __s1 = __p1; \
+ int32x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 2); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vsubw_s16(int32x4_t __p0, int16x4_t __p1) {
- int32x4_t __ret;
- __ret = __p0 - vmovl_s16(__p1);
- return __ret;
-}
+#define vst2_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4x2_t __s1 = __p1; \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 1); \
+})
#else
-__ai int32x4_t vsubw_s16(int32x4_t __p0, int16x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 - __noswap_vmovl_s16(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4x2_t __s1 = __p1; \
+ int16x4x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 1); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vtbl1_p8(poly8x8_t __p0, uint8x8_t __p1) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vtbl1_v((int8x8_t)__p0, (int8x8_t)__p1, 4);
- return __ret;
-}
+#define vst3_p8(__p0, __p1) __extension__ ({ \
+ poly8x8x3_t __s1 = __p1; \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 4); \
+})
#else
-__ai poly8x8_t vtbl1_p8(poly8x8_t __p0, uint8x8_t __p1) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vtbl1_v((int8x8_t)__rev0, (int8x8_t)__rev1, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3_p8(__p0, __p1) __extension__ ({ \
+ poly8x8x3_t __s1 = __p1; \
+ poly8x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 4); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vtbl1_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vtbl1_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
- return __ret;
-}
+#define vst3_p16(__p0, __p1) __extension__ ({ \
+ poly16x4x3_t __s1 = __p1; \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 5); \
+})
#else
-__ai uint8x8_t vtbl1_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vtbl1_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3_p16(__p0, __p1) __extension__ ({ \
+ poly16x4x3_t __s1 = __p1; \
+ poly16x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 5); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vtbl1_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vtbl1_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
- return __ret;
-}
+#define vst3q_p8(__p0, __p1) __extension__ ({ \
+ poly8x16x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 36); \
+})
#else
-__ai int8x8_t vtbl1_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vtbl1_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_p8(__p0, __p1) __extension__ ({ \
+ poly8x16x3_t __s1 = __p1; \
+ poly8x16x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 36); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vtbl2_p8(poly8x8x2_t __p0, uint8x8_t __p1) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vtbl2_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p1, 4);
- return __ret;
-}
+#define vst3q_p16(__p0, __p1) __extension__ ({ \
+ poly16x8x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 37); \
+})
#else
-__ai poly8x8_t vtbl2_p8(poly8x8x2_t __p0, uint8x8_t __p1) {
- poly8x8_t __ret;
- poly8x8x2_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vtbl2_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev1, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_p16(__p0, __p1) __extension__ ({ \
+ poly16x8x3_t __s1 = __p1; \
+ poly16x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 37); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vtbl2_u8(uint8x8x2_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vtbl2_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p1, 16);
- return __ret;
-}
-#else
-__ai uint8x8_t vtbl2_u8(uint8x8x2_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8x2_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vtbl2_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev1, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_u8(__p0, __p1) __extension__ ({ \
+ uint8x16x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 48); \
+})
+#else
+#define vst3q_u8(__p0, __p1) __extension__ ({ \
+ uint8x16x3_t __s1 = __p1; \
+ uint8x16x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 48); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vtbl2_s8(int8x8x2_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vtbl2_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p1, 0);
- return __ret;
-}
+#define vst3q_u32(__p0, __p1) __extension__ ({ \
+ uint32x4x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 50); \
+})
#else
-__ai int8x8_t vtbl2_s8(int8x8x2_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8x2_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vtbl2_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_u32(__p0, __p1) __extension__ ({ \
+ uint32x4x3_t __s1 = __p1; \
+ uint32x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 50); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vtbl3_p8(poly8x8x3_t __p0, uint8x8_t __p1) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vtbl3_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p0.val[2], (int8x8_t)__p1, 4);
- return __ret;
-}
+#define vst3q_u16(__p0, __p1) __extension__ ({ \
+ uint16x8x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 49); \
+})
#else
-__ai poly8x8_t vtbl3_p8(poly8x8x3_t __p0, uint8x8_t __p1) {
- poly8x8_t __ret;
- poly8x8x3_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vtbl3_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev0.val[2], (int8x8_t)__rev1, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_u16(__p0, __p1) __extension__ ({ \
+ uint16x8x3_t __s1 = __p1; \
+ uint16x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 49); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vtbl3_u8(uint8x8x3_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vtbl3_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p0.val[2], (int8x8_t)__p1, 16);
- return __ret;
-}
+#define vst3q_s8(__p0, __p1) __extension__ ({ \
+ int8x16x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 32); \
+})
#else
-__ai uint8x8_t vtbl3_u8(uint8x8x3_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8x3_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vtbl3_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev0.val[2], (int8x8_t)__rev1, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_s8(__p0, __p1) __extension__ ({ \
+ int8x16x3_t __s1 = __p1; \
+ int8x16x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 32); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vtbl3_s8(int8x8x3_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vtbl3_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p0.val[2], (int8x8_t)__p1, 0);
- return __ret;
-}
+#define vst3q_f32(__p0, __p1) __extension__ ({ \
+ float32x4x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 41); \
+})
#else
-__ai int8x8_t vtbl3_s8(int8x8x3_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8x3_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vtbl3_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev0.val[2], (int8x8_t)__rev1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_f32(__p0, __p1) __extension__ ({ \
+ float32x4x3_t __s1 = __p1; \
+ float32x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 41); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vtbl4_p8(poly8x8x4_t __p0, uint8x8_t __p1) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vtbl4_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p0.val[2], (int8x8_t)__p0.val[3], (int8x8_t)__p1, 4);
- return __ret;
-}
+#define vst3q_s32(__p0, __p1) __extension__ ({ \
+ int32x4x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 34); \
+})
#else
-__ai poly8x8_t vtbl4_p8(poly8x8x4_t __p0, uint8x8_t __p1) {
- poly8x8_t __ret;
- poly8x8x4_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vtbl4_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev0.val[2], (int8x8_t)__rev0.val[3], (int8x8_t)__rev1, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_s32(__p0, __p1) __extension__ ({ \
+ int32x4x3_t __s1 = __p1; \
+ int32x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 34); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vtbl4_u8(uint8x8x4_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vtbl4_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p0.val[2], (int8x8_t)__p0.val[3], (int8x8_t)__p1, 16);
- return __ret;
-}
+#define vst3q_s16(__p0, __p1) __extension__ ({ \
+ int16x8x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 33); \
+})
#else
-__ai uint8x8_t vtbl4_u8(uint8x8x4_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8x4_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vtbl4_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev0.val[2], (int8x8_t)__rev0.val[3], (int8x8_t)__rev1, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_s16(__p0, __p1) __extension__ ({ \
+ int16x8x3_t __s1 = __p1; \
+ int16x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 33); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vtbl4_s8(int8x8x4_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vtbl4_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p0.val[2], (int8x8_t)__p0.val[3], (int8x8_t)__p1, 0);
- return __ret;
-}
+#define vst3_u8(__p0, __p1) __extension__ ({ \
+ uint8x8x3_t __s1 = __p1; \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 16); \
+})
#else
-__ai int8x8_t vtbl4_s8(int8x8x4_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8x4_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vtbl4_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev0.val[2], (int8x8_t)__rev0.val[3], (int8x8_t)__rev1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3_u8(__p0, __p1) __extension__ ({ \
+ uint8x8x3_t __s1 = __p1; \
+ uint8x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 16); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vtbx1_p8(poly8x8_t __p0, poly8x8_t __p1, uint8x8_t __p2) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vtbx1_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 4);
- return __ret;
-}
+#define vst3_u32(__p0, __p1) __extension__ ({ \
+ uint32x2x3_t __s1 = __p1; \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 18); \
+})
#else
-__ai poly8x8_t vtbx1_p8(poly8x8_t __p0, poly8x8_t __p1, uint8x8_t __p2) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vtbx1_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3_u32(__p0, __p1) __extension__ ({ \
+ uint32x2x3_t __s1 = __p1; \
+ uint32x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 18); \
+})
#endif
+#define vst3_u64(__p0, __p1) __extension__ ({ \
+ uint64x1x3_t __s1 = __p1; \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 19); \
+})
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vtbx1_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vtbx1_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 16);
- return __ret;
-}
+#define vst3_u16(__p0, __p1) __extension__ ({ \
+ uint16x4x3_t __s1 = __p1; \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 17); \
+})
#else
-__ai uint8x8_t vtbx1_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vtbx1_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3_u16(__p0, __p1) __extension__ ({ \
+ uint16x4x3_t __s1 = __p1; \
+ uint16x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 17); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vtbx1_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vtbx1_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 0);
- return __ret;
-}
+#define vst3_s8(__p0, __p1) __extension__ ({ \
+ int8x8x3_t __s1 = __p1; \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 0); \
+})
#else
-__ai int8x8_t vtbx1_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vtbx1_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3_s8(__p0, __p1) __extension__ ({ \
+ int8x8x3_t __s1 = __p1; \
+ int8x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 0); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vtbx2_p8(poly8x8_t __p0, poly8x8x2_t __p1, uint8x8_t __p2) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vtbx2_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p2, 4);
- return __ret;
-}
+#define vst3_f32(__p0, __p1) __extension__ ({ \
+ float32x2x3_t __s1 = __p1; \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 9); \
+})
#else
-__ai poly8x8_t vtbx2_p8(poly8x8_t __p0, poly8x8x2_t __p1, uint8x8_t __p2) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8x2_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vtbx2_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev2, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3_f32(__p0, __p1) __extension__ ({ \
+ float32x2x3_t __s1 = __p1; \
+ float32x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 9); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vtbx2_u8(uint8x8_t __p0, uint8x8x2_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vtbx2_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p2, 16);
- return __ret;
-}
+#define vst3_s32(__p0, __p1) __extension__ ({ \
+ int32x2x3_t __s1 = __p1; \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 2); \
+})
#else
-__ai uint8x8_t vtbx2_u8(uint8x8_t __p0, uint8x8x2_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8x2_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vtbx2_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev2, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3_s32(__p0, __p1) __extension__ ({ \
+ int32x2x3_t __s1 = __p1; \
+ int32x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 2); \
+})
#endif
+#define vst3_s64(__p0, __p1) __extension__ ({ \
+ int64x1x3_t __s1 = __p1; \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 3); \
+})
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vtbx2_s8(int8x8_t __p0, int8x8x2_t __p1, int8x8_t __p2) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vtbx2_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p2, 0);
- return __ret;
-}
+#define vst3_s16(__p0, __p1) __extension__ ({ \
+ int16x4x3_t __s1 = __p1; \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 1); \
+})
#else
-__ai int8x8_t vtbx2_s8(int8x8_t __p0, int8x8x2_t __p1, int8x8_t __p2) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8x2_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vtbx2_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev2, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3_s16(__p0, __p1) __extension__ ({ \
+ int16x4x3_t __s1 = __p1; \
+ int16x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 1); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vtbx3_p8(poly8x8_t __p0, poly8x8x3_t __p1, uint8x8_t __p2) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vtbx3_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p1.val[2], (int8x8_t)__p2, 4);
- return __ret;
-}
+#define vst3_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8x3_t __s1 = __p1; \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 4); \
+})
#else
-__ai poly8x8_t vtbx3_p8(poly8x8_t __p0, poly8x8x3_t __p1, uint8x8_t __p2) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8x3_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vtbx3_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev2, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8x3_t __s1 = __p1; \
+ poly8x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 4); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vtbx3_u8(uint8x8_t __p0, uint8x8x3_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vtbx3_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p1.val[2], (int8x8_t)__p2, 16);
- return __ret;
-}
+#define vst3_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4x3_t __s1 = __p1; \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 5); \
+})
#else
-__ai uint8x8_t vtbx3_u8(uint8x8_t __p0, uint8x8x3_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8x3_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vtbx3_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev2, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4x3_t __s1 = __p1; \
+ poly16x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 5); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vtbx3_s8(int8x8_t __p0, int8x8x3_t __p1, int8x8_t __p2) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vtbx3_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p1.val[2], (int8x8_t)__p2, 0);
- return __ret;
-}
+#define vst3q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 37); \
+})
#else
-__ai int8x8_t vtbx3_s8(int8x8_t __p0, int8x8x3_t __p1, int8x8_t __p2) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8x3_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vtbx3_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev2, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8x3_t __s1 = __p1; \
+ poly16x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 37); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vtbx4_p8(poly8x8_t __p0, poly8x8x4_t __p1, uint8x8_t __p2) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vtbx4_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p1.val[2], (int8x8_t)__p1.val[3], (int8x8_t)__p2, 4);
- return __ret;
-}
+#define vst3q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 50); \
+})
#else
-__ai poly8x8_t vtbx4_p8(poly8x8_t __p0, poly8x8x4_t __p1, uint8x8_t __p2) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8x4_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vtbx4_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], (int8x8_t)__rev2, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4x3_t __s1 = __p1; \
+ uint32x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 50); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vtbx4_u8(uint8x8_t __p0, uint8x8x4_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vtbx4_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p1.val[2], (int8x8_t)__p1.val[3], (int8x8_t)__p2, 16);
- return __ret;
-}
+#define vst3q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 49); \
+})
#else
-__ai uint8x8_t vtbx4_u8(uint8x8_t __p0, uint8x8x4_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8x4_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vtbx4_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], (int8x8_t)__rev2, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8x3_t __s1 = __p1; \
+ uint16x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 49); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vtbx4_s8(int8x8_t __p0, int8x8x4_t __p1, int8x8_t __p2) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vtbx4_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p1.val[2], (int8x8_t)__p1.val[3], (int8x8_t)__p2, 0);
- return __ret;
-}
+#define vst3q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 41); \
+})
#else
-__ai int8x8_t vtbx4_s8(int8x8_t __p0, int8x8x4_t __p1, int8x8_t __p2) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8x4_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vtbx4_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], (int8x8_t)__rev2, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4x3_t __s1 = __p1; \
+ float32x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 41); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8x2_t vtrn_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x8x2_t __ret;
- __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 4);
- return __ret;
-}
+#define vst3q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 34); \
+})
#else
-__ai poly8x8x2_t vtrn_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x8x2_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 4);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4x3_t __s1 = __p1; \
+ int32x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 34); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x4x2_t vtrn_p16(poly16x4_t __p0, poly16x4_t __p1) {
- poly16x4x2_t __ret;
- __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 5);
- return __ret;
-}
+#define vst3q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 33); \
+})
#else
-__ai poly16x4x2_t vtrn_p16(poly16x4_t __p0, poly16x4_t __p1) {
- poly16x4x2_t __ret;
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 5);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8x3_t __s1 = __p1; \
+ int16x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 33); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16x2_t vtrnq_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly8x16x2_t __ret;
- __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 36);
- return __ret;
-}
+#define vst3_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8x3_t __s1 = __p1; \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 16); \
+})
#else
-__ai poly8x16x2_t vtrnq_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly8x16x2_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 36);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8x3_t __s1 = __p1; \
+ uint8x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 16); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x8x2_t vtrnq_p16(poly16x8_t __p0, poly16x8_t __p1) {
- poly16x8x2_t __ret;
- __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 37);
- return __ret;
-}
+#define vst3_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2x3_t __s1 = __p1; \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 18); \
+})
#else
-__ai poly16x8x2_t vtrnq_p16(poly16x8_t __p0, poly16x8_t __p1) {
- poly16x8x2_t __ret;
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 37);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2x3_t __s1 = __p1; \
+ uint32x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 18); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16x2_t vtrnq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16x2_t __ret;
- __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 48);
- return __ret;
-}
+#define vst3_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4x3_t __s1 = __p1; \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 17); \
+})
#else
-__ai uint8x16x2_t vtrnq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16x2_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 48);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4x3_t __s1 = __p1; \
+ uint16x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 17); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4x2_t vtrnq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4x2_t __ret;
- __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 50);
- return __ret;
-}
+#define vst3_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8x3_t __s1 = __p1; \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 0); \
+})
#else
-__ai uint32x4x2_t vtrnq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4x2_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 50);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
- return __ret;
-}
+#define vst3_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8x3_t __s1 = __p1; \
+ int8x8x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 0); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8x2_t vtrnq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8x2_t __ret;
- __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 49);
- return __ret;
-}
+#define vst3_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2x3_t __s1 = __p1; \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 9); \
+})
#else
-__ai uint16x8x2_t vtrnq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8x2_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 49);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2x3_t __s1 = __p1; \
+ float32x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 9); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16x2_t vtrnq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16x2_t __ret;
- __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 32);
- return __ret;
-}
+#define vst3_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2x3_t __s1 = __p1; \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 2); \
+})
#else
-__ai int8x16x2_t vtrnq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16x2_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 32);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2x3_t __s1 = __p1; \
+ int32x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 2); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4x2_t vtrnq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4x2_t __ret;
- __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 41);
- return __ret;
-}
+#define vst3_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4x3_t __s1 = __p1; \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 1); \
+})
#else
-__ai float32x4x2_t vtrnq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4x2_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 41);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
- return __ret;
-}
+#define vst3_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4x3_t __s1 = __p1; \
+ int16x4x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 1); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4x2_t vtrnq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4x2_t __ret;
- __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 34);
- return __ret;
-}
+#define vst4_p8(__p0, __p1) __extension__ ({ \
+ poly8x8x4_t __s1 = __p1; \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 4); \
+})
#else
-__ai int32x4x2_t vtrnq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4x2_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 34);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
- return __ret;
-}
+#define vst4_p8(__p0, __p1) __extension__ ({ \
+ poly8x8x4_t __s1 = __p1; \
+ poly8x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 4); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8x2_t vtrnq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8x2_t __ret;
- __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 33);
- return __ret;
-}
+#define vst4_p16(__p0, __p1) __extension__ ({ \
+ poly16x4x4_t __s1 = __p1; \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 5); \
+})
#else
-__ai int16x8x2_t vtrnq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8x2_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 33);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst4_p16(__p0, __p1) __extension__ ({ \
+ poly16x4x4_t __s1 = __p1; \
+ poly16x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 5); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8x2_t vtrn_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8x2_t __ret;
- __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 16);
- return __ret;
-}
+#define vst4q_p8(__p0, __p1) __extension__ ({ \
+ poly8x16x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 36); \
+})
#else
-__ai uint8x8x2_t vtrn_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8x2_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 16);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst4q_p8(__p0, __p1) __extension__ ({ \
+ poly8x16x4_t __s1 = __p1; \
+ poly8x16x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 36); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2x2_t vtrn_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2x2_t __ret;
- __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 18);
- return __ret;
-}
+#define vst4q_p16(__p0, __p1) __extension__ ({ \
+ poly16x8x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 37); \
+})
#else
-__ai uint32x2x2_t vtrn_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 18);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
- return __ret;
-}
+#define vst4q_p16(__p0, __p1) __extension__ ({ \
+ poly16x8x4_t __s1 = __p1; \
+ poly16x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 37); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4x2_t vtrn_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4x2_t __ret;
- __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 17);
- return __ret;
-}
+#define vst4q_u8(__p0, __p1) __extension__ ({ \
+ uint8x16x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 48); \
+})
#else
-__ai uint16x4x2_t vtrn_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4x2_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 17);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
- return __ret;
-}
+#define vst4q_u8(__p0, __p1) __extension__ ({ \
+ uint8x16x4_t __s1 = __p1; \
+ uint8x16x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 48); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8x2_t vtrn_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8x2_t __ret;
- __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 0);
- return __ret;
-}
+#define vst4q_u32(__p0, __p1) __extension__ ({ \
+ uint32x4x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 50); \
+})
#else
-__ai int8x8x2_t vtrn_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8x2_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 0);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst4q_u32(__p0, __p1) __extension__ ({ \
+ uint32x4x4_t __s1 = __p1; \
+ uint32x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 50); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2x2_t vtrn_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2x2_t __ret;
- __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 9);
- return __ret;
-}
+#define vst4q_u16(__p0, __p1) __extension__ ({ \
+ uint16x8x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 49); \
+})
#else
-__ai float32x2x2_t vtrn_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 9);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
- return __ret;
-}
+#define vst4q_u16(__p0, __p1) __extension__ ({ \
+ uint16x8x4_t __s1 = __p1; \
+ uint16x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 49); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2x2_t vtrn_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2x2_t __ret;
- __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 2);
- return __ret;
-}
+#define vst4q_s8(__p0, __p1) __extension__ ({ \
+ int8x16x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 32); \
+})
#else
-__ai int32x2x2_t vtrn_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 2);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
- return __ret;
-}
+#define vst4q_s8(__p0, __p1) __extension__ ({ \
+ int8x16x4_t __s1 = __p1; \
+ int8x16x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 32); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4x2_t vtrn_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4x2_t __ret;
- __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 1);
- return __ret;
-}
+#define vst4q_f32(__p0, __p1) __extension__ ({ \
+ float32x4x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 41); \
+})
#else
-__ai int16x4x2_t vtrn_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4x2_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 1);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
- return __ret;
-}
+#define vst4q_f32(__p0, __p1) __extension__ ({ \
+ float32x4x4_t __s1 = __p1; \
+ float32x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 41); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vtst_p8(poly8x8_t __p0, poly8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
- return __ret;
-}
+#define vst4q_s32(__p0, __p1) __extension__ ({ \
+ int32x4x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 34); \
+})
#else
-__ai uint8x8_t vtst_p8(poly8x8_t __p0, poly8x8_t __p1) {
- uint8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst4q_s32(__p0, __p1) __extension__ ({ \
+ int32x4x4_t __s1 = __p1; \
+ int32x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 34); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vtst_p16(poly16x4_t __p0, poly16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
- return __ret;
-}
+#define vst4q_s16(__p0, __p1) __extension__ ({ \
+ int16x8x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 33); \
+})
#else
-__ai uint16x4_t vtst_p16(poly16x4_t __p0, poly16x4_t __p1) {
- uint16x4_t __ret;
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst4q_s16(__p0, __p1) __extension__ ({ \
+ int16x8x4_t __s1 = __p1; \
+ int16x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 33); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vtstq_p8(poly8x16_t __p0, poly8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
- return __ret;
-}
+#define vst4_u8(__p0, __p1) __extension__ ({ \
+ uint8x8x4_t __s1 = __p1; \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 16); \
+})
#else
-__ai uint8x16_t vtstq_p8(poly8x16_t __p0, poly8x16_t __p1) {
- uint8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst4_u8(__p0, __p1) __extension__ ({ \
+ uint8x8x4_t __s1 = __p1; \
+ uint8x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 16); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vtstq_p16(poly16x8_t __p0, poly16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
- return __ret;
-}
+#define vst4_u32(__p0, __p1) __extension__ ({ \
+ uint32x2x4_t __s1 = __p1; \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 18); \
+})
#else
-__ai uint16x8_t vtstq_p16(poly16x8_t __p0, poly16x8_t __p1) {
- uint16x8_t __ret;
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst4_u32(__p0, __p1) __extension__ ({ \
+ uint32x2x4_t __s1 = __p1; \
+ uint32x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 18); \
+})
+#endif
+
+#define vst4_u64(__p0, __p1) __extension__ ({ \
+ uint64x1x4_t __s1 = __p1; \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 19); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst4_u16(__p0, __p1) __extension__ ({ \
+ uint16x4x4_t __s1 = __p1; \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 17); \
+})
+#else
+#define vst4_u16(__p0, __p1) __extension__ ({ \
+ uint16x4x4_t __s1 = __p1; \
+ uint16x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 17); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_s8(__p0, __p1) __extension__ ({ \
+ int8x8x4_t __s1 = __p1; \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 0); \
+})
+#else
+#define vst4_s8(__p0, __p1) __extension__ ({ \
+ int8x8x4_t __s1 = __p1; \
+ int8x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 0); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_f32(__p0, __p1) __extension__ ({ \
+ float32x2x4_t __s1 = __p1; \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 9); \
+})
+#else
+#define vst4_f32(__p0, __p1) __extension__ ({ \
+ float32x2x4_t __s1 = __p1; \
+ float32x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 9); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_s32(__p0, __p1) __extension__ ({ \
+ int32x2x4_t __s1 = __p1; \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 2); \
+})
+#else
+#define vst4_s32(__p0, __p1) __extension__ ({ \
+ int32x2x4_t __s1 = __p1; \
+ int32x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 2); \
+})
+#endif
+
+#define vst4_s64(__p0, __p1) __extension__ ({ \
+ int64x1x4_t __s1 = __p1; \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 3); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst4_s16(__p0, __p1) __extension__ ({ \
+ int16x4x4_t __s1 = __p1; \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 1); \
+})
+#else
+#define vst4_s16(__p0, __p1) __extension__ ({ \
+ int16x4x4_t __s1 = __p1; \
+ int16x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 1); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8x4_t __s1 = __p1; \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 4); \
+})
+#else
+#define vst4_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x8x4_t __s1 = __p1; \
+ poly8x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 4); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4x4_t __s1 = __p1; \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 5); \
+})
+#else
+#define vst4_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x4x4_t __s1 = __p1; \
+ poly16x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 5); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 37); \
+})
+#else
+#define vst4q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+ poly16x8x4_t __s1 = __p1; \
+ poly16x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 37); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 50); \
+})
+#else
+#define vst4q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x4x4_t __s1 = __p1; \
+ uint32x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 50); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 49); \
+})
+#else
+#define vst4q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x8x4_t __s1 = __p1; \
+ uint16x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 49); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 41); \
+})
+#else
+#define vst4q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x4x4_t __s1 = __p1; \
+ float32x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 41); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 34); \
+})
+#else
+#define vst4q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4x4_t __s1 = __p1; \
+ int32x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 34); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 33); \
+})
+#else
+#define vst4q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8x4_t __s1 = __p1; \
+ int16x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 33); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8x4_t __s1 = __p1; \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 16); \
+})
+#else
+#define vst4_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x8x4_t __s1 = __p1; \
+ uint8x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 16); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2x4_t __s1 = __p1; \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 18); \
+})
+#else
+#define vst4_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+ uint32x2x4_t __s1 = __p1; \
+ uint32x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 18); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4x4_t __s1 = __p1; \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 17); \
+})
+#else
+#define vst4_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+ uint16x4x4_t __s1 = __p1; \
+ uint16x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 17); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8x4_t __s1 = __p1; \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 0); \
+})
+#else
+#define vst4_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x8x4_t __s1 = __p1; \
+ int8x8x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 0); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2x4_t __s1 = __p1; \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 9); \
+})
+#else
+#define vst4_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+ float32x2x4_t __s1 = __p1; \
+ float32x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 9); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2x4_t __s1 = __p1; \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 2); \
+})
+#else
+#define vst4_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2x4_t __s1 = __p1; \
+ int32x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 2); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4x4_t __s1 = __p1; \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 1); \
+})
+#else
+#define vst4_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4x4_t __s1 = __p1; \
+ int16x4x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 1); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vtstq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint8x16_t vsubq_u8(uint8x16_t __p0, uint8x16_t __p1) {
uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ __ret = __p0 - __p1;
return __ret;
}
#else
-__ai uint8x16_t vtstq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint8x16_t vsubq_u8(uint8x16_t __p0, uint8x16_t __p1) {
uint8x16_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __rev0 - __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vtstq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vsubq_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+ __ret = __p0 - __p1;
return __ret;
}
#else
-__ai uint32x4_t vtstq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vsubq_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = __rev0 - __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vtstq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vsubq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = __p0 - __p1;
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vsubq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 - __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vsubq_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ __ret = __p0 - __p1;
return __ret;
}
#else
-__ai uint16x8_t vtstq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vsubq_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __rev0 - __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vtstq_s8(int8x16_t __p0, int8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+__ai __attribute__((target("neon"))) int8x16_t vsubq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = __p0 - __p1;
return __ret;
}
#else
-__ai uint8x16_t vtstq_s8(int8x16_t __p0, int8x16_t __p1) {
- uint8x16_t __ret;
+__ai __attribute__((target("neon"))) int8x16_t vsubq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __rev0 - __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vtstq_s32(int32x4_t __p0, int32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+__ai __attribute__((target("neon"))) float32x4_t vsubq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = __p0 - __p1;
return __ret;
}
#else
-__ai uint32x4_t vtstq_s32(int32x4_t __p0, int32x4_t __p1) {
- uint32x4_t __ret;
+__ai __attribute__((target("neon"))) float32x4_t vsubq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 - __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vsubq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = __p0 - __p1;
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vsubq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = __rev0 - __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vtstq_s16(int16x8_t __p0, int16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+__ai __attribute__((target("neon"))) int64x2_t vsubq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ __ret = __p0 - __p1;
return __ret;
}
#else
-__ai uint16x8_t vtstq_s16(int16x8_t __p0, int16x8_t __p1) {
- uint16x8_t __ret;
+__ai __attribute__((target("neon"))) int64x2_t vsubq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 - __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vsubq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = __p0 - __p1;
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vsubq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __rev0 - __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vtst_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vsub_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ __ret = __p0 - __p1;
return __ret;
}
#else
-__ai uint8x8_t vtst_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vsub_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint8x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __rev0 - __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vtst_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vsub_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ __ret = __p0 - __p1;
return __ret;
}
#else
-__ai uint32x2_t vtst_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vsub_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __rev0 - __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vsub_u64(uint64x1_t __p0, uint64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = __p0 - __p1;
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vtst_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vsub_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ __ret = __p0 - __p1;
return __ret;
}
#else
-__ai uint16x4_t vtst_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vsub_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = __rev0 - __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vtst_s8(int8x8_t __p0, int8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+__ai __attribute__((target("neon"))) int8x8_t vsub_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = __p0 - __p1;
return __ret;
}
#else
-__ai uint8x8_t vtst_s8(int8x8_t __p0, int8x8_t __p1) {
- uint8x8_t __ret;
+__ai __attribute__((target("neon"))) int8x8_t vsub_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __rev0 - __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vtst_s32(int32x2_t __p0, int32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+__ai __attribute__((target("neon"))) float32x2_t vsub_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = __p0 - __p1;
return __ret;
}
#else
-__ai uint32x2_t vtst_s32(int32x2_t __p0, int32x2_t __p1) {
- uint32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+__ai __attribute__((target("neon"))) float32x2_t vsub_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 - __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vtst_s16(int16x4_t __p0, int16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+__ai __attribute__((target("neon"))) int32x2_t vsub_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = __p0 - __p1;
return __ret;
}
#else
-__ai uint16x4_t vtst_s16(int16x4_t __p0, int16x4_t __p1) {
- uint16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x2_t vsub_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 - __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai poly8x8x2_t vuzp_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x8x2_t __ret;
- __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 4);
- return __ret;
-}
-#else
-__ai poly8x8x2_t vuzp_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x8x2_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 4);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int64x1_t vsub_s64(int64x1_t __p0, int64x1_t __p1) {
+ int64x1_t __ret;
+ __ret = __p0 - __p1;
return __ret;
}
-#endif
-
#ifdef __LITTLE_ENDIAN__
-__ai poly16x4x2_t vuzp_p16(poly16x4_t __p0, poly16x4_t __p1) {
- poly16x4x2_t __ret;
- __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 5);
+__ai __attribute__((target("neon"))) int16x4_t vsub_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = __p0 - __p1;
return __ret;
}
#else
-__ai poly16x4x2_t vuzp_p16(poly16x4_t __p0, poly16x4_t __p1) {
- poly16x4x2_t __ret;
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 5);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16x4_t vsub_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 - __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16x2_t vuzpq_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly8x16x2_t __ret;
- __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 36);
+__ai __attribute__((target("neon"))) uint16x4_t vsubhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
return __ret;
}
#else
-__ai poly8x16x2_t vuzpq_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly8x16x2_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 36);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai poly16x8x2_t vuzpq_p16(poly16x8_t __p0, poly16x8_t __p1) {
- poly16x8x2_t __ret;
- __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 37);
+__ai __attribute__((target("neon"))) uint16x4_t vsubhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint16x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-#else
-__ai poly16x8x2_t vuzpq_p16(poly16x8_t __p0, poly16x8_t __p1) {
- poly16x8x2_t __ret;
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 37);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint16x4_t __noswap_vsubhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16x2_t vuzpq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16x2_t __ret;
- __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 48);
+__ai __attribute__((target("neon"))) uint32x2_t vsubhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
return __ret;
}
#else
-__ai uint8x16x2_t vuzpq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16x2_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 48);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32x4x2_t vuzpq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4x2_t __ret;
- __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 50);
+__ai __attribute__((target("neon"))) uint32x2_t vsubhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint32x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-#else
-__ai uint32x4x2_t vuzpq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4x2_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 50);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x2_t __noswap_vsubhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8x2_t vuzpq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8x2_t __ret;
- __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 49);
+__ai __attribute__((target("neon"))) uint8x8_t vsubhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
return __ret;
}
#else
-__ai uint16x8x2_t vuzpq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8x2_t __ret;
+__ai __attribute__((target("neon"))) uint8x8_t vsubhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint8x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 49);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int8x16x2_t vuzpq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16x2_t __ret;
- __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 32);
+ __ret = (uint8x8_t) __builtin_neon_vsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-#else
-__ai int8x16x2_t vuzpq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16x2_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 32);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x8_t __noswap_vsubhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4x2_t vuzpq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4x2_t __ret;
- __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 41);
+__ai __attribute__((target("neon"))) int16x4_t vsubhn_s32(int32x4_t __p0, int32x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
return __ret;
}
#else
-__ai float32x4x2_t vuzpq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4x2_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 41);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16x4_t vsubhn_s32(int32x4_t __p0, int32x4_t __p1) {
+ int16x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vsubhn_s32(int32x4_t __p0, int32x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4x2_t vuzpq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4x2_t __ret;
- __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 34);
+__ai __attribute__((target("neon"))) int32x2_t vsubhn_s64(int64x2_t __p0, int64x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
return __ret;
}
#else
-__ai int32x4x2_t vuzpq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4x2_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 34);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x2_t vsubhn_s64(int64x2_t __p0, int64x2_t __p1) {
+ int32x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vsubhn_s64(int64x2_t __p0, int64x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8x2_t vuzpq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8x2_t __ret;
- __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 33);
+__ai __attribute__((target("neon"))) int8x8_t vsubhn_s16(int16x8_t __p0, int16x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
return __ret;
}
#else
-__ai int16x8x2_t vuzpq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8x2_t __ret;
+__ai __attribute__((target("neon"))) int8x8_t vsubhn_s16(int16x8_t __p0, int16x8_t __p1) {
+ int8x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 33);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t __noswap_vsubhn_s16(int16x8_t __p0, int16x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8x2_t vuzp_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8x2_t __ret;
- __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 16);
+__ai __attribute__((target("neon"))) uint16x8_t vsubl_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = vmovl_u8(__p0) - vmovl_u8(__p1);
return __ret;
}
#else
-__ai uint8x8x2_t vuzp_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8x2_t __ret;
+__ai __attribute__((target("neon"))) uint16x8_t vsubl_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint16x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 16);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vmovl_u8(__rev0) - __noswap_vmovl_u8(__rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2x2_t vuzp_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2x2_t __ret;
- __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 18);
+__ai __attribute__((target("neon"))) uint64x2_t vsubl_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = vmovl_u32(__p0) - vmovl_u32(__p1);
return __ret;
}
#else
-__ai uint32x2x2_t vuzp_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2x2_t __ret;
+__ai __attribute__((target("neon"))) uint64x2_t vsubl_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint64x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 18);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+ __ret = __noswap_vmovl_u32(__rev0) - __noswap_vmovl_u32(__rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4x2_t vuzp_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4x2_t __ret;
- __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 17);
+__ai __attribute__((target("neon"))) uint32x4_t vsubl_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = vmovl_u16(__p0) - vmovl_u16(__p1);
return __ret;
}
#else
-__ai uint16x4x2_t vuzp_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4x2_t __ret;
+__ai __attribute__((target("neon"))) uint32x4_t vsubl_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint32x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 17);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ __ret = __noswap_vmovl_u16(__rev0) - __noswap_vmovl_u16(__rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8x2_t vuzp_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8x2_t __ret;
- __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 0);
+__ai __attribute__((target("neon"))) int16x8_t vsubl_s8(int8x8_t __p0, int8x8_t __p1) {
+ int16x8_t __ret;
+ __ret = vmovl_s8(__p0) - vmovl_s8(__p1);
return __ret;
}
#else
-__ai int8x8x2_t vuzp_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8x2_t __ret;
+__ai __attribute__((target("neon"))) int16x8_t vsubl_s8(int8x8_t __p0, int8x8_t __p1) {
+ int16x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 0);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vmovl_s8(__rev0) - __noswap_vmovl_s8(__rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2x2_t vuzp_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2x2_t __ret;
- __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 9);
+__ai __attribute__((target("neon"))) int64x2_t vsubl_s32(int32x2_t __p0, int32x2_t __p1) {
+ int64x2_t __ret;
+ __ret = vmovl_s32(__p0) - vmovl_s32(__p1);
return __ret;
}
#else
-__ai float32x2x2_t vuzp_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 9);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+__ai __attribute__((target("neon"))) int64x2_t vsubl_s32(int32x2_t __p0, int32x2_t __p1) {
+ int64x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __noswap_vmovl_s32(__rev0) - __noswap_vmovl_s32(__rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2x2_t vuzp_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2x2_t __ret;
- __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 2);
+__ai __attribute__((target("neon"))) int32x4_t vsubl_s16(int16x4_t __p0, int16x4_t __p1) {
+ int32x4_t __ret;
+ __ret = vmovl_s16(__p0) - vmovl_s16(__p1);
return __ret;
}
#else
-__ai int32x2x2_t vuzp_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 2);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+__ai __attribute__((target("neon"))) int32x4_t vsubl_s16(int16x4_t __p0, int16x4_t __p1) {
+ int32x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __noswap_vmovl_s16(__rev0) - __noswap_vmovl_s16(__rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4x2_t vuzp_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4x2_t __ret;
- __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 1);
+__ai __attribute__((target("neon"))) uint16x8_t vsubw_u8(uint16x8_t __p0, uint8x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = __p0 - vmovl_u8(__p1);
return __ret;
}
#else
-__ai int16x4x2_t vuzp_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4x2_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 1);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint16x8_t vsubw_u8(uint16x8_t __p0, uint8x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 - __noswap_vmovl_u8(__rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8x2_t vzip_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x8x2_t __ret;
- __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 4);
+__ai __attribute__((target("neon"))) uint64x2_t vsubw_u32(uint64x2_t __p0, uint32x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = __p0 - vmovl_u32(__p1);
return __ret;
}
#else
-__ai poly8x8x2_t vzip_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x8x2_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 4);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint64x2_t vsubw_u32(uint64x2_t __p0, uint32x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 - __noswap_vmovl_u32(__rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x4x2_t vzip_p16(poly16x4_t __p0, poly16x4_t __p1) {
- poly16x4x2_t __ret;
- __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 5);
+__ai __attribute__((target("neon"))) uint32x4_t vsubw_u16(uint32x4_t __p0, uint16x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = __p0 - vmovl_u16(__p1);
return __ret;
}
#else
-__ai poly16x4x2_t vzip_p16(poly16x4_t __p0, poly16x4_t __p1) {
- poly16x4x2_t __ret;
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 5);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x4_t vsubw_u16(uint32x4_t __p0, uint16x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 - __noswap_vmovl_u16(__rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16x2_t vzipq_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly8x16x2_t __ret;
- __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 36);
+__ai __attribute__((target("neon"))) int16x8_t vsubw_s8(int16x8_t __p0, int8x8_t __p1) {
+ int16x8_t __ret;
+ __ret = __p0 - vmovl_s8(__p1);
return __ret;
}
#else
-__ai poly8x16x2_t vzipq_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly8x16x2_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 36);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16x8_t vsubw_s8(int16x8_t __p0, int8x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 - __noswap_vmovl_s8(__rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x8x2_t vzipq_p16(poly16x8_t __p0, poly16x8_t __p1) {
- poly16x8x2_t __ret;
- __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 37);
+__ai __attribute__((target("neon"))) int64x2_t vsubw_s32(int64x2_t __p0, int32x2_t __p1) {
+ int64x2_t __ret;
+ __ret = __p0 - vmovl_s32(__p1);
return __ret;
}
#else
-__ai poly16x8x2_t vzipq_p16(poly16x8_t __p0, poly16x8_t __p1) {
- poly16x8x2_t __ret;
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 37);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int64x2_t vsubw_s32(int64x2_t __p0, int32x2_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 - __noswap_vmovl_s32(__rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16x2_t vzipq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16x2_t __ret;
- __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 48);
+__ai __attribute__((target("neon"))) int32x4_t vsubw_s16(int32x4_t __p0, int16x4_t __p1) {
+ int32x4_t __ret;
+ __ret = __p0 - vmovl_s16(__p1);
return __ret;
}
#else
-__ai uint8x16x2_t vzipq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16x2_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 48);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x4_t vsubw_s16(int32x4_t __p0, int16x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 - __noswap_vmovl_s16(__rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4x2_t vzipq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4x2_t __ret;
- __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 50);
+__ai __attribute__((target("neon"))) poly8x8_t vtbl1_p8(poly8x8_t __p0, uint8x8_t __p1) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) __builtin_neon_vtbl1_v((int8x8_t)__p0, (int8x8_t)__p1, 4);
return __ret;
}
#else
-__ai uint32x4x2_t vzipq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4x2_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 50);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly8x8_t vtbl1_p8(poly8x8_t __p0, uint8x8_t __p1) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vtbl1_v((int8x8_t)__rev0, (int8x8_t)__rev1, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8x2_t vzipq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8x2_t __ret;
- __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 49);
+__ai __attribute__((target("neon"))) uint8x8_t vtbl1_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vtbl1_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
return __ret;
}
#else
-__ai uint16x8x2_t vzipq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8x2_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 49);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x8_t vtbl1_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vtbl1_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16x2_t vzipq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16x2_t __ret;
- __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 32);
+__ai __attribute__((target("neon"))) int8x8_t vtbl1_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vtbl1_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
return __ret;
}
#else
-__ai int8x16x2_t vzipq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16x2_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 32);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int8x8_t vtbl1_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vtbl1_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4x2_t vzipq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4x2_t __ret;
- __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 41);
+__ai __attribute__((target("neon"))) poly8x8_t vtbl2_p8(poly8x8x2_t __p0, uint8x8_t __p1) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) __builtin_neon_vtbl2_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p1, 4);
return __ret;
}
#else
-__ai float32x4x2_t vzipq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4x2_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 41);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly8x8_t vtbl2_p8(poly8x8x2_t __p0, uint8x8_t __p1) {
+ poly8x8_t __ret;
+ poly8x8x2_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vtbl2_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev1, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4x2_t vzipq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4x2_t __ret;
- __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 34);
+__ai __attribute__((target("neon"))) uint8x8_t vtbl2_u8(uint8x8x2_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vtbl2_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p1, 16);
return __ret;
}
#else
-__ai int32x4x2_t vzipq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4x2_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 34);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x8_t vtbl2_u8(uint8x8x2_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8x2_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vtbl2_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8x2_t vzipq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8x2_t __ret;
- __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 33);
+__ai __attribute__((target("neon"))) int8x8_t vtbl2_s8(int8x8x2_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vtbl2_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p1, 0);
return __ret;
}
#else
-__ai int16x8x2_t vzipq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8x2_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 33);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int8x8_t vtbl2_s8(int8x8x2_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8x2_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vtbl2_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8x2_t vzip_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8x2_t __ret;
- __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 16);
+__ai __attribute__((target("neon"))) poly8x8_t vtbl3_p8(poly8x8x3_t __p0, uint8x8_t __p1) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) __builtin_neon_vtbl3_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p0.val[2], (int8x8_t)__p1, 4);
return __ret;
}
#else
-__ai uint8x8x2_t vzip_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8x2_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly8x8_t vtbl3_p8(poly8x8x3_t __p0, uint8x8_t __p1) {
+ poly8x8_t __ret;
+ poly8x8x3_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 16);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vtbl3_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev0.val[2], (int8x8_t)__rev1, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2x2_t vzip_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2x2_t __ret;
- __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 18);
+__ai __attribute__((target("neon"))) uint8x8_t vtbl3_u8(uint8x8x3_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vtbl3_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p0.val[2], (int8x8_t)__p1, 16);
return __ret;
}
#else
-__ai uint32x2x2_t vzip_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 18);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+__ai __attribute__((target("neon"))) uint8x8_t vtbl3_u8(uint8x8x3_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8x3_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vtbl3_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev0.val[2], (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4x2_t vzip_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4x2_t __ret;
- __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 17);
+__ai __attribute__((target("neon"))) int8x8_t vtbl3_s8(int8x8x3_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vtbl3_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p0.val[2], (int8x8_t)__p1, 0);
return __ret;
}
#else
-__ai uint16x4x2_t vzip_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4x2_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 17);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int8x8_t vtbl3_s8(int8x8x3_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8x3_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vtbl3_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev0.val[2], (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8x2_t vzip_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8x2_t __ret;
- __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 0);
+__ai __attribute__((target("neon"))) poly8x8_t vtbl4_p8(poly8x8x4_t __p0, uint8x8_t __p1) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) __builtin_neon_vtbl4_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p0.val[2], (int8x8_t)__p0.val[3], (int8x8_t)__p1, 4);
return __ret;
}
#else
-__ai int8x8x2_t vzip_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8x2_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 0);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly8x8_t vtbl4_p8(poly8x8x4_t __p0, uint8x8_t __p1) {
+ poly8x8_t __ret;
+ poly8x8x4_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vtbl4_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev0.val[2], (int8x8_t)__rev0.val[3], (int8x8_t)__rev1, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2x2_t vzip_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2x2_t __ret;
- __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 9);
+__ai __attribute__((target("neon"))) uint8x8_t vtbl4_u8(uint8x8x4_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vtbl4_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p0.val[2], (int8x8_t)__p0.val[3], (int8x8_t)__p1, 16);
return __ret;
}
#else
-__ai float32x2x2_t vzip_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 9);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+__ai __attribute__((target("neon"))) uint8x8_t vtbl4_u8(uint8x8x4_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8x4_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vtbl4_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev0.val[2], (int8x8_t)__rev0.val[3], (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2x2_t vzip_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2x2_t __ret;
- __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 2);
+__ai __attribute__((target("neon"))) int8x8_t vtbl4_s8(int8x8x4_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vtbl4_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p0.val[2], (int8x8_t)__p0.val[3], (int8x8_t)__p1, 0);
return __ret;
}
#else
-__ai int32x2x2_t vzip_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 2);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+__ai __attribute__((target("neon"))) int8x8_t vtbl4_s8(int8x8x4_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8x4_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vtbl4_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev0.val[2], (int8x8_t)__rev0.val[3], (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4x2_t vzip_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4x2_t __ret;
- __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 1);
+__ai __attribute__((target("neon"))) poly8x8_t vtbx1_p8(poly8x8_t __p0, poly8x8_t __p1, uint8x8_t __p2) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) __builtin_neon_vtbx1_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 4);
return __ret;
}
#else
-__ai int16x4x2_t vzip_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4x2_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 1);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly8x8_t vtbx1_p8(poly8x8_t __p0, poly8x8_t __p1, uint8x8_t __p2) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vtbx1_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_lane_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x8_t __ret; \
- bfloat16x4_t __s0 = __p0; \
- __ret = (bfloat16x8_t) __builtin_neon_splatq_lane_bf16((int8x8_t)__s0, __p1, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vtbx1_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vtbx1_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 16);
+ return __ret;
+}
#else
-#define splatq_lane_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x8_t __ret; \
- bfloat16x4_t __s0 = __p0; \
- bfloat16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (bfloat16x8_t) __builtin_neon_splatq_lane_bf16((int8x8_t)__rev0, __p1, 11); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splatq_lane_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x8_t __ret; \
- bfloat16x4_t __s0 = __p0; \
- __ret = (bfloat16x8_t) __builtin_neon_splatq_lane_bf16((int8x8_t)__s0, __p1, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vtbx1_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vtbx1_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_lane_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x4_t __ret; \
- bfloat16x4_t __s0 = __p0; \
- __ret = (bfloat16x4_t) __builtin_neon_splat_lane_bf16((int8x8_t)__s0, __p1, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vtbx1_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vtbx1_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 0);
+ return __ret;
+}
#else
-#define splat_lane_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x4_t __ret; \
- bfloat16x4_t __s0 = __p0; \
- bfloat16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (bfloat16x4_t) __builtin_neon_splat_lane_bf16((int8x8_t)__rev0, __p1, 11); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splat_lane_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x4_t __ret; \
- bfloat16x4_t __s0 = __p0; \
- __ret = (bfloat16x4_t) __builtin_neon_splat_lane_bf16((int8x8_t)__s0, __p1, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vtbx1_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vtbx1_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define splatq_laneq_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x8_t __ret; \
- bfloat16x8_t __s0 = __p0; \
- __ret = (bfloat16x8_t) __builtin_neon_splatq_laneq_bf16((int8x16_t)__s0, __p1, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x8_t vtbx2_p8(poly8x8_t __p0, poly8x8x2_t __p1, uint8x8_t __p2) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) __builtin_neon_vtbx2_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p2, 4);
+ return __ret;
+}
#else
-#define splatq_laneq_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x8_t __ret; \
- bfloat16x8_t __s0 = __p0; \
- bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (bfloat16x8_t) __builtin_neon_splatq_laneq_bf16((int8x16_t)__rev0, __p1, 43); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splatq_laneq_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x8_t __ret; \
- bfloat16x8_t __s0 = __p0; \
- __ret = (bfloat16x8_t) __builtin_neon_splatq_laneq_bf16((int8x16_t)__s0, __p1, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x8_t vtbx2_p8(poly8x8_t __p0, poly8x8x2_t __p1, uint8x8_t __p2) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x8x2_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vtbx2_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev2, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define splat_laneq_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x4_t __ret; \
- bfloat16x8_t __s0 = __p0; \
- __ret = (bfloat16x4_t) __builtin_neon_splat_laneq_bf16((int8x16_t)__s0, __p1, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vtbx2_u8(uint8x8_t __p0, uint8x8x2_t __p1, uint8x8_t __p2) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vtbx2_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p2, 16);
+ return __ret;
+}
#else
-#define splat_laneq_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x4_t __ret; \
- bfloat16x8_t __s0 = __p0; \
- bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (bfloat16x4_t) __builtin_neon_splat_laneq_bf16((int8x16_t)__rev0, __p1, 43); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_splat_laneq_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x4_t __ret; \
- bfloat16x8_t __s0 = __p0; \
- __ret = (bfloat16x4_t) __builtin_neon_splat_laneq_bf16((int8x16_t)__s0, __p1, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vtbx2_u8(uint8x8_t __p0, uint8x8x2_t __p1, uint8x8_t __p2) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8x2_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vtbx2_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev2, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) float32x4_t vbfdotq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vbfdotq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("neon"))) int8x8_t vtbx2_s8(int8x8_t __p0, int8x8x2_t __p1, int8x8_t __p2) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vtbx2_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p2, 0);
return __ret;
}
#else
-__ai __attribute__((target("bf16"))) float32x4_t vbfdotq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- bfloat16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- bfloat16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vbfdotq_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) float32x4_t __noswap_vbfdotq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vbfdotq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("neon"))) int8x8_t vtbx2_s8(int8x8_t __p0, int8x8x2_t __p1, int8x8_t __p2) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8x2_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vtbx2_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev2, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) float32x2_t vbfdot_f32(float32x2_t __p0, bfloat16x4_t __p1, bfloat16x4_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vbfdot_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+__ai __attribute__((target("neon"))) poly8x8_t vtbx3_p8(poly8x8_t __p0, poly8x8x3_t __p1, uint8x8_t __p2) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) __builtin_neon_vtbx3_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p1.val[2], (int8x8_t)__p2, 4);
return __ret;
}
#else
-__ai __attribute__((target("bf16"))) float32x2_t vbfdot_f32(float32x2_t __p0, bfloat16x4_t __p1, bfloat16x4_t __p2) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- bfloat16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- bfloat16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vbfdot_f32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) float32x2_t __noswap_vbfdot_f32(float32x2_t __p0, bfloat16x4_t __p1, bfloat16x4_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vbfdot_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+__ai __attribute__((target("neon"))) poly8x8_t vtbx3_p8(poly8x8_t __p0, poly8x8x3_t __p1, uint8x8_t __p2) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x8x3_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vtbx3_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev2, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vbfdotq_lane_f32(__p0_126, __p1_126, __p2_126, __p3_126) __extension__ ({ \
- float32x4_t __ret_126; \
- float32x4_t __s0_126 = __p0_126; \
- bfloat16x8_t __s1_126 = __p1_126; \
- bfloat16x4_t __s2_126 = __p2_126; \
-bfloat16x4_t __reint_126 = __s2_126; \
-float32x4_t __reint1_126 = splatq_lane_f32(*(float32x2_t *) &__reint_126, __p3_126); \
- __ret_126 = vbfdotq_f32(__s0_126, __s1_126, *(bfloat16x8_t *) &__reint1_126); \
- __ret_126; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vtbx3_u8(uint8x8_t __p0, uint8x8x3_t __p1, uint8x8_t __p2) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vtbx3_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p1.val[2], (int8x8_t)__p2, 16);
+ return __ret;
+}
#else
-#define vbfdotq_lane_f32(__p0_127, __p1_127, __p2_127, __p3_127) __extension__ ({ \
- float32x4_t __ret_127; \
- float32x4_t __s0_127 = __p0_127; \
- bfloat16x8_t __s1_127 = __p1_127; \
- bfloat16x4_t __s2_127 = __p2_127; \
- float32x4_t __rev0_127; __rev0_127 = __builtin_shufflevector(__s0_127, __s0_127, 3, 2, 1, 0); \
- bfloat16x8_t __rev1_127; __rev1_127 = __builtin_shufflevector(__s1_127, __s1_127, 7, 6, 5, 4, 3, 2, 1, 0); \
- bfloat16x4_t __rev2_127; __rev2_127 = __builtin_shufflevector(__s2_127, __s2_127, 3, 2, 1, 0); \
-bfloat16x4_t __reint_127 = __rev2_127; \
-float32x4_t __reint1_127 = __noswap_splatq_lane_f32(*(float32x2_t *) &__reint_127, __p3_127); \
- __ret_127 = __noswap_vbfdotq_f32(__rev0_127, __rev1_127, *(bfloat16x8_t *) &__reint1_127); \
- __ret_127 = __builtin_shufflevector(__ret_127, __ret_127, 3, 2, 1, 0); \
- __ret_127; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vtbx3_u8(uint8x8_t __p0, uint8x8x3_t __p1, uint8x8_t __p2) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8x3_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vtbx3_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev2, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vbfdot_lane_f32(__p0_128, __p1_128, __p2_128, __p3_128) __extension__ ({ \
- float32x2_t __ret_128; \
- float32x2_t __s0_128 = __p0_128; \
- bfloat16x4_t __s1_128 = __p1_128; \
- bfloat16x4_t __s2_128 = __p2_128; \
-bfloat16x4_t __reint_128 = __s2_128; \
-float32x2_t __reint1_128 = splat_lane_f32(*(float32x2_t *) &__reint_128, __p3_128); \
- __ret_128 = vbfdot_f32(__s0_128, __s1_128, *(bfloat16x4_t *) &__reint1_128); \
- __ret_128; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vtbx3_s8(int8x8_t __p0, int8x8x3_t __p1, int8x8_t __p2) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vtbx3_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p1.val[2], (int8x8_t)__p2, 0);
+ return __ret;
+}
#else
-#define vbfdot_lane_f32(__p0_129, __p1_129, __p2_129, __p3_129) __extension__ ({ \
- float32x2_t __ret_129; \
- float32x2_t __s0_129 = __p0_129; \
- bfloat16x4_t __s1_129 = __p1_129; \
- bfloat16x4_t __s2_129 = __p2_129; \
- float32x2_t __rev0_129; __rev0_129 = __builtin_shufflevector(__s0_129, __s0_129, 1, 0); \
- bfloat16x4_t __rev1_129; __rev1_129 = __builtin_shufflevector(__s1_129, __s1_129, 3, 2, 1, 0); \
- bfloat16x4_t __rev2_129; __rev2_129 = __builtin_shufflevector(__s2_129, __s2_129, 3, 2, 1, 0); \
-bfloat16x4_t __reint_129 = __rev2_129; \
-float32x2_t __reint1_129 = __noswap_splat_lane_f32(*(float32x2_t *) &__reint_129, __p3_129); \
- __ret_129 = __noswap_vbfdot_f32(__rev0_129, __rev1_129, *(bfloat16x4_t *) &__reint1_129); \
- __ret_129 = __builtin_shufflevector(__ret_129, __ret_129, 1, 0); \
- __ret_129; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vtbx3_s8(int8x8_t __p0, int8x8x3_t __p1, int8x8_t __p2) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8x3_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vtbx3_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev2, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vbfdotq_laneq_f32(__p0_130, __p1_130, __p2_130, __p3_130) __extension__ ({ \
- float32x4_t __ret_130; \
- float32x4_t __s0_130 = __p0_130; \
- bfloat16x8_t __s1_130 = __p1_130; \
- bfloat16x8_t __s2_130 = __p2_130; \
-bfloat16x8_t __reint_130 = __s2_130; \
-float32x4_t __reint1_130 = splatq_laneq_f32(*(float32x4_t *) &__reint_130, __p3_130); \
- __ret_130 = vbfdotq_f32(__s0_130, __s1_130, *(bfloat16x8_t *) &__reint1_130); \
- __ret_130; \
-})
+__ai __attribute__((target("neon"))) poly8x8_t vtbx4_p8(poly8x8_t __p0, poly8x8x4_t __p1, uint8x8_t __p2) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) __builtin_neon_vtbx4_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p1.val[2], (int8x8_t)__p1.val[3], (int8x8_t)__p2, 4);
+ return __ret;
+}
#else
-#define vbfdotq_laneq_f32(__p0_131, __p1_131, __p2_131, __p3_131) __extension__ ({ \
- float32x4_t __ret_131; \
- float32x4_t __s0_131 = __p0_131; \
- bfloat16x8_t __s1_131 = __p1_131; \
- bfloat16x8_t __s2_131 = __p2_131; \
- float32x4_t __rev0_131; __rev0_131 = __builtin_shufflevector(__s0_131, __s0_131, 3, 2, 1, 0); \
- bfloat16x8_t __rev1_131; __rev1_131 = __builtin_shufflevector(__s1_131, __s1_131, 7, 6, 5, 4, 3, 2, 1, 0); \
- bfloat16x8_t __rev2_131; __rev2_131 = __builtin_shufflevector(__s2_131, __s2_131, 7, 6, 5, 4, 3, 2, 1, 0); \
-bfloat16x8_t __reint_131 = __rev2_131; \
-float32x4_t __reint1_131 = __noswap_splatq_laneq_f32(*(float32x4_t *) &__reint_131, __p3_131); \
- __ret_131 = __noswap_vbfdotq_f32(__rev0_131, __rev1_131, *(bfloat16x8_t *) &__reint1_131); \
- __ret_131 = __builtin_shufflevector(__ret_131, __ret_131, 3, 2, 1, 0); \
- __ret_131; \
-})
+__ai __attribute__((target("neon"))) poly8x8_t vtbx4_p8(poly8x8_t __p0, poly8x8x4_t __p1, uint8x8_t __p2) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x8x4_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vtbx4_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], (int8x8_t)__rev2, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vbfdot_laneq_f32(__p0_132, __p1_132, __p2_132, __p3_132) __extension__ ({ \
- float32x2_t __ret_132; \
- float32x2_t __s0_132 = __p0_132; \
- bfloat16x4_t __s1_132 = __p1_132; \
- bfloat16x8_t __s2_132 = __p2_132; \
-bfloat16x8_t __reint_132 = __s2_132; \
-float32x2_t __reint1_132 = splat_laneq_f32(*(float32x4_t *) &__reint_132, __p3_132); \
- __ret_132 = vbfdot_f32(__s0_132, __s1_132, *(bfloat16x4_t *) &__reint1_132); \
- __ret_132; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vtbx4_u8(uint8x8_t __p0, uint8x8x4_t __p1, uint8x8_t __p2) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vtbx4_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p1.val[2], (int8x8_t)__p1.val[3], (int8x8_t)__p2, 16);
+ return __ret;
+}
#else
-#define vbfdot_laneq_f32(__p0_133, __p1_133, __p2_133, __p3_133) __extension__ ({ \
- float32x2_t __ret_133; \
- float32x2_t __s0_133 = __p0_133; \
- bfloat16x4_t __s1_133 = __p1_133; \
- bfloat16x8_t __s2_133 = __p2_133; \
- float32x2_t __rev0_133; __rev0_133 = __builtin_shufflevector(__s0_133, __s0_133, 1, 0); \
- bfloat16x4_t __rev1_133; __rev1_133 = __builtin_shufflevector(__s1_133, __s1_133, 3, 2, 1, 0); \
- bfloat16x8_t __rev2_133; __rev2_133 = __builtin_shufflevector(__s2_133, __s2_133, 7, 6, 5, 4, 3, 2, 1, 0); \
-bfloat16x8_t __reint_133 = __rev2_133; \
-float32x2_t __reint1_133 = __noswap_splat_laneq_f32(*(float32x4_t *) &__reint_133, __p3_133); \
- __ret_133 = __noswap_vbfdot_f32(__rev0_133, __rev1_133, *(bfloat16x4_t *) &__reint1_133); \
- __ret_133 = __builtin_shufflevector(__ret_133, __ret_133, 1, 0); \
- __ret_133; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vtbx4_u8(uint8x8_t __p0, uint8x8x4_t __p1, uint8x8_t __p2) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8x4_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vtbx4_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], (int8x8_t)__rev2, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) float32x4_t vbfmlalbq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vbfmlalbq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("neon"))) int8x8_t vtbx4_s8(int8x8_t __p0, int8x8x4_t __p1, int8x8_t __p2) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vtbx4_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p1.val[2], (int8x8_t)__p1.val[3], (int8x8_t)__p2, 0);
return __ret;
}
#else
-__ai __attribute__((target("bf16"))) float32x4_t vbfmlalbq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- bfloat16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- bfloat16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vbfmlalbq_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) float32x4_t __noswap_vbfmlalbq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vbfmlalbq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("neon"))) int8x8_t vtbx4_s8(int8x8_t __p0, int8x8x4_t __p1, int8x8_t __p2) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8x4_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vtbx4_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], (int8x8_t)__rev2, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) float32x4_t vbfmlaltq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vbfmlaltq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("neon"))) poly8x8x2_t vtrn_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly8x8x2_t __ret;
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 4);
return __ret;
}
#else
-__ai __attribute__((target("bf16"))) float32x4_t vbfmlaltq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- bfloat16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- bfloat16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vbfmlaltq_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) float32x4_t __noswap_vbfmlaltq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vbfmlaltq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("neon"))) poly8x8x2_t vtrn_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly8x8x2_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 4);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) float32x4_t vbfmmlaq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vbfmmlaq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("neon"))) poly16x4x2_t vtrn_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ poly16x4x2_t __ret;
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 5);
return __ret;
}
#else
-__ai __attribute__((target("bf16"))) float32x4_t vbfmmlaq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- bfloat16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- bfloat16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vbfmmlaq_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly16x4x2_t vtrn_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ poly16x4x2_t __ret;
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 5);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) bfloat16x8_t vcombine_bf16(bfloat16x4_t __p0, bfloat16x4_t __p1) {
- bfloat16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) poly8x16x2_t vtrnq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly8x16x2_t __ret;
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 36);
return __ret;
}
#else
-__ai __attribute__((target("bf16"))) bfloat16x8_t vcombine_bf16(bfloat16x4_t __p0, bfloat16x4_t __p1) {
- bfloat16x8_t __ret;
- bfloat16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- bfloat16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t __noswap_vcombine_bf16(bfloat16x4_t __p0, bfloat16x4_t __p1) {
- bfloat16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) poly8x16x2_t vtrnq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly8x16x2_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 36);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
-#define vcreate_bf16(__p0) __extension__ ({ \
- bfloat16x4_t __ret; \
- uint64_t __promote = __p0; \
- __ret = (bfloat16x4_t)(__promote); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) float32x4_t vcvt_f32_bf16(bfloat16x4_t __p0_134) {
- float32x4_t __ret_134;
-bfloat16x4_t __reint_134 = __p0_134;
-int32x4_t __reint1_134 = vshll_n_s16(*(int16x4_t *) &__reint_134, 16);
- __ret_134 = *(float32x4_t *) &__reint1_134;
- return __ret_134;
+__ai __attribute__((target("neon"))) poly16x8x2_t vtrnq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+ poly16x8x2_t __ret;
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 37);
+ return __ret;
}
#else
-__ai __attribute__((target("bf16"))) float32x4_t vcvt_f32_bf16(bfloat16x4_t __p0_135) {
- float32x4_t __ret_135;
- bfloat16x4_t __rev0_135; __rev0_135 = __builtin_shufflevector(__p0_135, __p0_135, 3, 2, 1, 0);
-bfloat16x4_t __reint_135 = __rev0_135;
-int32x4_t __reint1_135 = __noswap_vshll_n_s16(*(int16x4_t *) &__reint_135, 16);
- __ret_135 = *(float32x4_t *) &__reint1_135;
- __ret_135 = __builtin_shufflevector(__ret_135, __ret_135, 3, 2, 1, 0);
- return __ret_135;
-}
-__ai __attribute__((target("bf16"))) float32x4_t __noswap_vcvt_f32_bf16(bfloat16x4_t __p0_136) {
- float32x4_t __ret_136;
-bfloat16x4_t __reint_136 = __p0_136;
-int32x4_t __reint1_136 = __noswap_vshll_n_s16(*(int16x4_t *) &__reint_136, 16);
- __ret_136 = *(float32x4_t *) &__reint1_136;
- return __ret_136;
+__ai __attribute__((target("neon"))) poly16x8x2_t vtrnq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+ poly16x8x2_t __ret;
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 37);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
}
#endif
-__ai __attribute__((target("bf16"))) float32_t vcvtah_f32_bf16(bfloat16_t __p0) {
- float32_t __ret;
-bfloat16_t __reint = __p0;
-int32_t __reint1 = *(int32_t *) &__reint << 16;
- __ret = *(float32_t *) &__reint1;
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16x2_t vtrnq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16x2_t __ret;
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 48);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16_t vcvth_bf16_f32(float32_t __p0) {
- bfloat16_t __ret;
- __ret = (bfloat16_t) __builtin_neon_vcvth_bf16_f32(__p0);
+#else
+__ai __attribute__((target("neon"))) uint8x16x2_t vtrnq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16x2_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-#ifdef __LITTLE_ENDIAN__
-#define vduph_lane_bf16(__p0, __p1) __extension__ ({ \
- bfloat16_t __ret; \
- bfloat16x4_t __s0 = __p0; \
- __ret = (bfloat16_t) __builtin_neon_vduph_lane_bf16((bfloat16x4_t)__s0, __p1); \
- __ret; \
-})
-#else
-#define vduph_lane_bf16(__p0, __p1) __extension__ ({ \
- bfloat16_t __ret; \
- bfloat16x4_t __s0 = __p0; \
- bfloat16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (bfloat16_t) __builtin_neon_vduph_lane_bf16((bfloat16x4_t)__rev0, __p1); \
- __ret; \
-})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupq_lane_bf16(__p0_137, __p1_137) __extension__ ({ \
- bfloat16x8_t __ret_137; \
- bfloat16x4_t __s0_137 = __p0_137; \
- __ret_137 = splatq_lane_bf16(__s0_137, __p1_137); \
- __ret_137; \
-})
+__ai __attribute__((target("neon"))) uint32x4x2_t vtrnq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4x2_t __ret;
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 50);
+ return __ret;
+}
#else
-#define vdupq_lane_bf16(__p0_138, __p1_138) __extension__ ({ \
- bfloat16x8_t __ret_138; \
- bfloat16x4_t __s0_138 = __p0_138; \
- bfloat16x4_t __rev0_138; __rev0_138 = __builtin_shufflevector(__s0_138, __s0_138, 3, 2, 1, 0); \
- __ret_138 = __noswap_splatq_lane_bf16(__rev0_138, __p1_138); \
- __ret_138 = __builtin_shufflevector(__ret_138, __ret_138, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_138; \
-})
+__ai __attribute__((target("neon"))) uint32x4x2_t vtrnq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4x2_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdup_lane_bf16(__p0_139, __p1_139) __extension__ ({ \
- bfloat16x4_t __ret_139; \
- bfloat16x4_t __s0_139 = __p0_139; \
- __ret_139 = splat_lane_bf16(__s0_139, __p1_139); \
- __ret_139; \
-})
+__ai __attribute__((target("neon"))) uint16x8x2_t vtrnq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8x2_t __ret;
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 49);
+ return __ret;
+}
#else
-#define vdup_lane_bf16(__p0_140, __p1_140) __extension__ ({ \
- bfloat16x4_t __ret_140; \
- bfloat16x4_t __s0_140 = __p0_140; \
- bfloat16x4_t __rev0_140; __rev0_140 = __builtin_shufflevector(__s0_140, __s0_140, 3, 2, 1, 0); \
- __ret_140 = __noswap_splat_lane_bf16(__rev0_140, __p1_140); \
- __ret_140 = __builtin_shufflevector(__ret_140, __ret_140, 3, 2, 1, 0); \
- __ret_140; \
-})
+__ai __attribute__((target("neon"))) uint16x8x2_t vtrnq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8x2_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vduph_laneq_bf16(__p0, __p1) __extension__ ({ \
- bfloat16_t __ret; \
- bfloat16x8_t __s0 = __p0; \
- __ret = (bfloat16_t) __builtin_neon_vduph_laneq_bf16((bfloat16x8_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16x2_t vtrnq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16x2_t __ret;
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 32);
+ return __ret;
+}
#else
-#define vduph_laneq_bf16(__p0, __p1) __extension__ ({ \
- bfloat16_t __ret; \
- bfloat16x8_t __s0 = __p0; \
- bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (bfloat16_t) __builtin_neon_vduph_laneq_bf16((bfloat16x8_t)__rev0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16x2_t vtrnq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16x2_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupq_laneq_bf16(__p0_141, __p1_141) __extension__ ({ \
- bfloat16x8_t __ret_141; \
- bfloat16x8_t __s0_141 = __p0_141; \
- __ret_141 = splatq_laneq_bf16(__s0_141, __p1_141); \
- __ret_141; \
-})
+__ai __attribute__((target("neon"))) float32x4x2_t vtrnq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4x2_t __ret;
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 41);
+ return __ret;
+}
#else
-#define vdupq_laneq_bf16(__p0_142, __p1_142) __extension__ ({ \
- bfloat16x8_t __ret_142; \
- bfloat16x8_t __s0_142 = __p0_142; \
- bfloat16x8_t __rev0_142; __rev0_142 = __builtin_shufflevector(__s0_142, __s0_142, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_142 = __noswap_splatq_laneq_bf16(__rev0_142, __p1_142); \
- __ret_142 = __builtin_shufflevector(__ret_142, __ret_142, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_142; \
-})
+__ai __attribute__((target("neon"))) float32x4x2_t vtrnq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4x2_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdup_laneq_bf16(__p0_143, __p1_143) __extension__ ({ \
- bfloat16x4_t __ret_143; \
- bfloat16x8_t __s0_143 = __p0_143; \
- __ret_143 = splat_laneq_bf16(__s0_143, __p1_143); \
- __ret_143; \
-})
+__ai __attribute__((target("neon"))) int32x4x2_t vtrnq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4x2_t __ret;
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 34);
+ return __ret;
+}
#else
-#define vdup_laneq_bf16(__p0_144, __p1_144) __extension__ ({ \
- bfloat16x4_t __ret_144; \
- bfloat16x8_t __s0_144 = __p0_144; \
- bfloat16x8_t __rev0_144; __rev0_144 = __builtin_shufflevector(__s0_144, __s0_144, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_144 = __noswap_splat_laneq_bf16(__rev0_144, __p1_144); \
- __ret_144 = __builtin_shufflevector(__ret_144, __ret_144, 3, 2, 1, 0); \
- __ret_144; \
-})
+__ai __attribute__((target("neon"))) int32x4x2_t vtrnq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4x2_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) bfloat16x8_t vdupq_n_bf16(bfloat16_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+__ai __attribute__((target("neon"))) int16x8x2_t vtrnq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8x2_t __ret;
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 33);
return __ret;
}
#else
-__ai __attribute__((target("bf16"))) bfloat16x8_t vdupq_n_bf16(bfloat16_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16x8x2_t vtrnq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8x2_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) bfloat16x4_t vdup_n_bf16(bfloat16_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t) {__p0, __p0, __p0, __p0};
+__ai __attribute__((target("neon"))) uint8x8x2_t vtrn_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8x2_t __ret;
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 16);
return __ret;
}
#else
-__ai __attribute__((target("bf16"))) bfloat16x4_t vdup_n_bf16(bfloat16_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t) {__p0, __p0, __p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x8x2_t vtrn_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8x2_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) bfloat16x4_t vget_high_bf16(bfloat16x8_t __p0) {
- bfloat16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) uint32x2x2_t vtrn_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2x2_t __ret;
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 18);
return __ret;
}
#else
-__ai __attribute__((target("bf16"))) bfloat16x4_t vget_high_bf16(bfloat16x8_t __p0) {
- bfloat16x4_t __ret;
- bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 4, 5, 6, 7);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x4_t __noswap_vget_high_bf16(bfloat16x8_t __p0) {
- bfloat16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+__ai __attribute__((target("neon"))) uint32x2x2_t vtrn_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vgetq_lane_bf16(__p0, __p1) __extension__ ({ \
- bfloat16_t __ret; \
- bfloat16x8_t __s0 = __p0; \
- __ret = (bfloat16_t) __builtin_neon_vgetq_lane_bf16((bfloat16x8_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4x2_t vtrn_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4x2_t __ret;
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 17);
+ return __ret;
+}
#else
-#define vgetq_lane_bf16(__p0, __p1) __extension__ ({ \
- bfloat16_t __ret; \
- bfloat16x8_t __s0 = __p0; \
- bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (bfloat16_t) __builtin_neon_vgetq_lane_bf16((bfloat16x8_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vgetq_lane_bf16(__p0, __p1) __extension__ ({ \
- bfloat16_t __ret; \
- bfloat16x8_t __s0 = __p0; \
- __ret = (bfloat16_t) __builtin_neon_vgetq_lane_bf16((bfloat16x8_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4x2_t vtrn_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4x2_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vget_lane_bf16(__p0, __p1) __extension__ ({ \
- bfloat16_t __ret; \
- bfloat16x4_t __s0 = __p0; \
- __ret = (bfloat16_t) __builtin_neon_vget_lane_bf16((bfloat16x4_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8x2_t vtrn_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8x2_t __ret;
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 0);
+ return __ret;
+}
#else
-#define vget_lane_bf16(__p0, __p1) __extension__ ({ \
- bfloat16_t __ret; \
- bfloat16x4_t __s0 = __p0; \
- bfloat16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (bfloat16_t) __builtin_neon_vget_lane_bf16((bfloat16x4_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vget_lane_bf16(__p0, __p1) __extension__ ({ \
- bfloat16_t __ret; \
- bfloat16x4_t __s0 = __p0; \
- __ret = (bfloat16_t) __builtin_neon_vget_lane_bf16((bfloat16x4_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8x2_t vtrn_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8x2_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) bfloat16x4_t vget_low_bf16(bfloat16x8_t __p0) {
- bfloat16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3);
+__ai __attribute__((target("neon"))) float32x2x2_t vtrn_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2x2_t __ret;
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 9);
return __ret;
}
#else
-__ai __attribute__((target("bf16"))) bfloat16x4_t vget_low_bf16(bfloat16x8_t __p0) {
- bfloat16x4_t __ret;
- bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x2x2_t vtrn_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16x4_t __noswap_vget_low_bf16(bfloat16x8_t __p0) {
- bfloat16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2x2_t vtrn_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2x2_t __ret;
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 2);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2x2_t vtrn_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_bf16(__p0) __extension__ ({ \
- bfloat16x8_t __ret; \
- __ret = (bfloat16x8_t) __builtin_neon_vld1q_bf16(__p0, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4x2_t vtrn_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4x2_t __ret;
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 1);
+ return __ret;
+}
#else
-#define vld1q_bf16(__p0) __extension__ ({ \
- bfloat16x8_t __ret; \
- __ret = (bfloat16x8_t) __builtin_neon_vld1q_bf16(__p0, 43); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x4x2_t vtrn_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4x2_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_bf16(__p0) __extension__ ({ \
- bfloat16x4_t __ret; \
- __ret = (bfloat16x4_t) __builtin_neon_vld1_bf16(__p0, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float16x8x2_t vtrnq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8x2_t __ret;
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 40);
+ return __ret;
+}
#else
-#define vld1_bf16(__p0) __extension__ ({ \
- bfloat16x4_t __ret; \
- __ret = (bfloat16x4_t) __builtin_neon_vld1_bf16(__p0, 11); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float16x8x2_t vtrnq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8x2_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_dup_bf16(__p0) __extension__ ({ \
- bfloat16x8_t __ret; \
- __ret = (bfloat16x8_t) __builtin_neon_vld1q_dup_bf16(__p0, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float16x4x2_t vtrn_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4x2_t __ret;
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 8);
+ return __ret;
+}
#else
-#define vld1q_dup_bf16(__p0) __extension__ ({ \
- bfloat16x8_t __ret; \
- __ret = (bfloat16x8_t) __builtin_neon_vld1q_dup_bf16(__p0, 43); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float16x4x2_t vtrn_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4x2_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_dup_bf16(__p0) __extension__ ({ \
- bfloat16x4_t __ret; \
- __ret = (bfloat16x4_t) __builtin_neon_vld1_dup_bf16(__p0, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vtst_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ return __ret;
+}
#else
-#define vld1_dup_bf16(__p0) __extension__ ({ \
- bfloat16x4_t __ret; \
- __ret = (bfloat16x4_t) __builtin_neon_vld1_dup_bf16(__p0, 11); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vtst_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ uint8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8_t __ret; \
- bfloat16x8_t __s1 = __p1; \
- __ret = (bfloat16x8_t) __builtin_neon_vld1q_lane_bf16(__p0, (int8x16_t)__s1, __p2, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vtst_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ return __ret;
+}
#else
-#define vld1q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8_t __ret; \
- bfloat16x8_t __s1 = __p1; \
- bfloat16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (bfloat16x8_t) __builtin_neon_vld1q_lane_bf16(__p0, (int8x16_t)__rev1, __p2, 43); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vtst_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ uint16x4_t __ret;
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4_t __ret; \
- bfloat16x4_t __s1 = __p1; \
- __ret = (bfloat16x4_t) __builtin_neon_vld1_lane_bf16(__p0, (int8x8_t)__s1, __p2, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vtstq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ return __ret;
+}
#else
-#define vld1_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4_t __ret; \
- bfloat16x4_t __s1 = __p1; \
- bfloat16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (bfloat16x4_t) __builtin_neon_vld1_lane_bf16(__p0, (int8x8_t)__rev1, __p2, 11); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vtstq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ uint8x16_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_bf16_x2(__p0) __extension__ ({ \
- bfloat16x8x2_t __ret; \
- __builtin_neon_vld1q_bf16_x2(&__ret, __p0, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vtstq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ return __ret;
+}
#else
-#define vld1q_bf16_x2(__p0) __extension__ ({ \
- bfloat16x8x2_t __ret; \
- __builtin_neon_vld1q_bf16_x2(&__ret, __p0, 43); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vtstq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+ uint16x8_t __ret;
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_bf16_x2(__p0) __extension__ ({ \
- bfloat16x4x2_t __ret; \
- __builtin_neon_vld1_bf16_x2(&__ret, __p0, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vtstq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ return __ret;
+}
#else
-#define vld1_bf16_x2(__p0) __extension__ ({ \
- bfloat16x4x2_t __ret; \
- __builtin_neon_vld1_bf16_x2(&__ret, __p0, 11); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vtstq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_bf16_x3(__p0) __extension__ ({ \
- bfloat16x8x3_t __ret; \
- __builtin_neon_vld1q_bf16_x3(&__ret, __p0, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vtstq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+ return __ret;
+}
#else
-#define vld1q_bf16_x3(__p0) __extension__ ({ \
- bfloat16x8x3_t __ret; \
- __builtin_neon_vld1q_bf16_x3(&__ret, __p0, 43); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vtstq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_bf16_x3(__p0) __extension__ ({ \
- bfloat16x4x3_t __ret; \
- __builtin_neon_vld1_bf16_x3(&__ret, __p0, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vtstq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ return __ret;
+}
#else
-#define vld1_bf16_x3(__p0) __extension__ ({ \
- bfloat16x4x3_t __ret; \
- __builtin_neon_vld1_bf16_x3(&__ret, __p0, 11); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vtstq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_bf16_x4(__p0) __extension__ ({ \
- bfloat16x8x4_t __ret; \
- __builtin_neon_vld1q_bf16_x4(&__ret, __p0, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vtstq_s8(int8x16_t __p0, int8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ return __ret;
+}
#else
-#define vld1q_bf16_x4(__p0) __extension__ ({ \
- bfloat16x8x4_t __ret; \
- __builtin_neon_vld1q_bf16_x4(&__ret, __p0, 43); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vtstq_s8(int8x16_t __p0, int8x16_t __p1) {
+ uint8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1_bf16_x4(__p0) __extension__ ({ \
- bfloat16x4x4_t __ret; \
- __builtin_neon_vld1_bf16_x4(&__ret, __p0, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vtstq_s32(int32x4_t __p0, int32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+ return __ret;
+}
#else
-#define vld1_bf16_x4(__p0) __extension__ ({ \
- bfloat16x4x4_t __ret; \
- __builtin_neon_vld1_bf16_x4(&__ret, __p0, 11); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vtstq_s32(int32x4_t __p0, int32x4_t __p1) {
+ uint32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_bf16(__p0) __extension__ ({ \
- bfloat16x8x2_t __ret; \
- __builtin_neon_vld2q_bf16(&__ret, __p0, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vtstq_s16(int16x8_t __p0, int16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ return __ret;
+}
#else
-#define vld2q_bf16(__p0) __extension__ ({ \
- bfloat16x8x2_t __ret; \
- __builtin_neon_vld2q_bf16(&__ret, __p0, 43); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vtstq_s16(int16x8_t __p0, int16x8_t __p1) {
+ uint16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_bf16(__p0) __extension__ ({ \
- bfloat16x4x2_t __ret; \
- __builtin_neon_vld2_bf16(&__ret, __p0, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vtst_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ return __ret;
+}
#else
-#define vld2_bf16(__p0) __extension__ ({ \
- bfloat16x4x2_t __ret; \
- __builtin_neon_vld2_bf16(&__ret, __p0, 11); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vtst_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_dup_bf16(__p0) __extension__ ({ \
- bfloat16x8x2_t __ret; \
- __builtin_neon_vld2q_dup_bf16(&__ret, __p0, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vtst_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ return __ret;
+}
#else
-#define vld2q_dup_bf16(__p0) __extension__ ({ \
- bfloat16x8x2_t __ret; \
- __builtin_neon_vld2q_dup_bf16(&__ret, __p0, 43); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vtst_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_dup_bf16(__p0) __extension__ ({ \
- bfloat16x4x2_t __ret; \
- __builtin_neon_vld2_dup_bf16(&__ret, __p0, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vtst_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ return __ret;
+}
#else
-#define vld2_dup_bf16(__p0) __extension__ ({ \
- bfloat16x4x2_t __ret; \
- __builtin_neon_vld2_dup_bf16(&__ret, __p0, 11); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vtst_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8x2_t __ret; \
- bfloat16x8x2_t __s1 = __p1; \
- __builtin_neon_vld2q_lane_bf16(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vtst_s8(int8x8_t __p0, int8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+ return __ret;
+}
#else
-#define vld2q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8x2_t __ret; \
- bfloat16x8x2_t __s1 = __p1; \
- bfloat16x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld2q_lane_bf16(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 43); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vtst_s8(int8x8_t __p0, int8x8_t __p1) {
+ uint8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4x2_t __ret; \
- bfloat16x4x2_t __s1 = __p1; \
- __builtin_neon_vld2_lane_bf16(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vtst_s32(int32x2_t __p0, int32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+ return __ret;
+}
#else
-#define vld2_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4x2_t __ret; \
- bfloat16x4x2_t __s1 = __p1; \
- bfloat16x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vld2_lane_bf16(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 11); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vtst_s32(int32x2_t __p0, int32x2_t __p1) {
+ uint32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_bf16(__p0) __extension__ ({ \
- bfloat16x8x3_t __ret; \
- __builtin_neon_vld3q_bf16(&__ret, __p0, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vtst_s16(int16x4_t __p0, int16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+ return __ret;
+}
#else
-#define vld3q_bf16(__p0) __extension__ ({ \
- bfloat16x8x3_t __ret; \
- __builtin_neon_vld3q_bf16(&__ret, __p0, 43); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vtst_s16(int16x4_t __p0, int16x4_t __p1) {
+ uint16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_bf16(__p0) __extension__ ({ \
- bfloat16x4x3_t __ret; \
- __builtin_neon_vld3_bf16(&__ret, __p0, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x8x2_t vuzp_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly8x8x2_t __ret;
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 4);
+ return __ret;
+}
#else
-#define vld3_bf16(__p0) __extension__ ({ \
- bfloat16x4x3_t __ret; \
- __builtin_neon_vld3_bf16(&__ret, __p0, 11); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x8x2_t vuzp_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly8x8x2_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 4);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_dup_bf16(__p0) __extension__ ({ \
- bfloat16x8x3_t __ret; \
- __builtin_neon_vld3q_dup_bf16(&__ret, __p0, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x4x2_t vuzp_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ poly16x4x2_t __ret;
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 5);
+ return __ret;
+}
#else
-#define vld3q_dup_bf16(__p0) __extension__ ({ \
- bfloat16x8x3_t __ret; \
- __builtin_neon_vld3q_dup_bf16(&__ret, __p0, 43); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x4x2_t vuzp_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ poly16x4x2_t __ret;
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 5);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_dup_bf16(__p0) __extension__ ({ \
- bfloat16x4x3_t __ret; \
- __builtin_neon_vld3_dup_bf16(&__ret, __p0, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x16x2_t vuzpq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly8x16x2_t __ret;
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 36);
+ return __ret;
+}
#else
-#define vld3_dup_bf16(__p0) __extension__ ({ \
- bfloat16x4x3_t __ret; \
- __builtin_neon_vld3_dup_bf16(&__ret, __p0, 11); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x16x2_t vuzpq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly8x16x2_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 36);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8x3_t __ret; \
- bfloat16x8x3_t __s1 = __p1; \
- __builtin_neon_vld3q_lane_bf16(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x8x2_t vuzpq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+ poly16x8x2_t __ret;
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 37);
+ return __ret;
+}
#else
-#define vld3q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8x3_t __ret; \
- bfloat16x8x3_t __s1 = __p1; \
- bfloat16x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld3q_lane_bf16(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 43); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x8x2_t vuzpq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+ poly16x8x2_t __ret;
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 37);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4x3_t __ret; \
- bfloat16x4x3_t __s1 = __p1; \
- __builtin_neon_vld3_lane_bf16(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16x2_t vuzpq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16x2_t __ret;
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 48);
+ return __ret;
+}
#else
-#define vld3_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4x3_t __ret; \
- bfloat16x4x3_t __s1 = __p1; \
- bfloat16x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vld3_lane_bf16(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 11); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16x2_t vuzpq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16x2_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_bf16(__p0) __extension__ ({ \
- bfloat16x8x4_t __ret; \
- __builtin_neon_vld4q_bf16(&__ret, __p0, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4x2_t vuzpq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4x2_t __ret;
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 50);
+ return __ret;
+}
#else
-#define vld4q_bf16(__p0) __extension__ ({ \
- bfloat16x8x4_t __ret; \
- __builtin_neon_vld4q_bf16(&__ret, __p0, 43); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4x2_t vuzpq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4x2_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_bf16(__p0) __extension__ ({ \
- bfloat16x4x4_t __ret; \
- __builtin_neon_vld4_bf16(&__ret, __p0, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8x2_t vuzpq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8x2_t __ret;
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 49);
+ return __ret;
+}
#else
-#define vld4_bf16(__p0) __extension__ ({ \
- bfloat16x4x4_t __ret; \
- __builtin_neon_vld4_bf16(&__ret, __p0, 11); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8x2_t vuzpq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8x2_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_dup_bf16(__p0) __extension__ ({ \
- bfloat16x8x4_t __ret; \
- __builtin_neon_vld4q_dup_bf16(&__ret, __p0, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16x2_t vuzpq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16x2_t __ret;
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 32);
+ return __ret;
+}
#else
-#define vld4q_dup_bf16(__p0) __extension__ ({ \
- bfloat16x8x4_t __ret; \
- __builtin_neon_vld4q_dup_bf16(&__ret, __p0, 43); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16x2_t vuzpq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16x2_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_dup_bf16(__p0) __extension__ ({ \
- bfloat16x4x4_t __ret; \
- __builtin_neon_vld4_dup_bf16(&__ret, __p0, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x4x2_t vuzpq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4x2_t __ret;
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 41);
+ return __ret;
+}
#else
-#define vld4_dup_bf16(__p0) __extension__ ({ \
- bfloat16x4x4_t __ret; \
- __builtin_neon_vld4_dup_bf16(&__ret, __p0, 11); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x4x2_t vuzpq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4x2_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8x4_t __ret; \
- bfloat16x8x4_t __s1 = __p1; \
- __builtin_neon_vld4q_lane_bf16(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 43); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4x2_t vuzpq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4x2_t __ret;
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 34);
+ return __ret;
+}
#else
-#define vld4q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8x4_t __ret; \
- bfloat16x8x4_t __s1 = __p1; \
- bfloat16x8x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld4q_lane_bf16(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 43); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4x2_t vuzpq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4x2_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4x4_t __ret; \
- bfloat16x4x4_t __s1 = __p1; \
- __builtin_neon_vld4_lane_bf16(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 11); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8x2_t vuzpq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8x2_t __ret;
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 33);
+ return __ret;
+}
#else
-#define vld4_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4x4_t __ret; \
- bfloat16x4x4_t __s1 = __p1; \
- bfloat16x4x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vld4_lane_bf16(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 11); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8x2_t vuzpq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8x2_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsetq_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8_t __ret; \
- bfloat16_t __s0 = __p0; \
- bfloat16x8_t __s1 = __p1; \
- __ret = (bfloat16x8_t) __builtin_neon_vsetq_lane_bf16(__s0, (bfloat16x8_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8x2_t vuzp_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8x2_t __ret;
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 16);
+ return __ret;
+}
#else
-#define vsetq_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8_t __ret; \
- bfloat16_t __s0 = __p0; \
- bfloat16x8_t __s1 = __p1; \
- bfloat16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (bfloat16x8_t) __builtin_neon_vsetq_lane_bf16(__s0, (bfloat16x8_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vsetq_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8_t __ret; \
- bfloat16_t __s0 = __p0; \
- bfloat16x8_t __s1 = __p1; \
- __ret = (bfloat16x8_t) __builtin_neon_vsetq_lane_bf16(__s0, (bfloat16x8_t)__s1, __p2); \
- __ret; \
-})
-#endif
+__ai __attribute__((target("neon"))) uint8x8x2_t vuzp_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8x2_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 16);
-#ifdef __LITTLE_ENDIAN__
-#define vset_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4_t __ret; \
- bfloat16_t __s0 = __p0; \
- bfloat16x4_t __s1 = __p1; \
- __ret = (bfloat16x4_t) __builtin_neon_vset_lane_bf16(__s0, (bfloat16x4_t)__s1, __p2); \
- __ret; \
-})
-#else
-#define vset_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4_t __ret; \
- bfloat16_t __s0 = __p0; \
- bfloat16x4_t __s1 = __p1; \
- bfloat16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (bfloat16x4_t) __builtin_neon_vset_lane_bf16(__s0, (bfloat16x4_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vset_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4_t __ret; \
- bfloat16_t __s0 = __p0; \
- bfloat16x4_t __s1 = __p1; \
- __ret = (bfloat16x4_t) __builtin_neon_vset_lane_bf16(__s0, (bfloat16x4_t)__s1, __p2); \
- __ret; \
-})
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x8_t __s1 = __p1; \
- __builtin_neon_vst1q_bf16(__p0, (int8x16_t)__s1, 43); \
-})
+__ai __attribute__((target("neon"))) uint32x2x2_t vuzp_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2x2_t __ret;
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 18);
+ return __ret;
+}
#else
-#define vst1q_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x8_t __s1 = __p1; \
- bfloat16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_bf16(__p0, (int8x16_t)__rev1, 43); \
-})
+__ai __attribute__((target("neon"))) uint32x2x2_t vuzp_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x4_t __s1 = __p1; \
- __builtin_neon_vst1_bf16(__p0, (int8x8_t)__s1, 11); \
-})
+__ai __attribute__((target("neon"))) uint16x4x2_t vuzp_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4x2_t __ret;
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 17);
+ return __ret;
+}
#else
-#define vst1_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x4_t __s1 = __p1; \
- bfloat16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __builtin_neon_vst1_bf16(__p0, (int8x8_t)__rev1, 11); \
-})
+__ai __attribute__((target("neon"))) uint16x4x2_t vuzp_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4x2_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8_t __s1 = __p1; \
- __builtin_neon_vst1q_lane_bf16(__p0, (int8x16_t)__s1, __p2, 43); \
-})
+__ai __attribute__((target("neon"))) int8x8x2_t vuzp_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8x2_t __ret;
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 0);
+ return __ret;
+}
#else
-#define vst1q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8_t __s1 = __p1; \
- bfloat16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_lane_bf16(__p0, (int8x16_t)__rev1, __p2, 43); \
-})
+__ai __attribute__((target("neon"))) int8x8x2_t vuzp_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8x2_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4_t __s1 = __p1; \
- __builtin_neon_vst1_lane_bf16(__p0, (int8x8_t)__s1, __p2, 11); \
-})
+__ai __attribute__((target("neon"))) float32x2x2_t vuzp_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2x2_t __ret;
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 9);
+ return __ret;
+}
#else
-#define vst1_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4_t __s1 = __p1; \
- bfloat16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __builtin_neon_vst1_lane_bf16(__p0, (int8x8_t)__rev1, __p2, 11); \
-})
+__ai __attribute__((target("neon"))) float32x2x2_t vuzp_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_bf16_x2(__p0, __p1) __extension__ ({ \
- bfloat16x8x2_t __s1 = __p1; \
- __builtin_neon_vst1q_bf16_x2(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 43); \
-})
+__ai __attribute__((target("neon"))) int32x2x2_t vuzp_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2x2_t __ret;
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 2);
+ return __ret;
+}
#else
-#define vst1q_bf16_x2(__p0, __p1) __extension__ ({ \
- bfloat16x8x2_t __s1 = __p1; \
- bfloat16x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_bf16_x2(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 43); \
-})
+__ai __attribute__((target("neon"))) int32x2x2_t vuzp_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_bf16_x2(__p0, __p1) __extension__ ({ \
- bfloat16x4x2_t __s1 = __p1; \
- __builtin_neon_vst1_bf16_x2(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 11); \
-})
+__ai __attribute__((target("neon"))) int16x4x2_t vuzp_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4x2_t __ret;
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 1);
+ return __ret;
+}
#else
-#define vst1_bf16_x2(__p0, __p1) __extension__ ({ \
- bfloat16x4x2_t __s1 = __p1; \
- bfloat16x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst1_bf16_x2(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 11); \
-})
+__ai __attribute__((target("neon"))) int16x4x2_t vuzp_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4x2_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_bf16_x3(__p0, __p1) __extension__ ({ \
- bfloat16x8x3_t __s1 = __p1; \
- __builtin_neon_vst1q_bf16_x3(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 43); \
-})
+__ai __attribute__((target("neon"))) float16x8x2_t vuzpq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8x2_t __ret;
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 40);
+ return __ret;
+}
#else
-#define vst1q_bf16_x3(__p0, __p1) __extension__ ({ \
- bfloat16x8x3_t __s1 = __p1; \
- bfloat16x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_bf16_x3(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 43); \
-})
+__ai __attribute__((target("neon"))) float16x8x2_t vuzpq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8x2_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_bf16_x3(__p0, __p1) __extension__ ({ \
- bfloat16x4x3_t __s1 = __p1; \
- __builtin_neon_vst1_bf16_x3(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 11); \
-})
+__ai __attribute__((target("neon"))) float16x4x2_t vuzp_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4x2_t __ret;
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 8);
+ return __ret;
+}
#else
-#define vst1_bf16_x3(__p0, __p1) __extension__ ({ \
- bfloat16x4x3_t __s1 = __p1; \
- bfloat16x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst1_bf16_x3(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 11); \
-})
+__ai __attribute__((target("neon"))) float16x4x2_t vuzp_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4x2_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1q_bf16_x4(__p0, __p1) __extension__ ({ \
- bfloat16x8x4_t __s1 = __p1; \
- __builtin_neon_vst1q_bf16_x4(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 43); \
-})
+__ai __attribute__((target("neon"))) poly8x8x2_t vzip_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly8x8x2_t __ret;
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 4);
+ return __ret;
+}
#else
-#define vst1q_bf16_x4(__p0, __p1) __extension__ ({ \
- bfloat16x8x4_t __s1 = __p1; \
- bfloat16x8x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst1q_bf16_x4(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 43); \
-})
+__ai __attribute__((target("neon"))) poly8x8x2_t vzip_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly8x8x2_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 4);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst1_bf16_x4(__p0, __p1) __extension__ ({ \
- bfloat16x4x4_t __s1 = __p1; \
- __builtin_neon_vst1_bf16_x4(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 11); \
-})
+__ai __attribute__((target("neon"))) poly16x4x2_t vzip_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ poly16x4x2_t __ret;
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 5);
+ return __ret;
+}
#else
-#define vst1_bf16_x4(__p0, __p1) __extension__ ({ \
- bfloat16x4x4_t __s1 = __p1; \
- bfloat16x4x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst1_bf16_x4(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 11); \
-})
+__ai __attribute__((target("neon"))) poly16x4x2_t vzip_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ poly16x4x2_t __ret;
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 5);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2q_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x8x2_t __s1 = __p1; \
- __builtin_neon_vst2q_bf16(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 43); \
-})
+__ai __attribute__((target("neon"))) poly8x16x2_t vzipq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly8x16x2_t __ret;
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 36);
+ return __ret;
+}
#else
-#define vst2q_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x8x2_t __s1 = __p1; \
- bfloat16x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2q_bf16(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 43); \
-})
+__ai __attribute__((target("neon"))) poly8x16x2_t vzipq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly8x16x2_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 36);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x4x2_t __s1 = __p1; \
- __builtin_neon_vst2_bf16(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 11); \
-})
+__ai __attribute__((target("neon"))) poly16x8x2_t vzipq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+ poly16x8x2_t __ret;
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 37);
+ return __ret;
+}
#else
-#define vst2_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x4x2_t __s1 = __p1; \
- bfloat16x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst2_bf16(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 11); \
-})
+__ai __attribute__((target("neon"))) poly16x8x2_t vzipq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+ poly16x8x2_t __ret;
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 37);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8x2_t __s1 = __p1; \
- __builtin_neon_vst2q_lane_bf16(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 43); \
-})
+__ai __attribute__((target("neon"))) uint8x16x2_t vzipq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16x2_t __ret;
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 48);
+ return __ret;
+}
#else
-#define vst2q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8x2_t __s1 = __p1; \
- bfloat16x8x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2q_lane_bf16(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 43); \
-})
+__ai __attribute__((target("neon"))) uint8x16x2_t vzipq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16x2_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst2_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4x2_t __s1 = __p1; \
- __builtin_neon_vst2_lane_bf16(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 11); \
-})
+__ai __attribute__((target("neon"))) uint32x4x2_t vzipq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4x2_t __ret;
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 50);
+ return __ret;
+}
#else
-#define vst2_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4x2_t __s1 = __p1; \
- bfloat16x4x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __builtin_neon_vst2_lane_bf16(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 11); \
-})
+__ai __attribute__((target("neon"))) uint32x4x2_t vzipq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4x2_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3q_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x8x3_t __s1 = __p1; \
- __builtin_neon_vst3q_bf16(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 43); \
-})
+__ai __attribute__((target("neon"))) uint16x8x2_t vzipq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8x2_t __ret;
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 49);
+ return __ret;
+}
#else
-#define vst3q_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x8x3_t __s1 = __p1; \
- bfloat16x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3q_bf16(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 43); \
-})
+__ai __attribute__((target("neon"))) uint16x8x2_t vzipq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8x2_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x4x3_t __s1 = __p1; \
- __builtin_neon_vst3_bf16(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 11); \
-})
+__ai __attribute__((target("neon"))) int8x16x2_t vzipq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16x2_t __ret;
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 32);
+ return __ret;
+}
#else
-#define vst3_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x4x3_t __s1 = __p1; \
- bfloat16x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst3_bf16(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 11); \
-})
+__ai __attribute__((target("neon"))) int8x16x2_t vzipq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16x2_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8x3_t __s1 = __p1; \
- __builtin_neon_vst3q_lane_bf16(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 43); \
-})
+__ai __attribute__((target("neon"))) float32x4x2_t vzipq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4x2_t __ret;
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 41);
+ return __ret;
+}
#else
-#define vst3q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8x3_t __s1 = __p1; \
- bfloat16x8x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3q_lane_bf16(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 43); \
-})
+__ai __attribute__((target("neon"))) float32x4x2_t vzipq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4x2_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst3_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4x3_t __s1 = __p1; \
- __builtin_neon_vst3_lane_bf16(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 11); \
-})
+__ai __attribute__((target("neon"))) int32x4x2_t vzipq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4x2_t __ret;
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 34);
+ return __ret;
+}
#else
-#define vst3_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4x3_t __s1 = __p1; \
- bfloat16x4x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __builtin_neon_vst3_lane_bf16(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 11); \
-})
+__ai __attribute__((target("neon"))) int32x4x2_t vzipq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4x2_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4q_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x8x4_t __s1 = __p1; \
- __builtin_neon_vst4q_bf16(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 43); \
-})
+__ai __attribute__((target("neon"))) int16x8x2_t vzipq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8x2_t __ret;
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 33);
+ return __ret;
+}
#else
-#define vst4q_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x8x4_t __s1 = __p1; \
- bfloat16x8x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4q_bf16(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 43); \
-})
+__ai __attribute__((target("neon"))) int16x8x2_t vzipq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8x2_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x4x4_t __s1 = __p1; \
- __builtin_neon_vst4_bf16(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 11); \
-})
+__ai __attribute__((target("neon"))) uint8x8x2_t vzip_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8x2_t __ret;
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 16);
+ return __ret;
+}
#else
-#define vst4_bf16(__p0, __p1) __extension__ ({ \
- bfloat16x4x4_t __s1 = __p1; \
- bfloat16x4x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst4_bf16(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 11); \
-})
+__ai __attribute__((target("neon"))) uint8x8x2_t vzip_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8x2_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8x4_t __s1 = __p1; \
- __builtin_neon_vst4q_lane_bf16(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 43); \
-})
+__ai __attribute__((target("neon"))) uint32x2x2_t vzip_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2x2_t __ret;
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 18);
+ return __ret;
+}
#else
-#define vst4q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x8x4_t __s1 = __p1; \
- bfloat16x8x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4q_lane_bf16(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 43); \
-})
+__ai __attribute__((target("neon"))) uint32x2x2_t vzip_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vst4_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4x4_t __s1 = __p1; \
- __builtin_neon_vst4_lane_bf16(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 11); \
-})
+__ai __attribute__((target("neon"))) uint16x4x2_t vzip_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4x2_t __ret;
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 17);
+ return __ret;
+}
#else
-#define vst4_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
- bfloat16x4x4_t __s1 = __p1; \
- bfloat16x4x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
- __builtin_neon_vst4_lane_bf16(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 11); \
-})
+__ai __attribute__((target("neon"))) uint16x4x2_t vzip_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4x2_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("dotprod"))) uint32x4_t vdotq_u32(uint32x4_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vdotq_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
+__ai __attribute__((target("neon"))) int8x8x2_t vzip_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8x2_t __ret;
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 0);
return __ret;
}
#else
-__ai __attribute__((target("dotprod"))) uint32x4_t vdotq_u32(uint32x4_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vdotq_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int8x8x2_t vzip_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8x2_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai __attribute__((target("dotprod"))) uint32x4_t __noswap_vdotq_u32(uint32x4_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vdotq_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2x2_t vzip_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2x2_t __ret;
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 9);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2x2_t vzip_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2x2_t vzip_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2x2_t __ret;
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 2);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2x2_t vzip_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4x2_t vzip_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4x2_t __ret;
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4x2_t vzip_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4x2_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x8x2_t vzipq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8x2_t __ret;
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 40);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x8x2_t vzipq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8x2_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x4x2_t vzip_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4x2_t __ret;
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 8);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x4x2_t vzip_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4x2_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("dotprod"))) int32x4_t vdotq_s32(int32x4_t __p0, int8x16_t __p1, int8x16_t __p2) {
+__ai __attribute__((target("v8.1a,neon"))) int32x4_t vqrdmlahq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vdotq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+ __ret = (int32x4_t) __builtin_neon_vqrdmlahq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
return __ret;
}
#else
-__ai __attribute__((target("dotprod"))) int32x4_t vdotq_s32(int32x4_t __p0, int8x16_t __p1, int8x16_t __p2) {
+__ai __attribute__((target("v8.1a,neon"))) int32x4_t vqrdmlahq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vdotq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vqrdmlahq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai __attribute__((target("dotprod"))) int32x4_t __noswap_vdotq_s32(int32x4_t __p0, int8x16_t __p1, int8x16_t __p2) {
+__ai __attribute__((target("v8.1a,neon"))) int32x4_t __noswap_vqrdmlahq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vdotq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+ __ret = (int32x4_t) __builtin_neon_vqrdmlahq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("dotprod"))) uint32x2_t vdot_u32(uint32x2_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vdot_u32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 18);
+__ai __attribute__((target("v8.1a,neon"))) int16x8_t vqrdmlahq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vqrdmlahq_s16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
return __ret;
}
#else
-__ai __attribute__((target("dotprod"))) uint32x2_t vdot_u32(uint32x2_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vdot_u32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("v8.1a,neon"))) int16x8_t vqrdmlahq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vqrdmlahq_s16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai __attribute__((target("dotprod"))) uint32x2_t __noswap_vdot_u32(uint32x2_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vdot_u32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 18);
+__ai __attribute__((target("v8.1a,neon"))) int16x8_t __noswap_vqrdmlahq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vqrdmlahq_s16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("dotprod"))) int32x2_t vdot_s32(int32x2_t __p0, int8x8_t __p1, int8x8_t __p2) {
+__ai __attribute__((target("v8.1a,neon"))) int32x2_t vqrdmlah_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vdot_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
+ __ret = (int32x2_t) __builtin_neon_vqrdmlah_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
return __ret;
}
#else
-__ai __attribute__((target("dotprod"))) int32x2_t vdot_s32(int32x2_t __p0, int8x8_t __p1, int8x8_t __p2) {
+__ai __attribute__((target("v8.1a,neon"))) int32x2_t vqrdmlah_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vdot_s32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 2);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ int32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vqrdmlah_s32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 2);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai __attribute__((target("dotprod"))) int32x2_t __noswap_vdot_s32(int32x2_t __p0, int8x8_t __p1, int8x8_t __p2) {
+__ai __attribute__((target("v8.1a,neon"))) int32x2_t __noswap_vqrdmlah_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vdot_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
+ __ret = (int32x2_t) __builtin_neon_vqrdmlah_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdotq_lane_u32(__p0_145, __p1_145, __p2_145, __p3_145) __extension__ ({ \
- uint32x4_t __ret_145; \
- uint32x4_t __s0_145 = __p0_145; \
- uint8x16_t __s1_145 = __p1_145; \
- uint8x8_t __s2_145 = __p2_145; \
-uint8x8_t __reint_145 = __s2_145; \
-uint32x4_t __reint1_145 = splatq_lane_u32(*(uint32x2_t *) &__reint_145, __p3_145); \
- __ret_145 = vdotq_u32(__s0_145, __s1_145, *(uint8x16_t *) &__reint1_145); \
- __ret_145; \
+__ai __attribute__((target("v8.1a,neon"))) int16x4_t vqrdmlah_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vqrdmlah_s16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("v8.1a,neon"))) int16x4_t vqrdmlah_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ int16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vqrdmlah_s16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("v8.1a,neon"))) int16x4_t __noswap_vqrdmlah_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vqrdmlah_s16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 1);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlahq_lane_s32(__p0_134, __p1_134, __p2_134, __p3_134) __extension__ ({ \
+ int32x4_t __ret_134; \
+ int32x4_t __s0_134 = __p0_134; \
+ int32x4_t __s1_134 = __p1_134; \
+ int32x2_t __s2_134 = __p2_134; \
+ __ret_134 = vqrdmlahq_s32(__s0_134, __s1_134, splatq_lane_s32(__s2_134, __p3_134)); \
+ __ret_134; \
})
#else
-#define vdotq_lane_u32(__p0_146, __p1_146, __p2_146, __p3_146) __extension__ ({ \
- uint32x4_t __ret_146; \
- uint32x4_t __s0_146 = __p0_146; \
- uint8x16_t __s1_146 = __p1_146; \
- uint8x8_t __s2_146 = __p2_146; \
- uint32x4_t __rev0_146; __rev0_146 = __builtin_shufflevector(__s0_146, __s0_146, 3, 2, 1, 0); \
- uint8x16_t __rev1_146; __rev1_146 = __builtin_shufflevector(__s1_146, __s1_146, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint8x8_t __rev2_146; __rev2_146 = __builtin_shufflevector(__s2_146, __s2_146, 7, 6, 5, 4, 3, 2, 1, 0); \
-uint8x8_t __reint_146 = __rev2_146; \
-uint32x4_t __reint1_146 = __noswap_splatq_lane_u32(*(uint32x2_t *) &__reint_146, __p3_146); \
- __ret_146 = __noswap_vdotq_u32(__rev0_146, __rev1_146, *(uint8x16_t *) &__reint1_146); \
- __ret_146 = __builtin_shufflevector(__ret_146, __ret_146, 3, 2, 1, 0); \
- __ret_146; \
+#define vqrdmlahq_lane_s32(__p0_135, __p1_135, __p2_135, __p3_135) __extension__ ({ \
+ int32x4_t __ret_135; \
+ int32x4_t __s0_135 = __p0_135; \
+ int32x4_t __s1_135 = __p1_135; \
+ int32x2_t __s2_135 = __p2_135; \
+ int32x4_t __rev0_135; __rev0_135 = __builtin_shufflevector(__s0_135, __s0_135, 3, 2, 1, 0); \
+ int32x4_t __rev1_135; __rev1_135 = __builtin_shufflevector(__s1_135, __s1_135, 3, 2, 1, 0); \
+ int32x2_t __rev2_135; __rev2_135 = __builtin_shufflevector(__s2_135, __s2_135, 1, 0); \
+ __ret_135 = __noswap_vqrdmlahq_s32(__rev0_135, __rev1_135, __noswap_splatq_lane_s32(__rev2_135, __p3_135)); \
+ __ret_135 = __builtin_shufflevector(__ret_135, __ret_135, 3, 2, 1, 0); \
+ __ret_135; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdotq_lane_s32(__p0_147, __p1_147, __p2_147, __p3_147) __extension__ ({ \
- int32x4_t __ret_147; \
- int32x4_t __s0_147 = __p0_147; \
- int8x16_t __s1_147 = __p1_147; \
- int8x8_t __s2_147 = __p2_147; \
-int8x8_t __reint_147 = __s2_147; \
-int32x4_t __reint1_147 = splatq_lane_s32(*(int32x2_t *) &__reint_147, __p3_147); \
- __ret_147 = vdotq_s32(__s0_147, __s1_147, *(int8x16_t *) &__reint1_147); \
- __ret_147; \
+#define vqrdmlahq_lane_s16(__p0_136, __p1_136, __p2_136, __p3_136) __extension__ ({ \
+ int16x8_t __ret_136; \
+ int16x8_t __s0_136 = __p0_136; \
+ int16x8_t __s1_136 = __p1_136; \
+ int16x4_t __s2_136 = __p2_136; \
+ __ret_136 = vqrdmlahq_s16(__s0_136, __s1_136, splatq_lane_s16(__s2_136, __p3_136)); \
+ __ret_136; \
})
#else
-#define vdotq_lane_s32(__p0_148, __p1_148, __p2_148, __p3_148) __extension__ ({ \
- int32x4_t __ret_148; \
- int32x4_t __s0_148 = __p0_148; \
- int8x16_t __s1_148 = __p1_148; \
- int8x8_t __s2_148 = __p2_148; \
- int32x4_t __rev0_148; __rev0_148 = __builtin_shufflevector(__s0_148, __s0_148, 3, 2, 1, 0); \
- int8x16_t __rev1_148; __rev1_148 = __builtin_shufflevector(__s1_148, __s1_148, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- int8x8_t __rev2_148; __rev2_148 = __builtin_shufflevector(__s2_148, __s2_148, 7, 6, 5, 4, 3, 2, 1, 0); \
-int8x8_t __reint_148 = __rev2_148; \
-int32x4_t __reint1_148 = __noswap_splatq_lane_s32(*(int32x2_t *) &__reint_148, __p3_148); \
- __ret_148 = __noswap_vdotq_s32(__rev0_148, __rev1_148, *(int8x16_t *) &__reint1_148); \
- __ret_148 = __builtin_shufflevector(__ret_148, __ret_148, 3, 2, 1, 0); \
- __ret_148; \
+#define vqrdmlahq_lane_s16(__p0_137, __p1_137, __p2_137, __p3_137) __extension__ ({ \
+ int16x8_t __ret_137; \
+ int16x8_t __s0_137 = __p0_137; \
+ int16x8_t __s1_137 = __p1_137; \
+ int16x4_t __s2_137 = __p2_137; \
+ int16x8_t __rev0_137; __rev0_137 = __builtin_shufflevector(__s0_137, __s0_137, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1_137; __rev1_137 = __builtin_shufflevector(__s1_137, __s1_137, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x4_t __rev2_137; __rev2_137 = __builtin_shufflevector(__s2_137, __s2_137, 3, 2, 1, 0); \
+ __ret_137 = __noswap_vqrdmlahq_s16(__rev0_137, __rev1_137, __noswap_splatq_lane_s16(__rev2_137, __p3_137)); \
+ __ret_137 = __builtin_shufflevector(__ret_137, __ret_137, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_137; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdot_lane_u32(__p0_149, __p1_149, __p2_149, __p3_149) __extension__ ({ \
- uint32x2_t __ret_149; \
- uint32x2_t __s0_149 = __p0_149; \
- uint8x8_t __s1_149 = __p1_149; \
- uint8x8_t __s2_149 = __p2_149; \
-uint8x8_t __reint_149 = __s2_149; \
-uint32x2_t __reint1_149 = splat_lane_u32(*(uint32x2_t *) &__reint_149, __p3_149); \
- __ret_149 = vdot_u32(__s0_149, __s1_149, *(uint8x8_t *) &__reint1_149); \
- __ret_149; \
+#define vqrdmlah_lane_s32(__p0_138, __p1_138, __p2_138, __p3_138) __extension__ ({ \
+ int32x2_t __ret_138; \
+ int32x2_t __s0_138 = __p0_138; \
+ int32x2_t __s1_138 = __p1_138; \
+ int32x2_t __s2_138 = __p2_138; \
+ __ret_138 = vqrdmlah_s32(__s0_138, __s1_138, splat_lane_s32(__s2_138, __p3_138)); \
+ __ret_138; \
})
#else
-#define vdot_lane_u32(__p0_150, __p1_150, __p2_150, __p3_150) __extension__ ({ \
- uint32x2_t __ret_150; \
- uint32x2_t __s0_150 = __p0_150; \
- uint8x8_t __s1_150 = __p1_150; \
- uint8x8_t __s2_150 = __p2_150; \
- uint32x2_t __rev0_150; __rev0_150 = __builtin_shufflevector(__s0_150, __s0_150, 1, 0); \
- uint8x8_t __rev1_150; __rev1_150 = __builtin_shufflevector(__s1_150, __s1_150, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint8x8_t __rev2_150; __rev2_150 = __builtin_shufflevector(__s2_150, __s2_150, 7, 6, 5, 4, 3, 2, 1, 0); \
-uint8x8_t __reint_150 = __rev2_150; \
-uint32x2_t __reint1_150 = __noswap_splat_lane_u32(*(uint32x2_t *) &__reint_150, __p3_150); \
- __ret_150 = __noswap_vdot_u32(__rev0_150, __rev1_150, *(uint8x8_t *) &__reint1_150); \
- __ret_150 = __builtin_shufflevector(__ret_150, __ret_150, 1, 0); \
- __ret_150; \
+#define vqrdmlah_lane_s32(__p0_139, __p1_139, __p2_139, __p3_139) __extension__ ({ \
+ int32x2_t __ret_139; \
+ int32x2_t __s0_139 = __p0_139; \
+ int32x2_t __s1_139 = __p1_139; \
+ int32x2_t __s2_139 = __p2_139; \
+ int32x2_t __rev0_139; __rev0_139 = __builtin_shufflevector(__s0_139, __s0_139, 1, 0); \
+ int32x2_t __rev1_139; __rev1_139 = __builtin_shufflevector(__s1_139, __s1_139, 1, 0); \
+ int32x2_t __rev2_139; __rev2_139 = __builtin_shufflevector(__s2_139, __s2_139, 1, 0); \
+ __ret_139 = __noswap_vqrdmlah_s32(__rev0_139, __rev1_139, __noswap_splat_lane_s32(__rev2_139, __p3_139)); \
+ __ret_139 = __builtin_shufflevector(__ret_139, __ret_139, 1, 0); \
+ __ret_139; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdot_lane_s32(__p0_151, __p1_151, __p2_151, __p3_151) __extension__ ({ \
- int32x2_t __ret_151; \
- int32x2_t __s0_151 = __p0_151; \
- int8x8_t __s1_151 = __p1_151; \
- int8x8_t __s2_151 = __p2_151; \
-int8x8_t __reint_151 = __s2_151; \
-int32x2_t __reint1_151 = splat_lane_s32(*(int32x2_t *) &__reint_151, __p3_151); \
- __ret_151 = vdot_s32(__s0_151, __s1_151, *(int8x8_t *) &__reint1_151); \
- __ret_151; \
+#define vqrdmlah_lane_s16(__p0_140, __p1_140, __p2_140, __p3_140) __extension__ ({ \
+ int16x4_t __ret_140; \
+ int16x4_t __s0_140 = __p0_140; \
+ int16x4_t __s1_140 = __p1_140; \
+ int16x4_t __s2_140 = __p2_140; \
+ __ret_140 = vqrdmlah_s16(__s0_140, __s1_140, splat_lane_s16(__s2_140, __p3_140)); \
+ __ret_140; \
})
#else
-#define vdot_lane_s32(__p0_152, __p1_152, __p2_152, __p3_152) __extension__ ({ \
- int32x2_t __ret_152; \
- int32x2_t __s0_152 = __p0_152; \
- int8x8_t __s1_152 = __p1_152; \
- int8x8_t __s2_152 = __p2_152; \
- int32x2_t __rev0_152; __rev0_152 = __builtin_shufflevector(__s0_152, __s0_152, 1, 0); \
- int8x8_t __rev1_152; __rev1_152 = __builtin_shufflevector(__s1_152, __s1_152, 7, 6, 5, 4, 3, 2, 1, 0); \
- int8x8_t __rev2_152; __rev2_152 = __builtin_shufflevector(__s2_152, __s2_152, 7, 6, 5, 4, 3, 2, 1, 0); \
-int8x8_t __reint_152 = __rev2_152; \
-int32x2_t __reint1_152 = __noswap_splat_lane_s32(*(int32x2_t *) &__reint_152, __p3_152); \
- __ret_152 = __noswap_vdot_s32(__rev0_152, __rev1_152, *(int8x8_t *) &__reint1_152); \
- __ret_152 = __builtin_shufflevector(__ret_152, __ret_152, 1, 0); \
- __ret_152; \
+#define vqrdmlah_lane_s16(__p0_141, __p1_141, __p2_141, __p3_141) __extension__ ({ \
+ int16x4_t __ret_141; \
+ int16x4_t __s0_141 = __p0_141; \
+ int16x4_t __s1_141 = __p1_141; \
+ int16x4_t __s2_141 = __p2_141; \
+ int16x4_t __rev0_141; __rev0_141 = __builtin_shufflevector(__s0_141, __s0_141, 3, 2, 1, 0); \
+ int16x4_t __rev1_141; __rev1_141 = __builtin_shufflevector(__s1_141, __s1_141, 3, 2, 1, 0); \
+ int16x4_t __rev2_141; __rev2_141 = __builtin_shufflevector(__s2_141, __s2_141, 3, 2, 1, 0); \
+ __ret_141 = __noswap_vqrdmlah_s16(__rev0_141, __rev1_141, __noswap_splat_lane_s16(__rev2_141, __p3_141)); \
+ __ret_141 = __builtin_shufflevector(__ret_141, __ret_141, 3, 2, 1, 0); \
+ __ret_141; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vabdq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vabdq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+__ai __attribute__((target("v8.1a,neon"))) int32x4_t vqrdmlshq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vqrdmlshq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vabdq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vabdq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("v8.1a,neon"))) int32x4_t vqrdmlshq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vqrdmlshq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("v8.1a,neon"))) int32x4_t __noswap_vqrdmlshq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vqrdmlshq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vabd_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vabd_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+__ai __attribute__((target("v8.1a,neon"))) int16x8_t vqrdmlshq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vqrdmlshq_s16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vabd_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vabd_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("v8.1a,neon"))) int16x8_t vqrdmlshq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vqrdmlshq_s16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("v8.1a,neon"))) int16x8_t __noswap_vqrdmlshq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vqrdmlshq_s16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vabsq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vabsq_f16((int8x16_t)__p0, 40);
+__ai __attribute__((target("v8.1a,neon"))) int32x2_t vqrdmlsh_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vqrdmlsh_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vabsq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vabsq_f16((int8x16_t)__rev0, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("v8.1a,neon"))) int32x2_t vqrdmlsh_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ int32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vqrdmlsh_s32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("v8.1a,neon"))) int32x2_t __noswap_vqrdmlsh_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vqrdmlsh_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vabs_f16(float16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vabs_f16((int8x8_t)__p0, 8);
+__ai __attribute__((target("v8.1a,neon"))) int16x4_t vqrdmlsh_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vqrdmlsh_s16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 1);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vabs_f16(float16x4_t __p0) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vabs_f16((int8x8_t)__rev0, 8);
+__ai __attribute__((target("v8.1a,neon"))) int16x4_t vqrdmlsh_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ int16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vqrdmlsh_s16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("v8.1a,neon"))) int16x4_t __noswap_vqrdmlsh_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vqrdmlsh_s16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 1);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vaddq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = __p0 + __p1;
+#define vqrdmlshq_lane_s32(__p0_142, __p1_142, __p2_142, __p3_142) __extension__ ({ \
+ int32x4_t __ret_142; \
+ int32x4_t __s0_142 = __p0_142; \
+ int32x4_t __s1_142 = __p1_142; \
+ int32x2_t __s2_142 = __p2_142; \
+ __ret_142 = vqrdmlshq_s32(__s0_142, __s1_142, splatq_lane_s32(__s2_142, __p3_142)); \
+ __ret_142; \
+})
+#else
+#define vqrdmlshq_lane_s32(__p0_143, __p1_143, __p2_143, __p3_143) __extension__ ({ \
+ int32x4_t __ret_143; \
+ int32x4_t __s0_143 = __p0_143; \
+ int32x4_t __s1_143 = __p1_143; \
+ int32x2_t __s2_143 = __p2_143; \
+ int32x4_t __rev0_143; __rev0_143 = __builtin_shufflevector(__s0_143, __s0_143, 3, 2, 1, 0); \
+ int32x4_t __rev1_143; __rev1_143 = __builtin_shufflevector(__s1_143, __s1_143, 3, 2, 1, 0); \
+ int32x2_t __rev2_143; __rev2_143 = __builtin_shufflevector(__s2_143, __s2_143, 1, 0); \
+ __ret_143 = __noswap_vqrdmlshq_s32(__rev0_143, __rev1_143, __noswap_splatq_lane_s32(__rev2_143, __p3_143)); \
+ __ret_143 = __builtin_shufflevector(__ret_143, __ret_143, 3, 2, 1, 0); \
+ __ret_143; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlshq_lane_s16(__p0_144, __p1_144, __p2_144, __p3_144) __extension__ ({ \
+ int16x8_t __ret_144; \
+ int16x8_t __s0_144 = __p0_144; \
+ int16x8_t __s1_144 = __p1_144; \
+ int16x4_t __s2_144 = __p2_144; \
+ __ret_144 = vqrdmlshq_s16(__s0_144, __s1_144, splatq_lane_s16(__s2_144, __p3_144)); \
+ __ret_144; \
+})
+#else
+#define vqrdmlshq_lane_s16(__p0_145, __p1_145, __p2_145, __p3_145) __extension__ ({ \
+ int16x8_t __ret_145; \
+ int16x8_t __s0_145 = __p0_145; \
+ int16x8_t __s1_145 = __p1_145; \
+ int16x4_t __s2_145 = __p2_145; \
+ int16x8_t __rev0_145; __rev0_145 = __builtin_shufflevector(__s0_145, __s0_145, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1_145; __rev1_145 = __builtin_shufflevector(__s1_145, __s1_145, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x4_t __rev2_145; __rev2_145 = __builtin_shufflevector(__s2_145, __s2_145, 3, 2, 1, 0); \
+ __ret_145 = __noswap_vqrdmlshq_s16(__rev0_145, __rev1_145, __noswap_splatq_lane_s16(__rev2_145, __p3_145)); \
+ __ret_145 = __builtin_shufflevector(__ret_145, __ret_145, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_145; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlsh_lane_s32(__p0_146, __p1_146, __p2_146, __p3_146) __extension__ ({ \
+ int32x2_t __ret_146; \
+ int32x2_t __s0_146 = __p0_146; \
+ int32x2_t __s1_146 = __p1_146; \
+ int32x2_t __s2_146 = __p2_146; \
+ __ret_146 = vqrdmlsh_s32(__s0_146, __s1_146, splat_lane_s32(__s2_146, __p3_146)); \
+ __ret_146; \
+})
+#else
+#define vqrdmlsh_lane_s32(__p0_147, __p1_147, __p2_147, __p3_147) __extension__ ({ \
+ int32x2_t __ret_147; \
+ int32x2_t __s0_147 = __p0_147; \
+ int32x2_t __s1_147 = __p1_147; \
+ int32x2_t __s2_147 = __p2_147; \
+ int32x2_t __rev0_147; __rev0_147 = __builtin_shufflevector(__s0_147, __s0_147, 1, 0); \
+ int32x2_t __rev1_147; __rev1_147 = __builtin_shufflevector(__s1_147, __s1_147, 1, 0); \
+ int32x2_t __rev2_147; __rev2_147 = __builtin_shufflevector(__s2_147, __s2_147, 1, 0); \
+ __ret_147 = __noswap_vqrdmlsh_s32(__rev0_147, __rev1_147, __noswap_splat_lane_s32(__rev2_147, __p3_147)); \
+ __ret_147 = __builtin_shufflevector(__ret_147, __ret_147, 1, 0); \
+ __ret_147; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlsh_lane_s16(__p0_148, __p1_148, __p2_148, __p3_148) __extension__ ({ \
+ int16x4_t __ret_148; \
+ int16x4_t __s0_148 = __p0_148; \
+ int16x4_t __s1_148 = __p1_148; \
+ int16x4_t __s2_148 = __p2_148; \
+ __ret_148 = vqrdmlsh_s16(__s0_148, __s1_148, splat_lane_s16(__s2_148, __p3_148)); \
+ __ret_148; \
+})
+#else
+#define vqrdmlsh_lane_s16(__p0_149, __p1_149, __p2_149, __p3_149) __extension__ ({ \
+ int16x4_t __ret_149; \
+ int16x4_t __s0_149 = __p0_149; \
+ int16x4_t __s1_149 = __p1_149; \
+ int16x4_t __s2_149 = __p2_149; \
+ int16x4_t __rev0_149; __rev0_149 = __builtin_shufflevector(__s0_149, __s0_149, 3, 2, 1, 0); \
+ int16x4_t __rev1_149; __rev1_149 = __builtin_shufflevector(__s1_149, __s1_149, 3, 2, 1, 0); \
+ int16x4_t __rev2_149; __rev2_149 = __builtin_shufflevector(__s2_149, __s2_149, 3, 2, 1, 0); \
+ __ret_149 = __noswap_vqrdmlsh_s16(__rev0_149, __rev1_149, __noswap_splat_lane_s16(__rev2_149, __p3_149)); \
+ __ret_149 = __builtin_shufflevector(__ret_149, __ret_149, 3, 2, 1, 0); \
+ __ret_149; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcadd_rot270_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vcadd_rot270_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vaddq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 + __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcadd_rot270_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vcadd_rot270_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vadd_f16(float16x4_t __p0, float16x4_t __p1) {
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcadd_rot90_f16(float16x4_t __p0, float16x4_t __p1) {
float16x4_t __ret;
- __ret = __p0 + __p1;
+ __ret = (float16x4_t) __builtin_neon_vcadd_rot90_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vadd_f16(float16x4_t __p0, float16x4_t __p1) {
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcadd_rot90_f16(float16x4_t __p0, float16x4_t __p1) {
float16x4_t __ret;
float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 + __rev1;
+ __ret = (float16x4_t) __builtin_neon_vcadd_rot90_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vbslq_f16(uint16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcaddq_rot270_f16(float16x8_t __p0, float16x8_t __p1) {
float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vbslq_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+ __ret = (float16x8_t) __builtin_neon_vcaddq_rot270_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vbslq_f16(uint16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcaddq_rot270_f16(float16x8_t __p0, float16x8_t __p1) {
float16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vbslq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 40);
+ __ret = (float16x8_t) __builtin_neon_vcaddq_rot270_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vbsl_f16(uint16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vbsl_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcaddq_rot90_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vcaddq_rot90_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vbsl_f16(uint16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vbsl_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcaddq_rot90_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vcaddq_rot90_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcageq_f16(float16x8_t __p0, float16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vcageq_f16((int8x16_t)__p0, (int8x16_t)__p1, 49);
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcmlaq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vcmlaq_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcageq_f16(float16x8_t __p0, float16x8_t __p1) {
- uint16x8_t __ret;
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcmlaq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vcageq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vcmlaq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 40);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t __noswap_vcmlaq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vcmlaq_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcage_f16(float16x4_t __p0, float16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vcage_f16((int8x8_t)__p0, (int8x8_t)__p1, 17);
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcmla_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vcmla_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcage_f16(float16x4_t __p0, float16x4_t __p1) {
- uint16x4_t __ret;
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcmla_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vcage_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vcmla_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 8);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t __noswap_vcmla_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vcmla_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcagtq_f16(float16x8_t __p0, float16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vcagtq_f16((int8x16_t)__p0, (int8x16_t)__p1, 49);
- return __ret;
-}
+#define vcmla_lane_f16(__p0_150, __p1_150, __p2_150, __p3_150) __extension__ ({ \
+ float16x4_t __ret_150; \
+ float16x4_t __s0_150 = __p0_150; \
+ float16x4_t __s1_150 = __p1_150; \
+ float16x4_t __s2_150 = __p2_150; \
+float16x4_t __reint_150 = __s2_150; \
+uint32x2_t __reint1_150 = (uint32x2_t) {vget_lane_u32(*(uint32x2_t *) &__reint_150, __p3_150), vget_lane_u32(*(uint32x2_t *) &__reint_150, __p3_150)}; \
+ __ret_150 = vcmla_f16(__s0_150, __s1_150, *(float16x4_t *) &__reint1_150); \
+ __ret_150; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcagtq_f16(float16x8_t __p0, float16x8_t __p1) {
- uint16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vcagtq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmla_lane_f16(__p0_151, __p1_151, __p2_151, __p3_151) __extension__ ({ \
+ float16x4_t __ret_151; \
+ float16x4_t __s0_151 = __p0_151; \
+ float16x4_t __s1_151 = __p1_151; \
+ float16x4_t __s2_151 = __p2_151; \
+ float16x4_t __rev0_151; __rev0_151 = __builtin_shufflevector(__s0_151, __s0_151, 3, 2, 1, 0); \
+ float16x4_t __rev1_151; __rev1_151 = __builtin_shufflevector(__s1_151, __s1_151, 3, 2, 1, 0); \
+ float16x4_t __rev2_151; __rev2_151 = __builtin_shufflevector(__s2_151, __s2_151, 3, 2, 1, 0); \
+float16x4_t __reint_151 = __rev2_151; \
+uint32x2_t __reint1_151 = (uint32x2_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_151, __p3_151), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_151, __p3_151)}; \
+ __ret_151 = __noswap_vcmla_f16(__rev0_151, __rev1_151, *(float16x4_t *) &__reint1_151); \
+ __ret_151 = __builtin_shufflevector(__ret_151, __ret_151, 3, 2, 1, 0); \
+ __ret_151; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcagt_f16(float16x4_t __p0, float16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vcagt_f16((int8x8_t)__p0, (int8x8_t)__p1, 17);
- return __ret;
-}
+#define vcmlaq_lane_f16(__p0_152, __p1_152, __p2_152, __p3_152) __extension__ ({ \
+ float16x8_t __ret_152; \
+ float16x8_t __s0_152 = __p0_152; \
+ float16x8_t __s1_152 = __p1_152; \
+ float16x4_t __s2_152 = __p2_152; \
+float16x4_t __reint_152 = __s2_152; \
+uint32x4_t __reint1_152 = (uint32x4_t) {vget_lane_u32(*(uint32x2_t *) &__reint_152, __p3_152), vget_lane_u32(*(uint32x2_t *) &__reint_152, __p3_152), vget_lane_u32(*(uint32x2_t *) &__reint_152, __p3_152), vget_lane_u32(*(uint32x2_t *) &__reint_152, __p3_152)}; \
+ __ret_152 = vcmlaq_f16(__s0_152, __s1_152, *(float16x8_t *) &__reint1_152); \
+ __ret_152; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcagt_f16(float16x4_t __p0, float16x4_t __p1) {
- uint16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vcagt_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmlaq_lane_f16(__p0_153, __p1_153, __p2_153, __p3_153) __extension__ ({ \
+ float16x8_t __ret_153; \
+ float16x8_t __s0_153 = __p0_153; \
+ float16x8_t __s1_153 = __p1_153; \
+ float16x4_t __s2_153 = __p2_153; \
+ float16x8_t __rev0_153; __rev0_153 = __builtin_shufflevector(__s0_153, __s0_153, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev1_153; __rev1_153 = __builtin_shufflevector(__s1_153, __s1_153, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x4_t __rev2_153; __rev2_153 = __builtin_shufflevector(__s2_153, __s2_153, 3, 2, 1, 0); \
+float16x4_t __reint_153 = __rev2_153; \
+uint32x4_t __reint1_153 = (uint32x4_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_153, __p3_153), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_153, __p3_153), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_153, __p3_153), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_153, __p3_153)}; \
+ __ret_153 = __noswap_vcmlaq_f16(__rev0_153, __rev1_153, *(float16x8_t *) &__reint1_153); \
+ __ret_153 = __builtin_shufflevector(__ret_153, __ret_153, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_153; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcaleq_f16(float16x8_t __p0, float16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vcaleq_f16((int8x16_t)__p0, (int8x16_t)__p1, 49);
- return __ret;
-}
+#define vcmla_laneq_f16(__p0_154, __p1_154, __p2_154, __p3_154) __extension__ ({ \
+ float16x4_t __ret_154; \
+ float16x4_t __s0_154 = __p0_154; \
+ float16x4_t __s1_154 = __p1_154; \
+ float16x8_t __s2_154 = __p2_154; \
+float16x8_t __reint_154 = __s2_154; \
+uint32x2_t __reint1_154 = (uint32x2_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_154, __p3_154), vgetq_lane_u32(*(uint32x4_t *) &__reint_154, __p3_154)}; \
+ __ret_154 = vcmla_f16(__s0_154, __s1_154, *(float16x4_t *) &__reint1_154); \
+ __ret_154; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcaleq_f16(float16x8_t __p0, float16x8_t __p1) {
- uint16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vcaleq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmla_laneq_f16(__p0_155, __p1_155, __p2_155, __p3_155) __extension__ ({ \
+ float16x4_t __ret_155; \
+ float16x4_t __s0_155 = __p0_155; \
+ float16x4_t __s1_155 = __p1_155; \
+ float16x8_t __s2_155 = __p2_155; \
+ float16x4_t __rev0_155; __rev0_155 = __builtin_shufflevector(__s0_155, __s0_155, 3, 2, 1, 0); \
+ float16x4_t __rev1_155; __rev1_155 = __builtin_shufflevector(__s1_155, __s1_155, 3, 2, 1, 0); \
+ float16x8_t __rev2_155; __rev2_155 = __builtin_shufflevector(__s2_155, __s2_155, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16x8_t __reint_155 = __rev2_155; \
+uint32x2_t __reint1_155 = (uint32x2_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_155, __p3_155), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_155, __p3_155)}; \
+ __ret_155 = __noswap_vcmla_f16(__rev0_155, __rev1_155, *(float16x4_t *) &__reint1_155); \
+ __ret_155 = __builtin_shufflevector(__ret_155, __ret_155, 3, 2, 1, 0); \
+ __ret_155; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcale_f16(float16x4_t __p0, float16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vcale_f16((int8x8_t)__p0, (int8x8_t)__p1, 17);
- return __ret;
-}
+#define vcmlaq_laneq_f16(__p0_156, __p1_156, __p2_156, __p3_156) __extension__ ({ \
+ float16x8_t __ret_156; \
+ float16x8_t __s0_156 = __p0_156; \
+ float16x8_t __s1_156 = __p1_156; \
+ float16x8_t __s2_156 = __p2_156; \
+float16x8_t __reint_156 = __s2_156; \
+uint32x4_t __reint1_156 = (uint32x4_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_156, __p3_156), vgetq_lane_u32(*(uint32x4_t *) &__reint_156, __p3_156), vgetq_lane_u32(*(uint32x4_t *) &__reint_156, __p3_156), vgetq_lane_u32(*(uint32x4_t *) &__reint_156, __p3_156)}; \
+ __ret_156 = vcmlaq_f16(__s0_156, __s1_156, *(float16x8_t *) &__reint1_156); \
+ __ret_156; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcale_f16(float16x4_t __p0, float16x4_t __p1) {
- uint16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vcale_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmlaq_laneq_f16(__p0_157, __p1_157, __p2_157, __p3_157) __extension__ ({ \
+ float16x8_t __ret_157; \
+ float16x8_t __s0_157 = __p0_157; \
+ float16x8_t __s1_157 = __p1_157; \
+ float16x8_t __s2_157 = __p2_157; \
+ float16x8_t __rev0_157; __rev0_157 = __builtin_shufflevector(__s0_157, __s0_157, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev1_157; __rev1_157 = __builtin_shufflevector(__s1_157, __s1_157, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev2_157; __rev2_157 = __builtin_shufflevector(__s2_157, __s2_157, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16x8_t __reint_157 = __rev2_157; \
+uint32x4_t __reint1_157 = (uint32x4_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_157, __p3_157), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_157, __p3_157), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_157, __p3_157), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_157, __p3_157)}; \
+ __ret_157 = __noswap_vcmlaq_f16(__rev0_157, __rev1_157, *(float16x8_t *) &__reint1_157); \
+ __ret_157 = __builtin_shufflevector(__ret_157, __ret_157, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_157; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcaltq_f16(float16x8_t __p0, float16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vcaltq_f16((int8x16_t)__p0, (int8x16_t)__p1, 49);
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcmlaq_rot180_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vcmlaq_rot180_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcaltq_f16(float16x8_t __p0, float16x8_t __p1) {
- uint16x8_t __ret;
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcmlaq_rot180_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vcaltq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vcmlaq_rot180_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 40);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t __noswap_vcmlaq_rot180_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vcmlaq_rot180_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcalt_f16(float16x4_t __p0, float16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vcalt_f16((int8x8_t)__p0, (int8x8_t)__p1, 17);
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcmla_rot180_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vcmla_rot180_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcalt_f16(float16x4_t __p0, float16x4_t __p1) {
- uint16x4_t __ret;
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcmla_rot180_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vcalt_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+ float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vcmla_rot180_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 8);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t __noswap_vcmla_rot180_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vcmla_rot180_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vceqq_f16(float16x8_t __p0, float16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0 == __p1);
- return __ret;
-}
+#define vcmla_rot180_lane_f16(__p0_158, __p1_158, __p2_158, __p3_158) __extension__ ({ \
+ float16x4_t __ret_158; \
+ float16x4_t __s0_158 = __p0_158; \
+ float16x4_t __s1_158 = __p1_158; \
+ float16x4_t __s2_158 = __p2_158; \
+float16x4_t __reint_158 = __s2_158; \
+uint32x2_t __reint1_158 = (uint32x2_t) {vget_lane_u32(*(uint32x2_t *) &__reint_158, __p3_158), vget_lane_u32(*(uint32x2_t *) &__reint_158, __p3_158)}; \
+ __ret_158 = vcmla_rot180_f16(__s0_158, __s1_158, *(float16x4_t *) &__reint1_158); \
+ __ret_158; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vceqq_f16(float16x8_t __p0, float16x8_t __p1) {
- uint16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t)(__rev0 == __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmla_rot180_lane_f16(__p0_159, __p1_159, __p2_159, __p3_159) __extension__ ({ \
+ float16x4_t __ret_159; \
+ float16x4_t __s0_159 = __p0_159; \
+ float16x4_t __s1_159 = __p1_159; \
+ float16x4_t __s2_159 = __p2_159; \
+ float16x4_t __rev0_159; __rev0_159 = __builtin_shufflevector(__s0_159, __s0_159, 3, 2, 1, 0); \
+ float16x4_t __rev1_159; __rev1_159 = __builtin_shufflevector(__s1_159, __s1_159, 3, 2, 1, 0); \
+ float16x4_t __rev2_159; __rev2_159 = __builtin_shufflevector(__s2_159, __s2_159, 3, 2, 1, 0); \
+float16x4_t __reint_159 = __rev2_159; \
+uint32x2_t __reint1_159 = (uint32x2_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_159, __p3_159), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_159, __p3_159)}; \
+ __ret_159 = __noswap_vcmla_rot180_f16(__rev0_159, __rev1_159, *(float16x4_t *) &__reint1_159); \
+ __ret_159 = __builtin_shufflevector(__ret_159, __ret_159, 3, 2, 1, 0); \
+ __ret_159; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vceq_f16(float16x4_t __p0, float16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0 == __p1);
- return __ret;
-}
+#define vcmlaq_rot180_lane_f16(__p0_160, __p1_160, __p2_160, __p3_160) __extension__ ({ \
+ float16x8_t __ret_160; \
+ float16x8_t __s0_160 = __p0_160; \
+ float16x8_t __s1_160 = __p1_160; \
+ float16x4_t __s2_160 = __p2_160; \
+float16x4_t __reint_160 = __s2_160; \
+uint32x4_t __reint1_160 = (uint32x4_t) {vget_lane_u32(*(uint32x2_t *) &__reint_160, __p3_160), vget_lane_u32(*(uint32x2_t *) &__reint_160, __p3_160), vget_lane_u32(*(uint32x2_t *) &__reint_160, __p3_160), vget_lane_u32(*(uint32x2_t *) &__reint_160, __p3_160)}; \
+ __ret_160 = vcmlaq_rot180_f16(__s0_160, __s1_160, *(float16x8_t *) &__reint1_160); \
+ __ret_160; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vceq_f16(float16x4_t __p0, float16x4_t __p1) {
- uint16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t)(__rev0 == __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmlaq_rot180_lane_f16(__p0_161, __p1_161, __p2_161, __p3_161) __extension__ ({ \
+ float16x8_t __ret_161; \
+ float16x8_t __s0_161 = __p0_161; \
+ float16x8_t __s1_161 = __p1_161; \
+ float16x4_t __s2_161 = __p2_161; \
+ float16x8_t __rev0_161; __rev0_161 = __builtin_shufflevector(__s0_161, __s0_161, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev1_161; __rev1_161 = __builtin_shufflevector(__s1_161, __s1_161, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x4_t __rev2_161; __rev2_161 = __builtin_shufflevector(__s2_161, __s2_161, 3, 2, 1, 0); \
+float16x4_t __reint_161 = __rev2_161; \
+uint32x4_t __reint1_161 = (uint32x4_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_161, __p3_161), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_161, __p3_161), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_161, __p3_161), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_161, __p3_161)}; \
+ __ret_161 = __noswap_vcmlaq_rot180_f16(__rev0_161, __rev1_161, *(float16x8_t *) &__reint1_161); \
+ __ret_161 = __builtin_shufflevector(__ret_161, __ret_161, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_161; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vceqzq_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vceqzq_f16((int8x16_t)__p0, 49);
- return __ret;
-}
+#define vcmla_rot180_laneq_f16(__p0_162, __p1_162, __p2_162, __p3_162) __extension__ ({ \
+ float16x4_t __ret_162; \
+ float16x4_t __s0_162 = __p0_162; \
+ float16x4_t __s1_162 = __p1_162; \
+ float16x8_t __s2_162 = __p2_162; \
+float16x8_t __reint_162 = __s2_162; \
+uint32x2_t __reint1_162 = (uint32x2_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_162, __p3_162), vgetq_lane_u32(*(uint32x4_t *) &__reint_162, __p3_162)}; \
+ __ret_162 = vcmla_rot180_f16(__s0_162, __s1_162, *(float16x4_t *) &__reint1_162); \
+ __ret_162; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vceqzq_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vceqzq_f16((int8x16_t)__rev0, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmla_rot180_laneq_f16(__p0_163, __p1_163, __p2_163, __p3_163) __extension__ ({ \
+ float16x4_t __ret_163; \
+ float16x4_t __s0_163 = __p0_163; \
+ float16x4_t __s1_163 = __p1_163; \
+ float16x8_t __s2_163 = __p2_163; \
+ float16x4_t __rev0_163; __rev0_163 = __builtin_shufflevector(__s0_163, __s0_163, 3, 2, 1, 0); \
+ float16x4_t __rev1_163; __rev1_163 = __builtin_shufflevector(__s1_163, __s1_163, 3, 2, 1, 0); \
+ float16x8_t __rev2_163; __rev2_163 = __builtin_shufflevector(__s2_163, __s2_163, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16x8_t __reint_163 = __rev2_163; \
+uint32x2_t __reint1_163 = (uint32x2_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_163, __p3_163), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_163, __p3_163)}; \
+ __ret_163 = __noswap_vcmla_rot180_f16(__rev0_163, __rev1_163, *(float16x4_t *) &__reint1_163); \
+ __ret_163 = __builtin_shufflevector(__ret_163, __ret_163, 3, 2, 1, 0); \
+ __ret_163; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vceqz_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vceqz_f16((int8x8_t)__p0, 17);
- return __ret;
-}
+#define vcmlaq_rot180_laneq_f16(__p0_164, __p1_164, __p2_164, __p3_164) __extension__ ({ \
+ float16x8_t __ret_164; \
+ float16x8_t __s0_164 = __p0_164; \
+ float16x8_t __s1_164 = __p1_164; \
+ float16x8_t __s2_164 = __p2_164; \
+float16x8_t __reint_164 = __s2_164; \
+uint32x4_t __reint1_164 = (uint32x4_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_164, __p3_164), vgetq_lane_u32(*(uint32x4_t *) &__reint_164, __p3_164), vgetq_lane_u32(*(uint32x4_t *) &__reint_164, __p3_164), vgetq_lane_u32(*(uint32x4_t *) &__reint_164, __p3_164)}; \
+ __ret_164 = vcmlaq_rot180_f16(__s0_164, __s1_164, *(float16x8_t *) &__reint1_164); \
+ __ret_164; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vceqz_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vceqz_f16((int8x8_t)__rev0, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmlaq_rot180_laneq_f16(__p0_165, __p1_165, __p2_165, __p3_165) __extension__ ({ \
+ float16x8_t __ret_165; \
+ float16x8_t __s0_165 = __p0_165; \
+ float16x8_t __s1_165 = __p1_165; \
+ float16x8_t __s2_165 = __p2_165; \
+ float16x8_t __rev0_165; __rev0_165 = __builtin_shufflevector(__s0_165, __s0_165, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev1_165; __rev1_165 = __builtin_shufflevector(__s1_165, __s1_165, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev2_165; __rev2_165 = __builtin_shufflevector(__s2_165, __s2_165, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16x8_t __reint_165 = __rev2_165; \
+uint32x4_t __reint1_165 = (uint32x4_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_165, __p3_165), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_165, __p3_165), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_165, __p3_165), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_165, __p3_165)}; \
+ __ret_165 = __noswap_vcmlaq_rot180_f16(__rev0_165, __rev1_165, *(float16x8_t *) &__reint1_165); \
+ __ret_165 = __builtin_shufflevector(__ret_165, __ret_165, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_165; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcgeq_f16(float16x8_t __p0, float16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0 >= __p1);
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcmlaq_rot270_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vcmlaq_rot270_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcgeq_f16(float16x8_t __p0, float16x8_t __p1) {
- uint16x8_t __ret;
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcmlaq_rot270_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t)(__rev0 >= __rev1);
+ float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vcmlaq_rot270_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 40);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t __noswap_vcmlaq_rot270_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vcmlaq_rot270_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcge_f16(float16x4_t __p0, float16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0 >= __p1);
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcmla_rot270_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vcmla_rot270_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcge_f16(float16x4_t __p0, float16x4_t __p1) {
- uint16x4_t __ret;
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcmla_rot270_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t)(__rev0 >= __rev1);
+ float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vcmla_rot270_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 8);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcgezq_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vcgezq_f16((int8x16_t)__p0, 49);
- return __ret;
-}
-#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcgezq_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vcgezq_f16((int8x16_t)__rev0, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcgez_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vcgez_f16((int8x8_t)__p0, 17);
- return __ret;
-}
-#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcgez_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vcgez_f16((int8x8_t)__rev0, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t __noswap_vcmla_rot270_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vcmla_rot270_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcgtq_f16(float16x8_t __p0, float16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0 > __p1);
- return __ret;
-}
+#define vcmla_rot270_lane_f16(__p0_166, __p1_166, __p2_166, __p3_166) __extension__ ({ \
+ float16x4_t __ret_166; \
+ float16x4_t __s0_166 = __p0_166; \
+ float16x4_t __s1_166 = __p1_166; \
+ float16x4_t __s2_166 = __p2_166; \
+float16x4_t __reint_166 = __s2_166; \
+uint32x2_t __reint1_166 = (uint32x2_t) {vget_lane_u32(*(uint32x2_t *) &__reint_166, __p3_166), vget_lane_u32(*(uint32x2_t *) &__reint_166, __p3_166)}; \
+ __ret_166 = vcmla_rot270_f16(__s0_166, __s1_166, *(float16x4_t *) &__reint1_166); \
+ __ret_166; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcgtq_f16(float16x8_t __p0, float16x8_t __p1) {
- uint16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmla_rot270_lane_f16(__p0_167, __p1_167, __p2_167, __p3_167) __extension__ ({ \
+ float16x4_t __ret_167; \
+ float16x4_t __s0_167 = __p0_167; \
+ float16x4_t __s1_167 = __p1_167; \
+ float16x4_t __s2_167 = __p2_167; \
+ float16x4_t __rev0_167; __rev0_167 = __builtin_shufflevector(__s0_167, __s0_167, 3, 2, 1, 0); \
+ float16x4_t __rev1_167; __rev1_167 = __builtin_shufflevector(__s1_167, __s1_167, 3, 2, 1, 0); \
+ float16x4_t __rev2_167; __rev2_167 = __builtin_shufflevector(__s2_167, __s2_167, 3, 2, 1, 0); \
+float16x4_t __reint_167 = __rev2_167; \
+uint32x2_t __reint1_167 = (uint32x2_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_167, __p3_167), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_167, __p3_167)}; \
+ __ret_167 = __noswap_vcmla_rot270_f16(__rev0_167, __rev1_167, *(float16x4_t *) &__reint1_167); \
+ __ret_167 = __builtin_shufflevector(__ret_167, __ret_167, 3, 2, 1, 0); \
+ __ret_167; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcgt_f16(float16x4_t __p0, float16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0 > __p1);
- return __ret;
-}
+#define vcmlaq_rot270_lane_f16(__p0_168, __p1_168, __p2_168, __p3_168) __extension__ ({ \
+ float16x8_t __ret_168; \
+ float16x8_t __s0_168 = __p0_168; \
+ float16x8_t __s1_168 = __p1_168; \
+ float16x4_t __s2_168 = __p2_168; \
+float16x4_t __reint_168 = __s2_168; \
+uint32x4_t __reint1_168 = (uint32x4_t) {vget_lane_u32(*(uint32x2_t *) &__reint_168, __p3_168), vget_lane_u32(*(uint32x2_t *) &__reint_168, __p3_168), vget_lane_u32(*(uint32x2_t *) &__reint_168, __p3_168), vget_lane_u32(*(uint32x2_t *) &__reint_168, __p3_168)}; \
+ __ret_168 = vcmlaq_rot270_f16(__s0_168, __s1_168, *(float16x8_t *) &__reint1_168); \
+ __ret_168; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcgt_f16(float16x4_t __p0, float16x4_t __p1) {
- uint16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmlaq_rot270_lane_f16(__p0_169, __p1_169, __p2_169, __p3_169) __extension__ ({ \
+ float16x8_t __ret_169; \
+ float16x8_t __s0_169 = __p0_169; \
+ float16x8_t __s1_169 = __p1_169; \
+ float16x4_t __s2_169 = __p2_169; \
+ float16x8_t __rev0_169; __rev0_169 = __builtin_shufflevector(__s0_169, __s0_169, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev1_169; __rev1_169 = __builtin_shufflevector(__s1_169, __s1_169, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x4_t __rev2_169; __rev2_169 = __builtin_shufflevector(__s2_169, __s2_169, 3, 2, 1, 0); \
+float16x4_t __reint_169 = __rev2_169; \
+uint32x4_t __reint1_169 = (uint32x4_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_169, __p3_169), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_169, __p3_169), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_169, __p3_169), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_169, __p3_169)}; \
+ __ret_169 = __noswap_vcmlaq_rot270_f16(__rev0_169, __rev1_169, *(float16x8_t *) &__reint1_169); \
+ __ret_169 = __builtin_shufflevector(__ret_169, __ret_169, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_169; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcgtzq_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vcgtzq_f16((int8x16_t)__p0, 49);
- return __ret;
-}
+#define vcmla_rot270_laneq_f16(__p0_170, __p1_170, __p2_170, __p3_170) __extension__ ({ \
+ float16x4_t __ret_170; \
+ float16x4_t __s0_170 = __p0_170; \
+ float16x4_t __s1_170 = __p1_170; \
+ float16x8_t __s2_170 = __p2_170; \
+float16x8_t __reint_170 = __s2_170; \
+uint32x2_t __reint1_170 = (uint32x2_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_170, __p3_170), vgetq_lane_u32(*(uint32x4_t *) &__reint_170, __p3_170)}; \
+ __ret_170 = vcmla_rot270_f16(__s0_170, __s1_170, *(float16x4_t *) &__reint1_170); \
+ __ret_170; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcgtzq_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vcgtzq_f16((int8x16_t)__rev0, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmla_rot270_laneq_f16(__p0_171, __p1_171, __p2_171, __p3_171) __extension__ ({ \
+ float16x4_t __ret_171; \
+ float16x4_t __s0_171 = __p0_171; \
+ float16x4_t __s1_171 = __p1_171; \
+ float16x8_t __s2_171 = __p2_171; \
+ float16x4_t __rev0_171; __rev0_171 = __builtin_shufflevector(__s0_171, __s0_171, 3, 2, 1, 0); \
+ float16x4_t __rev1_171; __rev1_171 = __builtin_shufflevector(__s1_171, __s1_171, 3, 2, 1, 0); \
+ float16x8_t __rev2_171; __rev2_171 = __builtin_shufflevector(__s2_171, __s2_171, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16x8_t __reint_171 = __rev2_171; \
+uint32x2_t __reint1_171 = (uint32x2_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_171, __p3_171), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_171, __p3_171)}; \
+ __ret_171 = __noswap_vcmla_rot270_f16(__rev0_171, __rev1_171, *(float16x4_t *) &__reint1_171); \
+ __ret_171 = __builtin_shufflevector(__ret_171, __ret_171, 3, 2, 1, 0); \
+ __ret_171; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcgtz_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vcgtz_f16((int8x8_t)__p0, 17);
- return __ret;
-}
+#define vcmlaq_rot270_laneq_f16(__p0_172, __p1_172, __p2_172, __p3_172) __extension__ ({ \
+ float16x8_t __ret_172; \
+ float16x8_t __s0_172 = __p0_172; \
+ float16x8_t __s1_172 = __p1_172; \
+ float16x8_t __s2_172 = __p2_172; \
+float16x8_t __reint_172 = __s2_172; \
+uint32x4_t __reint1_172 = (uint32x4_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_172, __p3_172), vgetq_lane_u32(*(uint32x4_t *) &__reint_172, __p3_172), vgetq_lane_u32(*(uint32x4_t *) &__reint_172, __p3_172), vgetq_lane_u32(*(uint32x4_t *) &__reint_172, __p3_172)}; \
+ __ret_172 = vcmlaq_rot270_f16(__s0_172, __s1_172, *(float16x8_t *) &__reint1_172); \
+ __ret_172; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcgtz_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vcgtz_f16((int8x8_t)__rev0, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmlaq_rot270_laneq_f16(__p0_173, __p1_173, __p2_173, __p3_173) __extension__ ({ \
+ float16x8_t __ret_173; \
+ float16x8_t __s0_173 = __p0_173; \
+ float16x8_t __s1_173 = __p1_173; \
+ float16x8_t __s2_173 = __p2_173; \
+ float16x8_t __rev0_173; __rev0_173 = __builtin_shufflevector(__s0_173, __s0_173, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev1_173; __rev1_173 = __builtin_shufflevector(__s1_173, __s1_173, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev2_173; __rev2_173 = __builtin_shufflevector(__s2_173, __s2_173, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16x8_t __reint_173 = __rev2_173; \
+uint32x4_t __reint1_173 = (uint32x4_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_173, __p3_173), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_173, __p3_173), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_173, __p3_173), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_173, __p3_173)}; \
+ __ret_173 = __noswap_vcmlaq_rot270_f16(__rev0_173, __rev1_173, *(float16x8_t *) &__reint1_173); \
+ __ret_173 = __builtin_shufflevector(__ret_173, __ret_173, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_173; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcleq_f16(float16x8_t __p0, float16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0 <= __p1);
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcmlaq_rot90_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vcmlaq_rot90_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcleq_f16(float16x8_t __p0, float16x8_t __p1) {
- uint16x8_t __ret;
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcmlaq_rot90_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t)(__rev0 <= __rev1);
+ float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vcmlaq_rot90_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 40);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t __noswap_vcmlaq_rot90_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vcmlaq_rot90_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcle_f16(float16x4_t __p0, float16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0 <= __p1);
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcmla_rot90_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vcmla_rot90_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcle_f16(float16x4_t __p0, float16x4_t __p1) {
- uint16x4_t __ret;
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcmla_rot90_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t)(__rev0 <= __rev1);
+ float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vcmla_rot90_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 8);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t __noswap_vcmla_rot90_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vcmla_rot90_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vclezq_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vclezq_f16((int8x16_t)__p0, 49);
- return __ret;
-}
+#define vcmla_rot90_lane_f16(__p0_174, __p1_174, __p2_174, __p3_174) __extension__ ({ \
+ float16x4_t __ret_174; \
+ float16x4_t __s0_174 = __p0_174; \
+ float16x4_t __s1_174 = __p1_174; \
+ float16x4_t __s2_174 = __p2_174; \
+float16x4_t __reint_174 = __s2_174; \
+uint32x2_t __reint1_174 = (uint32x2_t) {vget_lane_u32(*(uint32x2_t *) &__reint_174, __p3_174), vget_lane_u32(*(uint32x2_t *) &__reint_174, __p3_174)}; \
+ __ret_174 = vcmla_rot90_f16(__s0_174, __s1_174, *(float16x4_t *) &__reint1_174); \
+ __ret_174; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vclezq_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vclezq_f16((int8x16_t)__rev0, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmla_rot90_lane_f16(__p0_175, __p1_175, __p2_175, __p3_175) __extension__ ({ \
+ float16x4_t __ret_175; \
+ float16x4_t __s0_175 = __p0_175; \
+ float16x4_t __s1_175 = __p1_175; \
+ float16x4_t __s2_175 = __p2_175; \
+ float16x4_t __rev0_175; __rev0_175 = __builtin_shufflevector(__s0_175, __s0_175, 3, 2, 1, 0); \
+ float16x4_t __rev1_175; __rev1_175 = __builtin_shufflevector(__s1_175, __s1_175, 3, 2, 1, 0); \
+ float16x4_t __rev2_175; __rev2_175 = __builtin_shufflevector(__s2_175, __s2_175, 3, 2, 1, 0); \
+float16x4_t __reint_175 = __rev2_175; \
+uint32x2_t __reint1_175 = (uint32x2_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_175, __p3_175), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_175, __p3_175)}; \
+ __ret_175 = __noswap_vcmla_rot90_f16(__rev0_175, __rev1_175, *(float16x4_t *) &__reint1_175); \
+ __ret_175 = __builtin_shufflevector(__ret_175, __ret_175, 3, 2, 1, 0); \
+ __ret_175; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vclez_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vclez_f16((int8x8_t)__p0, 17);
- return __ret;
-}
+#define vcmlaq_rot90_lane_f16(__p0_176, __p1_176, __p2_176, __p3_176) __extension__ ({ \
+ float16x8_t __ret_176; \
+ float16x8_t __s0_176 = __p0_176; \
+ float16x8_t __s1_176 = __p1_176; \
+ float16x4_t __s2_176 = __p2_176; \
+float16x4_t __reint_176 = __s2_176; \
+uint32x4_t __reint1_176 = (uint32x4_t) {vget_lane_u32(*(uint32x2_t *) &__reint_176, __p3_176), vget_lane_u32(*(uint32x2_t *) &__reint_176, __p3_176), vget_lane_u32(*(uint32x2_t *) &__reint_176, __p3_176), vget_lane_u32(*(uint32x2_t *) &__reint_176, __p3_176)}; \
+ __ret_176 = vcmlaq_rot90_f16(__s0_176, __s1_176, *(float16x8_t *) &__reint1_176); \
+ __ret_176; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vclez_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vclez_f16((int8x8_t)__rev0, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmlaq_rot90_lane_f16(__p0_177, __p1_177, __p2_177, __p3_177) __extension__ ({ \
+ float16x8_t __ret_177; \
+ float16x8_t __s0_177 = __p0_177; \
+ float16x8_t __s1_177 = __p1_177; \
+ float16x4_t __s2_177 = __p2_177; \
+ float16x8_t __rev0_177; __rev0_177 = __builtin_shufflevector(__s0_177, __s0_177, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev1_177; __rev1_177 = __builtin_shufflevector(__s1_177, __s1_177, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x4_t __rev2_177; __rev2_177 = __builtin_shufflevector(__s2_177, __s2_177, 3, 2, 1, 0); \
+float16x4_t __reint_177 = __rev2_177; \
+uint32x4_t __reint1_177 = (uint32x4_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_177, __p3_177), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_177, __p3_177), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_177, __p3_177), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_177, __p3_177)}; \
+ __ret_177 = __noswap_vcmlaq_rot90_f16(__rev0_177, __rev1_177, *(float16x8_t *) &__reint1_177); \
+ __ret_177 = __builtin_shufflevector(__ret_177, __ret_177, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_177; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcltq_f16(float16x8_t __p0, float16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0 < __p1);
- return __ret;
-}
+#define vcmla_rot90_laneq_f16(__p0_178, __p1_178, __p2_178, __p3_178) __extension__ ({ \
+ float16x4_t __ret_178; \
+ float16x4_t __s0_178 = __p0_178; \
+ float16x4_t __s1_178 = __p1_178; \
+ float16x8_t __s2_178 = __p2_178; \
+float16x8_t __reint_178 = __s2_178; \
+uint32x2_t __reint1_178 = (uint32x2_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_178, __p3_178), vgetq_lane_u32(*(uint32x4_t *) &__reint_178, __p3_178)}; \
+ __ret_178 = vcmla_rot90_f16(__s0_178, __s1_178, *(float16x4_t *) &__reint1_178); \
+ __ret_178; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcltq_f16(float16x8_t __p0, float16x8_t __p1) {
- uint16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t)(__rev0 < __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmla_rot90_laneq_f16(__p0_179, __p1_179, __p2_179, __p3_179) __extension__ ({ \
+ float16x4_t __ret_179; \
+ float16x4_t __s0_179 = __p0_179; \
+ float16x4_t __s1_179 = __p1_179; \
+ float16x8_t __s2_179 = __p2_179; \
+ float16x4_t __rev0_179; __rev0_179 = __builtin_shufflevector(__s0_179, __s0_179, 3, 2, 1, 0); \
+ float16x4_t __rev1_179; __rev1_179 = __builtin_shufflevector(__s1_179, __s1_179, 3, 2, 1, 0); \
+ float16x8_t __rev2_179; __rev2_179 = __builtin_shufflevector(__s2_179, __s2_179, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16x8_t __reint_179 = __rev2_179; \
+uint32x2_t __reint1_179 = (uint32x2_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_179, __p3_179), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_179, __p3_179)}; \
+ __ret_179 = __noswap_vcmla_rot90_f16(__rev0_179, __rev1_179, *(float16x4_t *) &__reint1_179); \
+ __ret_179 = __builtin_shufflevector(__ret_179, __ret_179, 3, 2, 1, 0); \
+ __ret_179; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vclt_f16(float16x4_t __p0, float16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0 < __p1);
- return __ret;
-}
+#define vcmlaq_rot90_laneq_f16(__p0_180, __p1_180, __p2_180, __p3_180) __extension__ ({ \
+ float16x8_t __ret_180; \
+ float16x8_t __s0_180 = __p0_180; \
+ float16x8_t __s1_180 = __p1_180; \
+ float16x8_t __s2_180 = __p2_180; \
+float16x8_t __reint_180 = __s2_180; \
+uint32x4_t __reint1_180 = (uint32x4_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_180, __p3_180), vgetq_lane_u32(*(uint32x4_t *) &__reint_180, __p3_180), vgetq_lane_u32(*(uint32x4_t *) &__reint_180, __p3_180), vgetq_lane_u32(*(uint32x4_t *) &__reint_180, __p3_180)}; \
+ __ret_180 = vcmlaq_rot90_f16(__s0_180, __s1_180, *(float16x8_t *) &__reint1_180); \
+ __ret_180; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vclt_f16(float16x4_t __p0, float16x4_t __p1) {
- uint16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t)(__rev0 < __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmlaq_rot90_laneq_f16(__p0_181, __p1_181, __p2_181, __p3_181) __extension__ ({ \
+ float16x8_t __ret_181; \
+ float16x8_t __s0_181 = __p0_181; \
+ float16x8_t __s1_181 = __p1_181; \
+ float16x8_t __s2_181 = __p2_181; \
+ float16x8_t __rev0_181; __rev0_181 = __builtin_shufflevector(__s0_181, __s0_181, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev1_181; __rev1_181 = __builtin_shufflevector(__s1_181, __s1_181, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev2_181; __rev2_181 = __builtin_shufflevector(__s2_181, __s2_181, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16x8_t __reint_181 = __rev2_181; \
+uint32x4_t __reint1_181 = (uint32x4_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_181, __p3_181), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_181, __p3_181), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_181, __p3_181), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_181, __p3_181)}; \
+ __ret_181 = __noswap_vcmlaq_rot90_f16(__rev0_181, __rev1_181, *(float16x8_t *) &__reint1_181); \
+ __ret_181 = __builtin_shufflevector(__ret_181, __ret_181, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_181; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcltzq_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vcltzq_f16((int8x16_t)__p0, 49);
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcadd_rot270_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vcadd_rot270_f32((int8x8_t)__p0, (int8x8_t)__p1, 9);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcltzq_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vcltzq_f16((int8x16_t)__rev0, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcadd_rot270_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vcadd_rot270_f32((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcltz_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vcltz_f16((int8x8_t)__p0, 17);
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcadd_rot90_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vcadd_rot90_f32((int8x8_t)__p0, (int8x8_t)__p1, 9);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcltz_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vcltz_f16((int8x8_t)__rev0, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcadd_rot90_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vcadd_rot90_f32((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vcvtq_f16_u16(uint16x8_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vcvtq_f16_u16((int8x16_t)__p0, 49);
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcaddq_rot270_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vcaddq_rot270_f32((int8x16_t)__p0, (int8x16_t)__p1, 41);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vcvtq_f16_u16(uint16x8_t __p0) {
- float16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vcvtq_f16_u16((int8x16_t)__rev0, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcaddq_rot270_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vcaddq_rot270_f32((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vcvtq_f16_s16(int16x8_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vcvtq_f16_s16((int8x16_t)__p0, 33);
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcaddq_rot90_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vcaddq_rot90_f32((int8x16_t)__p0, (int8x16_t)__p1, 41);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vcvtq_f16_s16(int16x8_t __p0) {
- float16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vcvtq_f16_s16((int8x16_t)__rev0, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcaddq_rot90_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vcaddq_rot90_f32((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vcvt_f16_u16(uint16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vcvt_f16_u16((int8x8_t)__p0, 17);
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcmlaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vcmlaq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vcvt_f16_u16(uint16x4_t __p0) {
- float16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vcvt_f16_u16((int8x8_t)__rev0, 17);
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcmlaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ float32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vcmlaq_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t __noswap_vcmlaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vcmlaq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vcvt_f16_s16(int16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vcvt_f16_s16((int8x8_t)__p0, 1);
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcmla_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vcmla_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vcvt_f16_s16(int16x4_t __p0) {
- float16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vcvt_f16_s16((int8x8_t)__rev0, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcmla_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ float32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vcmla_f32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t __noswap_vcmla_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vcmla_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcvtq_n_f16_u16(__p0, __p1) __extension__ ({ \
- float16x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- __ret = (float16x8_t) __builtin_neon_vcvtq_n_f16_u16((int8x16_t)__s0, __p1, 49); \
- __ret; \
+#define vcmla_lane_f32(__p0_182, __p1_182, __p2_182, __p3_182) __extension__ ({ \
+ float32x2_t __ret_182; \
+ float32x2_t __s0_182 = __p0_182; \
+ float32x2_t __s1_182 = __p1_182; \
+ float32x2_t __s2_182 = __p2_182; \
+float32x2_t __reint_182 = __s2_182; \
+uint64x1_t __reint1_182 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_182, __p3_182)}; \
+ __ret_182 = vcmla_f32(__s0_182, __s1_182, *(float32x2_t *) &__reint1_182); \
+ __ret_182; \
})
#else
-#define vcvtq_n_f16_u16(__p0, __p1) __extension__ ({ \
- float16x8_t __ret; \
- uint16x8_t __s0 = __p0; \
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (float16x8_t) __builtin_neon_vcvtq_n_f16_u16((int8x16_t)__rev0, __p1, 49); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vcmla_lane_f32(__p0_183, __p1_183, __p2_183, __p3_183) __extension__ ({ \
+ float32x2_t __ret_183; \
+ float32x2_t __s0_183 = __p0_183; \
+ float32x2_t __s1_183 = __p1_183; \
+ float32x2_t __s2_183 = __p2_183; \
+ float32x2_t __rev0_183; __rev0_183 = __builtin_shufflevector(__s0_183, __s0_183, 1, 0); \
+ float32x2_t __rev1_183; __rev1_183 = __builtin_shufflevector(__s1_183, __s1_183, 1, 0); \
+ float32x2_t __rev2_183; __rev2_183 = __builtin_shufflevector(__s2_183, __s2_183, 1, 0); \
+float32x2_t __reint_183 = __rev2_183; \
+uint64x1_t __reint1_183 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_183, __p3_183)}; \
+ __ret_183 = __noswap_vcmla_f32(__rev0_183, __rev1_183, *(float32x2_t *) &__reint1_183); \
+ __ret_183 = __builtin_shufflevector(__ret_183, __ret_183, 1, 0); \
+ __ret_183; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcvtq_n_f16_s16(__p0, __p1) __extension__ ({ \
- float16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (float16x8_t) __builtin_neon_vcvtq_n_f16_s16((int8x16_t)__s0, __p1, 33); \
- __ret; \
+#define vcmlaq_lane_f32(__p0_184, __p1_184, __p2_184, __p3_184) __extension__ ({ \
+ float32x4_t __ret_184; \
+ float32x4_t __s0_184 = __p0_184; \
+ float32x4_t __s1_184 = __p1_184; \
+ float32x2_t __s2_184 = __p2_184; \
+float32x2_t __reint_184 = __s2_184; \
+uint64x2_t __reint1_184 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_184, __p3_184), vget_lane_u64(*(uint64x1_t *) &__reint_184, __p3_184)}; \
+ __ret_184 = vcmlaq_f32(__s0_184, __s1_184, *(float32x4_t *) &__reint1_184); \
+ __ret_184; \
})
#else
-#define vcvtq_n_f16_s16(__p0, __p1) __extension__ ({ \
- float16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (float16x8_t) __builtin_neon_vcvtq_n_f16_s16((int8x16_t)__rev0, __p1, 33); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vcmlaq_lane_f32(__p0_185, __p1_185, __p2_185, __p3_185) __extension__ ({ \
+ float32x4_t __ret_185; \
+ float32x4_t __s0_185 = __p0_185; \
+ float32x4_t __s1_185 = __p1_185; \
+ float32x2_t __s2_185 = __p2_185; \
+ float32x4_t __rev0_185; __rev0_185 = __builtin_shufflevector(__s0_185, __s0_185, 3, 2, 1, 0); \
+ float32x4_t __rev1_185; __rev1_185 = __builtin_shufflevector(__s1_185, __s1_185, 3, 2, 1, 0); \
+ float32x2_t __rev2_185; __rev2_185 = __builtin_shufflevector(__s2_185, __s2_185, 1, 0); \
+float32x2_t __reint_185 = __rev2_185; \
+uint64x2_t __reint1_185 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_185, __p3_185), vget_lane_u64(*(uint64x1_t *) &__reint_185, __p3_185)}; \
+ __ret_185 = __noswap_vcmlaq_f32(__rev0_185, __rev1_185, *(float32x4_t *) &__reint1_185); \
+ __ret_185 = __builtin_shufflevector(__ret_185, __ret_185, 3, 2, 1, 0); \
+ __ret_185; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcvt_n_f16_u16(__p0, __p1) __extension__ ({ \
- float16x4_t __ret; \
- uint16x4_t __s0 = __p0; \
- __ret = (float16x4_t) __builtin_neon_vcvt_n_f16_u16((int8x8_t)__s0, __p1, 17); \
- __ret; \
+#define vcmla_laneq_f32(__p0_186, __p1_186, __p2_186, __p3_186) __extension__ ({ \
+ float32x2_t __ret_186; \
+ float32x2_t __s0_186 = __p0_186; \
+ float32x2_t __s1_186 = __p1_186; \
+ float32x4_t __s2_186 = __p2_186; \
+float32x4_t __reint_186 = __s2_186; \
+uint64x1_t __reint1_186 = (uint64x1_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_186, __p3_186)}; \
+ __ret_186 = vcmla_f32(__s0_186, __s1_186, *(float32x2_t *) &__reint1_186); \
+ __ret_186; \
})
#else
-#define vcvt_n_f16_u16(__p0, __p1) __extension__ ({ \
- float16x4_t __ret; \
- uint16x4_t __s0 = __p0; \
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (float16x4_t) __builtin_neon_vcvt_n_f16_u16((int8x8_t)__rev0, __p1, 17); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
+#define vcmla_laneq_f32(__p0_187, __p1_187, __p2_187, __p3_187) __extension__ ({ \
+ float32x2_t __ret_187; \
+ float32x2_t __s0_187 = __p0_187; \
+ float32x2_t __s1_187 = __p1_187; \
+ float32x4_t __s2_187 = __p2_187; \
+ float32x2_t __rev0_187; __rev0_187 = __builtin_shufflevector(__s0_187, __s0_187, 1, 0); \
+ float32x2_t __rev1_187; __rev1_187 = __builtin_shufflevector(__s1_187, __s1_187, 1, 0); \
+ float32x4_t __rev2_187; __rev2_187 = __builtin_shufflevector(__s2_187, __s2_187, 3, 2, 1, 0); \
+float32x4_t __reint_187 = __rev2_187; \
+uint64x1_t __reint1_187 = (uint64x1_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_187, __p3_187)}; \
+ __ret_187 = __noswap_vcmla_f32(__rev0_187, __rev1_187, *(float32x2_t *) &__reint1_187); \
+ __ret_187 = __builtin_shufflevector(__ret_187, __ret_187, 1, 0); \
+ __ret_187; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcvt_n_f16_s16(__p0, __p1) __extension__ ({ \
- float16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- __ret = (float16x4_t) __builtin_neon_vcvt_n_f16_s16((int8x8_t)__s0, __p1, 1); \
- __ret; \
+#define vcmlaq_laneq_f32(__p0_188, __p1_188, __p2_188, __p3_188) __extension__ ({ \
+ float32x4_t __ret_188; \
+ float32x4_t __s0_188 = __p0_188; \
+ float32x4_t __s1_188 = __p1_188; \
+ float32x4_t __s2_188 = __p2_188; \
+float32x4_t __reint_188 = __s2_188; \
+uint64x2_t __reint1_188 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_188, __p3_188), vgetq_lane_u64(*(uint64x2_t *) &__reint_188, __p3_188)}; \
+ __ret_188 = vcmlaq_f32(__s0_188, __s1_188, *(float32x4_t *) &__reint1_188); \
+ __ret_188; \
})
#else
-#define vcvt_n_f16_s16(__p0, __p1) __extension__ ({ \
- float16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (float16x4_t) __builtin_neon_vcvt_n_f16_s16((int8x8_t)__rev0, __p1, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
+#define vcmlaq_laneq_f32(__p0_189, __p1_189, __p2_189, __p3_189) __extension__ ({ \
+ float32x4_t __ret_189; \
+ float32x4_t __s0_189 = __p0_189; \
+ float32x4_t __s1_189 = __p1_189; \
+ float32x4_t __s2_189 = __p2_189; \
+ float32x4_t __rev0_189; __rev0_189 = __builtin_shufflevector(__s0_189, __s0_189, 3, 2, 1, 0); \
+ float32x4_t __rev1_189; __rev1_189 = __builtin_shufflevector(__s1_189, __s1_189, 3, 2, 1, 0); \
+ float32x4_t __rev2_189; __rev2_189 = __builtin_shufflevector(__s2_189, __s2_189, 3, 2, 1, 0); \
+float32x4_t __reint_189 = __rev2_189; \
+uint64x2_t __reint1_189 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_189, __p3_189), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_189, __p3_189)}; \
+ __ret_189 = __noswap_vcmlaq_f32(__rev0_189, __rev1_189, *(float32x4_t *) &__reint1_189); \
+ __ret_189 = __builtin_shufflevector(__ret_189, __ret_189, 3, 2, 1, 0); \
+ __ret_189; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcvtq_n_s16_f16(__p0, __p1) __extension__ ({ \
- int16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- __ret = (int16x8_t) __builtin_neon_vcvtq_n_s16_f16((int8x16_t)__s0, __p1, 33); \
- __ret; \
-})
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcmlaq_rot180_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vcmlaq_rot180_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+ return __ret;
+}
#else
-#define vcvtq_n_s16_f16(__p0, __p1) __extension__ ({ \
- int16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_vcvtq_n_s16_f16((int8x16_t)__rev0, __p1, 33); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcmlaq_rot180_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ float32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vcmlaq_rot180_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t __noswap_vcmlaq_rot180_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vcmlaq_rot180_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcvt_n_s16_f16(__p0, __p1) __extension__ ({ \
- int16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- __ret = (int16x4_t) __builtin_neon_vcvt_n_s16_f16((int8x8_t)__s0, __p1, 1); \
- __ret; \
-})
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcmla_rot180_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vcmla_rot180_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+ return __ret;
+}
#else
-#define vcvt_n_s16_f16(__p0, __p1) __extension__ ({ \
- int16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vcvt_n_s16_f16((int8x8_t)__rev0, __p1, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcmla_rot180_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ float32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vcmla_rot180_f32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t __noswap_vcmla_rot180_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vcmla_rot180_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcvtq_n_u16_f16(__p0, __p1) __extension__ ({ \
- uint16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- __ret = (uint16x8_t) __builtin_neon_vcvtq_n_u16_f16((int8x16_t)__s0, __p1, 49); \
- __ret; \
+#define vcmla_rot180_lane_f32(__p0_190, __p1_190, __p2_190, __p3_190) __extension__ ({ \
+ float32x2_t __ret_190; \
+ float32x2_t __s0_190 = __p0_190; \
+ float32x2_t __s1_190 = __p1_190; \
+ float32x2_t __s2_190 = __p2_190; \
+float32x2_t __reint_190 = __s2_190; \
+uint64x1_t __reint1_190 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_190, __p3_190)}; \
+ __ret_190 = vcmla_rot180_f32(__s0_190, __s1_190, *(float32x2_t *) &__reint1_190); \
+ __ret_190; \
})
#else
-#define vcvtq_n_u16_f16(__p0, __p1) __extension__ ({ \
- uint16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint16x8_t) __builtin_neon_vcvtq_n_u16_f16((int8x16_t)__rev0, __p1, 49); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vcmla_rot180_lane_f32(__p0_191, __p1_191, __p2_191, __p3_191) __extension__ ({ \
+ float32x2_t __ret_191; \
+ float32x2_t __s0_191 = __p0_191; \
+ float32x2_t __s1_191 = __p1_191; \
+ float32x2_t __s2_191 = __p2_191; \
+ float32x2_t __rev0_191; __rev0_191 = __builtin_shufflevector(__s0_191, __s0_191, 1, 0); \
+ float32x2_t __rev1_191; __rev1_191 = __builtin_shufflevector(__s1_191, __s1_191, 1, 0); \
+ float32x2_t __rev2_191; __rev2_191 = __builtin_shufflevector(__s2_191, __s2_191, 1, 0); \
+float32x2_t __reint_191 = __rev2_191; \
+uint64x1_t __reint1_191 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_191, __p3_191)}; \
+ __ret_191 = __noswap_vcmla_rot180_f32(__rev0_191, __rev1_191, *(float32x2_t *) &__reint1_191); \
+ __ret_191 = __builtin_shufflevector(__ret_191, __ret_191, 1, 0); \
+ __ret_191; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcvt_n_u16_f16(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- __ret = (uint16x4_t) __builtin_neon_vcvt_n_u16_f16((int8x8_t)__s0, __p1, 17); \
- __ret; \
+#define vcmlaq_rot180_lane_f32(__p0_192, __p1_192, __p2_192, __p3_192) __extension__ ({ \
+ float32x4_t __ret_192; \
+ float32x4_t __s0_192 = __p0_192; \
+ float32x4_t __s1_192 = __p1_192; \
+ float32x2_t __s2_192 = __p2_192; \
+float32x2_t __reint_192 = __s2_192; \
+uint64x2_t __reint1_192 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_192, __p3_192), vget_lane_u64(*(uint64x1_t *) &__reint_192, __p3_192)}; \
+ __ret_192 = vcmlaq_rot180_f32(__s0_192, __s1_192, *(float32x4_t *) &__reint1_192); \
+ __ret_192; \
})
#else
-#define vcvt_n_u16_f16(__p0, __p1) __extension__ ({ \
- uint16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint16x4_t) __builtin_neon_vcvt_n_u16_f16((int8x8_t)__rev0, __p1, 17); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
+#define vcmlaq_rot180_lane_f32(__p0_193, __p1_193, __p2_193, __p3_193) __extension__ ({ \
+ float32x4_t __ret_193; \
+ float32x4_t __s0_193 = __p0_193; \
+ float32x4_t __s1_193 = __p1_193; \
+ float32x2_t __s2_193 = __p2_193; \
+ float32x4_t __rev0_193; __rev0_193 = __builtin_shufflevector(__s0_193, __s0_193, 3, 2, 1, 0); \
+ float32x4_t __rev1_193; __rev1_193 = __builtin_shufflevector(__s1_193, __s1_193, 3, 2, 1, 0); \
+ float32x2_t __rev2_193; __rev2_193 = __builtin_shufflevector(__s2_193, __s2_193, 1, 0); \
+float32x2_t __reint_193 = __rev2_193; \
+uint64x2_t __reint1_193 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_193, __p3_193), vget_lane_u64(*(uint64x1_t *) &__reint_193, __p3_193)}; \
+ __ret_193 = __noswap_vcmlaq_rot180_f32(__rev0_193, __rev1_193, *(float32x4_t *) &__reint1_193); \
+ __ret_193 = __builtin_shufflevector(__ret_193, __ret_193, 3, 2, 1, 0); \
+ __ret_193; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) int16x8_t vcvtq_s16_f16(float16x8_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vcvtq_s16_f16((int8x16_t)__p0, 33);
- return __ret;
-}
+#define vcmla_rot180_laneq_f32(__p0_194, __p1_194, __p2_194, __p3_194) __extension__ ({ \
+ float32x2_t __ret_194; \
+ float32x2_t __s0_194 = __p0_194; \
+ float32x2_t __s1_194 = __p1_194; \
+ float32x4_t __s2_194 = __p2_194; \
+float32x4_t __reint_194 = __s2_194; \
+uint64x1_t __reint1_194 = (uint64x1_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_194, __p3_194)}; \
+ __ret_194 = vcmla_rot180_f32(__s0_194, __s1_194, *(float32x2_t *) &__reint1_194); \
+ __ret_194; \
+})
#else
-__ai __attribute__((target("fullfp16"))) int16x8_t vcvtq_s16_f16(float16x8_t __p0) {
- int16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vcvtq_s16_f16((int8x16_t)__rev0, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmla_rot180_laneq_f32(__p0_195, __p1_195, __p2_195, __p3_195) __extension__ ({ \
+ float32x2_t __ret_195; \
+ float32x2_t __s0_195 = __p0_195; \
+ float32x2_t __s1_195 = __p1_195; \
+ float32x4_t __s2_195 = __p2_195; \
+ float32x2_t __rev0_195; __rev0_195 = __builtin_shufflevector(__s0_195, __s0_195, 1, 0); \
+ float32x2_t __rev1_195; __rev1_195 = __builtin_shufflevector(__s1_195, __s1_195, 1, 0); \
+ float32x4_t __rev2_195; __rev2_195 = __builtin_shufflevector(__s2_195, __s2_195, 3, 2, 1, 0); \
+float32x4_t __reint_195 = __rev2_195; \
+uint64x1_t __reint1_195 = (uint64x1_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_195, __p3_195)}; \
+ __ret_195 = __noswap_vcmla_rot180_f32(__rev0_195, __rev1_195, *(float32x2_t *) &__reint1_195); \
+ __ret_195 = __builtin_shufflevector(__ret_195, __ret_195, 1, 0); \
+ __ret_195; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) int16x4_t vcvt_s16_f16(float16x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vcvt_s16_f16((int8x8_t)__p0, 1);
+#define vcmlaq_rot180_laneq_f32(__p0_196, __p1_196, __p2_196, __p3_196) __extension__ ({ \
+ float32x4_t __ret_196; \
+ float32x4_t __s0_196 = __p0_196; \
+ float32x4_t __s1_196 = __p1_196; \
+ float32x4_t __s2_196 = __p2_196; \
+float32x4_t __reint_196 = __s2_196; \
+uint64x2_t __reint1_196 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_196, __p3_196), vgetq_lane_u64(*(uint64x2_t *) &__reint_196, __p3_196)}; \
+ __ret_196 = vcmlaq_rot180_f32(__s0_196, __s1_196, *(float32x4_t *) &__reint1_196); \
+ __ret_196; \
+})
+#else
+#define vcmlaq_rot180_laneq_f32(__p0_197, __p1_197, __p2_197, __p3_197) __extension__ ({ \
+ float32x4_t __ret_197; \
+ float32x4_t __s0_197 = __p0_197; \
+ float32x4_t __s1_197 = __p1_197; \
+ float32x4_t __s2_197 = __p2_197; \
+ float32x4_t __rev0_197; __rev0_197 = __builtin_shufflevector(__s0_197, __s0_197, 3, 2, 1, 0); \
+ float32x4_t __rev1_197; __rev1_197 = __builtin_shufflevector(__s1_197, __s1_197, 3, 2, 1, 0); \
+ float32x4_t __rev2_197; __rev2_197 = __builtin_shufflevector(__s2_197, __s2_197, 3, 2, 1, 0); \
+float32x4_t __reint_197 = __rev2_197; \
+uint64x2_t __reint1_197 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_197, __p3_197), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_197, __p3_197)}; \
+ __ret_197 = __noswap_vcmlaq_rot180_f32(__rev0_197, __rev1_197, *(float32x4_t *) &__reint1_197); \
+ __ret_197 = __builtin_shufflevector(__ret_197, __ret_197, 3, 2, 1, 0); \
+ __ret_197; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcmlaq_rot270_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vcmlaq_rot270_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) int16x4_t vcvt_s16_f16(float16x4_t __p0) {
- int16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vcvt_s16_f16((int8x8_t)__rev0, 1);
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcmlaq_rot270_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ float32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vcmlaq_rot270_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t __noswap_vcmlaq_rot270_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vcmlaq_rot270_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcvtq_u16_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vcvtq_u16_f16((int8x16_t)__p0, 49);
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcmla_rot270_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vcmla_rot270_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcvtq_u16_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vcvtq_u16_f16((int8x16_t)__rev0, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcmla_rot270_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ float32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vcmla_rot270_f32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t __noswap_vcmla_rot270_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vcmla_rot270_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcvt_u16_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vcvt_u16_f16((int8x8_t)__p0, 17);
- return __ret;
-}
+#define vcmla_rot270_lane_f32(__p0_198, __p1_198, __p2_198, __p3_198) __extension__ ({ \
+ float32x2_t __ret_198; \
+ float32x2_t __s0_198 = __p0_198; \
+ float32x2_t __s1_198 = __p1_198; \
+ float32x2_t __s2_198 = __p2_198; \
+float32x2_t __reint_198 = __s2_198; \
+uint64x1_t __reint1_198 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_198, __p3_198)}; \
+ __ret_198 = vcmla_rot270_f32(__s0_198, __s1_198, *(float32x2_t *) &__reint1_198); \
+ __ret_198; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcvt_u16_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vcvt_u16_f16((int8x8_t)__rev0, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmla_rot270_lane_f32(__p0_199, __p1_199, __p2_199, __p3_199) __extension__ ({ \
+ float32x2_t __ret_199; \
+ float32x2_t __s0_199 = __p0_199; \
+ float32x2_t __s1_199 = __p1_199; \
+ float32x2_t __s2_199 = __p2_199; \
+ float32x2_t __rev0_199; __rev0_199 = __builtin_shufflevector(__s0_199, __s0_199, 1, 0); \
+ float32x2_t __rev1_199; __rev1_199 = __builtin_shufflevector(__s1_199, __s1_199, 1, 0); \
+ float32x2_t __rev2_199; __rev2_199 = __builtin_shufflevector(__s2_199, __s2_199, 1, 0); \
+float32x2_t __reint_199 = __rev2_199; \
+uint64x1_t __reint1_199 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_199, __p3_199)}; \
+ __ret_199 = __noswap_vcmla_rot270_f32(__rev0_199, __rev1_199, *(float32x2_t *) &__reint1_199); \
+ __ret_199 = __builtin_shufflevector(__ret_199, __ret_199, 1, 0); \
+ __ret_199; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) int16x8_t vcvtaq_s16_f16(float16x8_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vcvtaq_s16_f16((int8x16_t)__p0, 33);
- return __ret;
-}
+#define vcmlaq_rot270_lane_f32(__p0_200, __p1_200, __p2_200, __p3_200) __extension__ ({ \
+ float32x4_t __ret_200; \
+ float32x4_t __s0_200 = __p0_200; \
+ float32x4_t __s1_200 = __p1_200; \
+ float32x2_t __s2_200 = __p2_200; \
+float32x2_t __reint_200 = __s2_200; \
+uint64x2_t __reint1_200 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_200, __p3_200), vget_lane_u64(*(uint64x1_t *) &__reint_200, __p3_200)}; \
+ __ret_200 = vcmlaq_rot270_f32(__s0_200, __s1_200, *(float32x4_t *) &__reint1_200); \
+ __ret_200; \
+})
#else
-__ai __attribute__((target("fullfp16"))) int16x8_t vcvtaq_s16_f16(float16x8_t __p0) {
- int16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vcvtaq_s16_f16((int8x16_t)__rev0, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmlaq_rot270_lane_f32(__p0_201, __p1_201, __p2_201, __p3_201) __extension__ ({ \
+ float32x4_t __ret_201; \
+ float32x4_t __s0_201 = __p0_201; \
+ float32x4_t __s1_201 = __p1_201; \
+ float32x2_t __s2_201 = __p2_201; \
+ float32x4_t __rev0_201; __rev0_201 = __builtin_shufflevector(__s0_201, __s0_201, 3, 2, 1, 0); \
+ float32x4_t __rev1_201; __rev1_201 = __builtin_shufflevector(__s1_201, __s1_201, 3, 2, 1, 0); \
+ float32x2_t __rev2_201; __rev2_201 = __builtin_shufflevector(__s2_201, __s2_201, 1, 0); \
+float32x2_t __reint_201 = __rev2_201; \
+uint64x2_t __reint1_201 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_201, __p3_201), vget_lane_u64(*(uint64x1_t *) &__reint_201, __p3_201)}; \
+ __ret_201 = __noswap_vcmlaq_rot270_f32(__rev0_201, __rev1_201, *(float32x4_t *) &__reint1_201); \
+ __ret_201 = __builtin_shufflevector(__ret_201, __ret_201, 3, 2, 1, 0); \
+ __ret_201; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) int16x4_t vcvta_s16_f16(float16x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vcvta_s16_f16((int8x8_t)__p0, 1);
- return __ret;
-}
+#define vcmla_rot270_laneq_f32(__p0_202, __p1_202, __p2_202, __p3_202) __extension__ ({ \
+ float32x2_t __ret_202; \
+ float32x2_t __s0_202 = __p0_202; \
+ float32x2_t __s1_202 = __p1_202; \
+ float32x4_t __s2_202 = __p2_202; \
+float32x4_t __reint_202 = __s2_202; \
+uint64x1_t __reint1_202 = (uint64x1_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_202, __p3_202)}; \
+ __ret_202 = vcmla_rot270_f32(__s0_202, __s1_202, *(float32x2_t *) &__reint1_202); \
+ __ret_202; \
+})
#else
-__ai __attribute__((target("fullfp16"))) int16x4_t vcvta_s16_f16(float16x4_t __p0) {
- int16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vcvta_s16_f16((int8x8_t)__rev0, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmla_rot270_laneq_f32(__p0_203, __p1_203, __p2_203, __p3_203) __extension__ ({ \
+ float32x2_t __ret_203; \
+ float32x2_t __s0_203 = __p0_203; \
+ float32x2_t __s1_203 = __p1_203; \
+ float32x4_t __s2_203 = __p2_203; \
+ float32x2_t __rev0_203; __rev0_203 = __builtin_shufflevector(__s0_203, __s0_203, 1, 0); \
+ float32x2_t __rev1_203; __rev1_203 = __builtin_shufflevector(__s1_203, __s1_203, 1, 0); \
+ float32x4_t __rev2_203; __rev2_203 = __builtin_shufflevector(__s2_203, __s2_203, 3, 2, 1, 0); \
+float32x4_t __reint_203 = __rev2_203; \
+uint64x1_t __reint1_203 = (uint64x1_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_203, __p3_203)}; \
+ __ret_203 = __noswap_vcmla_rot270_f32(__rev0_203, __rev1_203, *(float32x2_t *) &__reint1_203); \
+ __ret_203 = __builtin_shufflevector(__ret_203, __ret_203, 1, 0); \
+ __ret_203; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcvtaq_u16_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vcvtaq_u16_f16((int8x16_t)__p0, 49);
- return __ret;
-}
+#define vcmlaq_rot270_laneq_f32(__p0_204, __p1_204, __p2_204, __p3_204) __extension__ ({ \
+ float32x4_t __ret_204; \
+ float32x4_t __s0_204 = __p0_204; \
+ float32x4_t __s1_204 = __p1_204; \
+ float32x4_t __s2_204 = __p2_204; \
+float32x4_t __reint_204 = __s2_204; \
+uint64x2_t __reint1_204 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_204, __p3_204), vgetq_lane_u64(*(uint64x2_t *) &__reint_204, __p3_204)}; \
+ __ret_204 = vcmlaq_rot270_f32(__s0_204, __s1_204, *(float32x4_t *) &__reint1_204); \
+ __ret_204; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcvtaq_u16_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vcvtaq_u16_f16((int8x16_t)__rev0, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmlaq_rot270_laneq_f32(__p0_205, __p1_205, __p2_205, __p3_205) __extension__ ({ \
+ float32x4_t __ret_205; \
+ float32x4_t __s0_205 = __p0_205; \
+ float32x4_t __s1_205 = __p1_205; \
+ float32x4_t __s2_205 = __p2_205; \
+ float32x4_t __rev0_205; __rev0_205 = __builtin_shufflevector(__s0_205, __s0_205, 3, 2, 1, 0); \
+ float32x4_t __rev1_205; __rev1_205 = __builtin_shufflevector(__s1_205, __s1_205, 3, 2, 1, 0); \
+ float32x4_t __rev2_205; __rev2_205 = __builtin_shufflevector(__s2_205, __s2_205, 3, 2, 1, 0); \
+float32x4_t __reint_205 = __rev2_205; \
+uint64x2_t __reint1_205 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_205, __p3_205), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_205, __p3_205)}; \
+ __ret_205 = __noswap_vcmlaq_rot270_f32(__rev0_205, __rev1_205, *(float32x4_t *) &__reint1_205); \
+ __ret_205 = __builtin_shufflevector(__ret_205, __ret_205, 3, 2, 1, 0); \
+ __ret_205; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcvta_u16_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vcvta_u16_f16((int8x8_t)__p0, 17);
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcmlaq_rot90_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vcmlaq_rot90_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcvta_u16_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vcvta_u16_f16((int8x8_t)__rev0, 17);
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcmlaq_rot90_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ float32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vcmlaq_rot90_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t __noswap_vcmlaq_rot90_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vcmlaq_rot90_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) int16x8_t vcvtmq_s16_f16(float16x8_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vcvtmq_s16_f16((int8x16_t)__p0, 33);
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcmla_rot90_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vcmla_rot90_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) int16x8_t vcvtmq_s16_f16(float16x8_t __p0) {
- int16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vcvtmq_s16_f16((int8x16_t)__rev0, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcmla_rot90_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ float32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vcmla_rot90_f32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t __noswap_vcmla_rot90_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vcmla_rot90_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) int16x4_t vcvtm_s16_f16(float16x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vcvtm_s16_f16((int8x8_t)__p0, 1);
- return __ret;
-}
+#define vcmla_rot90_lane_f32(__p0_206, __p1_206, __p2_206, __p3_206) __extension__ ({ \
+ float32x2_t __ret_206; \
+ float32x2_t __s0_206 = __p0_206; \
+ float32x2_t __s1_206 = __p1_206; \
+ float32x2_t __s2_206 = __p2_206; \
+float32x2_t __reint_206 = __s2_206; \
+uint64x1_t __reint1_206 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_206, __p3_206)}; \
+ __ret_206 = vcmla_rot90_f32(__s0_206, __s1_206, *(float32x2_t *) &__reint1_206); \
+ __ret_206; \
+})
#else
-__ai __attribute__((target("fullfp16"))) int16x4_t vcvtm_s16_f16(float16x4_t __p0) {
- int16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vcvtm_s16_f16((int8x8_t)__rev0, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmla_rot90_lane_f32(__p0_207, __p1_207, __p2_207, __p3_207) __extension__ ({ \
+ float32x2_t __ret_207; \
+ float32x2_t __s0_207 = __p0_207; \
+ float32x2_t __s1_207 = __p1_207; \
+ float32x2_t __s2_207 = __p2_207; \
+ float32x2_t __rev0_207; __rev0_207 = __builtin_shufflevector(__s0_207, __s0_207, 1, 0); \
+ float32x2_t __rev1_207; __rev1_207 = __builtin_shufflevector(__s1_207, __s1_207, 1, 0); \
+ float32x2_t __rev2_207; __rev2_207 = __builtin_shufflevector(__s2_207, __s2_207, 1, 0); \
+float32x2_t __reint_207 = __rev2_207; \
+uint64x1_t __reint1_207 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_207, __p3_207)}; \
+ __ret_207 = __noswap_vcmla_rot90_f32(__rev0_207, __rev1_207, *(float32x2_t *) &__reint1_207); \
+ __ret_207 = __builtin_shufflevector(__ret_207, __ret_207, 1, 0); \
+ __ret_207; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcvtmq_u16_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vcvtmq_u16_f16((int8x16_t)__p0, 49);
- return __ret;
-}
+#define vcmlaq_rot90_lane_f32(__p0_208, __p1_208, __p2_208, __p3_208) __extension__ ({ \
+ float32x4_t __ret_208; \
+ float32x4_t __s0_208 = __p0_208; \
+ float32x4_t __s1_208 = __p1_208; \
+ float32x2_t __s2_208 = __p2_208; \
+float32x2_t __reint_208 = __s2_208; \
+uint64x2_t __reint1_208 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_208, __p3_208), vget_lane_u64(*(uint64x1_t *) &__reint_208, __p3_208)}; \
+ __ret_208 = vcmlaq_rot90_f32(__s0_208, __s1_208, *(float32x4_t *) &__reint1_208); \
+ __ret_208; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcvtmq_u16_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vcvtmq_u16_f16((int8x16_t)__rev0, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmlaq_rot90_lane_f32(__p0_209, __p1_209, __p2_209, __p3_209) __extension__ ({ \
+ float32x4_t __ret_209; \
+ float32x4_t __s0_209 = __p0_209; \
+ float32x4_t __s1_209 = __p1_209; \
+ float32x2_t __s2_209 = __p2_209; \
+ float32x4_t __rev0_209; __rev0_209 = __builtin_shufflevector(__s0_209, __s0_209, 3, 2, 1, 0); \
+ float32x4_t __rev1_209; __rev1_209 = __builtin_shufflevector(__s1_209, __s1_209, 3, 2, 1, 0); \
+ float32x2_t __rev2_209; __rev2_209 = __builtin_shufflevector(__s2_209, __s2_209, 1, 0); \
+float32x2_t __reint_209 = __rev2_209; \
+uint64x2_t __reint1_209 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_209, __p3_209), vget_lane_u64(*(uint64x1_t *) &__reint_209, __p3_209)}; \
+ __ret_209 = __noswap_vcmlaq_rot90_f32(__rev0_209, __rev1_209, *(float32x4_t *) &__reint1_209); \
+ __ret_209 = __builtin_shufflevector(__ret_209, __ret_209, 3, 2, 1, 0); \
+ __ret_209; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcvtm_u16_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vcvtm_u16_f16((int8x8_t)__p0, 17);
- return __ret;
-}
+#define vcmla_rot90_laneq_f32(__p0_210, __p1_210, __p2_210, __p3_210) __extension__ ({ \
+ float32x2_t __ret_210; \
+ float32x2_t __s0_210 = __p0_210; \
+ float32x2_t __s1_210 = __p1_210; \
+ float32x4_t __s2_210 = __p2_210; \
+float32x4_t __reint_210 = __s2_210; \
+uint64x1_t __reint1_210 = (uint64x1_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_210, __p3_210)}; \
+ __ret_210 = vcmla_rot90_f32(__s0_210, __s1_210, *(float32x2_t *) &__reint1_210); \
+ __ret_210; \
+})
#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcvtm_u16_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vcvtm_u16_f16((int8x8_t)__rev0, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmla_rot90_laneq_f32(__p0_211, __p1_211, __p2_211, __p3_211) __extension__ ({ \
+ float32x2_t __ret_211; \
+ float32x2_t __s0_211 = __p0_211; \
+ float32x2_t __s1_211 = __p1_211; \
+ float32x4_t __s2_211 = __p2_211; \
+ float32x2_t __rev0_211; __rev0_211 = __builtin_shufflevector(__s0_211, __s0_211, 1, 0); \
+ float32x2_t __rev1_211; __rev1_211 = __builtin_shufflevector(__s1_211, __s1_211, 1, 0); \
+ float32x4_t __rev2_211; __rev2_211 = __builtin_shufflevector(__s2_211, __s2_211, 3, 2, 1, 0); \
+float32x4_t __reint_211 = __rev2_211; \
+uint64x1_t __reint1_211 = (uint64x1_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_211, __p3_211)}; \
+ __ret_211 = __noswap_vcmla_rot90_f32(__rev0_211, __rev1_211, *(float32x2_t *) &__reint1_211); \
+ __ret_211 = __builtin_shufflevector(__ret_211, __ret_211, 1, 0); \
+ __ret_211; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) int16x8_t vcvtnq_s16_f16(float16x8_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vcvtnq_s16_f16((int8x16_t)__p0, 33);
- return __ret;
-}
+#define vcmlaq_rot90_laneq_f32(__p0_212, __p1_212, __p2_212, __p3_212) __extension__ ({ \
+ float32x4_t __ret_212; \
+ float32x4_t __s0_212 = __p0_212; \
+ float32x4_t __s1_212 = __p1_212; \
+ float32x4_t __s2_212 = __p2_212; \
+float32x4_t __reint_212 = __s2_212; \
+uint64x2_t __reint1_212 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_212, __p3_212), vgetq_lane_u64(*(uint64x2_t *) &__reint_212, __p3_212)}; \
+ __ret_212 = vcmlaq_rot90_f32(__s0_212, __s1_212, *(float32x4_t *) &__reint1_212); \
+ __ret_212; \
+})
#else
-__ai __attribute__((target("fullfp16"))) int16x8_t vcvtnq_s16_f16(float16x8_t __p0) {
- int16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vcvtnq_s16_f16((int8x16_t)__rev0, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vcmlaq_rot90_laneq_f32(__p0_213, __p1_213, __p2_213, __p3_213) __extension__ ({ \
+ float32x4_t __ret_213; \
+ float32x4_t __s0_213 = __p0_213; \
+ float32x4_t __s1_213 = __p1_213; \
+ float32x4_t __s2_213 = __p2_213; \
+ float32x4_t __rev0_213; __rev0_213 = __builtin_shufflevector(__s0_213, __s0_213, 3, 2, 1, 0); \
+ float32x4_t __rev1_213; __rev1_213 = __builtin_shufflevector(__s1_213, __s1_213, 3, 2, 1, 0); \
+ float32x4_t __rev2_213; __rev2_213 = __builtin_shufflevector(__s2_213, __s2_213, 3, 2, 1, 0); \
+float32x4_t __reint_213 = __rev2_213; \
+uint64x2_t __reint1_213 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_213, __p3_213), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_213, __p3_213)}; \
+ __ret_213 = __noswap_vcmlaq_rot90_f32(__rev0_213, __rev1_213, *(float32x4_t *) &__reint1_213); \
+ __ret_213 = __builtin_shufflevector(__ret_213, __ret_213, 3, 2, 1, 0); \
+ __ret_213; \
+})
#endif
+#if !defined(__aarch64__) && !defined(__arm64ec__)
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) int16x4_t vcvtn_s16_f16(float16x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vcvtn_s16_f16((int8x8_t)__p0, 1);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t __a32_vcvt_bf16_f32(float32x4_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t) __builtin_neon___a32_vcvt_bf16_f32((int8x16_t)__p0, 11);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) int16x4_t vcvtn_s16_f16(float16x4_t __p0) {
- int16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vcvtn_s16_f16((int8x8_t)__rev0, 1);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t __a32_vcvt_bf16_f32(float32x4_t __p0) {
+ bfloat16x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (bfloat16x4_t) __builtin_neon___a32_vcvt_bf16_f32((int8x16_t)__rev0, 11);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t __noswap___a32_vcvt_bf16_f32(float32x4_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t) __builtin_neon___a32_vcvt_bf16_f32((int8x16_t)__p0, 11);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcvtnq_u16_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vcvtnq_u16_f16((int8x16_t)__p0, 49);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vcvt_bf16_f32(float32x4_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = __a32_vcvt_bf16_f32(__p0);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcvtnq_u16_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vcvtnq_u16_f16((int8x16_t)__rev0, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vcvt_bf16_f32(float32x4_t __p0) {
+ bfloat16x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __noswap___a32_vcvt_bf16_f32(__rev0);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcvtn_u16_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vcvtn_u16_f16((int8x8_t)__p0, 17);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcvtq_high_bf16_f32(bfloat16x8_t __p0, float32x4_t __p1) {
+ bfloat16x8_t __ret;
+ __ret = vcombine_bf16(__a32_vcvt_bf16_f32(__p1), vget_low_bf16(__p0));
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcvtn_u16_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vcvtn_u16_f16((int8x8_t)__rev0, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcvtq_high_bf16_f32(bfloat16x8_t __p0, float32x4_t __p1) {
+ bfloat16x8_t __ret;
+ bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_bf16(__noswap___a32_vcvt_bf16_f32(__rev1), __noswap_vget_low_bf16(__rev0));
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) int16x8_t vcvtpq_s16_f16(float16x8_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vcvtpq_s16_f16((int8x16_t)__p0, 33);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcvtq_low_bf16_f32(float32x4_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = vcombine_bf16((bfloat16x4_t)(0ULL), __a32_vcvt_bf16_f32(__p0));
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) int16x8_t vcvtpq_s16_f16(float16x8_t __p0) {
- int16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vcvtpq_s16_f16((int8x16_t)__rev0, 33);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcvtq_low_bf16_f32(float32x4_t __p0) {
+ bfloat16x8_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_bf16((bfloat16x4_t)(0ULL), __noswap___a32_vcvt_bf16_f32(__rev0));
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) int16x4_t vcvtp_s16_f16(float16x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vcvtp_s16_f16((int8x8_t)__p0, 1);
+__ai __attribute__((target("bf16,neon"))) poly8x8_t vreinterpret_p8_bf16(bfloat16x4_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) int16x4_t vcvtp_s16_f16(float16x4_t __p0) {
- int16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vcvtp_s16_f16((int8x8_t)__rev0, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) poly64x1_t vreinterpret_p64_bf16(bfloat16x4_t __p0) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcvtpq_u16_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vcvtpq_u16_f16((int8x16_t)__p0, 49);
+__ai __attribute__((target("bf16,neon"))) poly16x4_t vreinterpret_p16_bf16(bfloat16x4_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) uint16x8_t vcvtpq_u16_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vcvtpq_u16_f16((int8x16_t)__rev0, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) poly8x16_t vreinterpretq_p8_bf16(bfloat16x8_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcvtp_u16_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vcvtp_u16_f16((int8x8_t)__p0, 17);
+__ai __attribute__((target("bf16,neon"))) poly64x2_t vreinterpretq_p64_bf16(bfloat16x8_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) uint16x4_t vcvtp_u16_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vcvtp_u16_f16((int8x8_t)__rev0, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) poly16x8_t vreinterpretq_p16_bf16(bfloat16x8_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vextq_f16(__p0, __p1, __p2) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __s1 = __p1; \
- __ret = (float16x8_t) __builtin_neon_vextq_f16((int8x16_t)__s0, (int8x16_t)__s1, __p2, 40); \
- __ret; \
-})
-#else
-#define vextq_f16(__p0, __p1, __p2) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __s1 = __p1; \
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (float16x8_t) __builtin_neon_vextq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 40); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vext_f16(__p0, __p1, __p2) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __s1 = __p1; \
- __ret = (float16x4_t) __builtin_neon_vext_f16((int8x8_t)__s0, (int8x8_t)__s1, __p2, 8); \
- __ret; \
-})
-#else
-#define vext_f16(__p0, __p1, __p2) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __s1 = __p1; \
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (float16x4_t) __builtin_neon_vext_f16((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 8); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vfmaq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vfmaq_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+__ai __attribute__((target("bf16,neon"))) uint8x16_t vreinterpretq_u8_bf16(bfloat16x8_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vfmaq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vfmaq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) uint32x4_t vreinterpretq_u32_bf16(bfloat16x8_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
return __ret;
}
-__ai __attribute__((target("fullfp16"))) float16x8_t __noswap_vfmaq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vfmaq_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+__ai __attribute__((target("bf16,neon"))) uint64x2_t vreinterpretq_u64_bf16(bfloat16x8_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vfma_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vfma_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+__ai __attribute__((target("bf16,neon"))) uint16x8_t vreinterpretq_u16_bf16(bfloat16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vfma_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vfma_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) int8x16_t vreinterpretq_s8_bf16(bfloat16x8_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t)(__p0);
return __ret;
}
-__ai __attribute__((target("fullfp16"))) float16x4_t __noswap_vfma_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vfma_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+__ai __attribute__((target("bf16,neon"))) float32x4_t vreinterpretq_f32_bf16(bfloat16x8_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vfmsq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+__ai __attribute__((target("bf16,neon"))) float16x8_t vreinterpretq_f16_bf16(bfloat16x8_t __p0) {
float16x8_t __ret;
- __ret = vfmaq_f16(__p0, -__p1, __p2);
+ __ret = (float16x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vfmsq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vfmaq_f16(__rev0, -__rev1, __rev2);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) int32x4_t vreinterpretq_s32_bf16(bfloat16x8_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vfms_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- __ret = vfma_f16(__p0, -__p1, __p2);
+__ai __attribute__((target("bf16,neon"))) int64x2_t vreinterpretq_s64_bf16(bfloat16x8_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vfms_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __noswap_vfma_f16(__rev0, -__rev1, __rev2);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) int16x8_t vreinterpretq_s16_bf16(bfloat16x8_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vmaxq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vmaxq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+__ai __attribute__((target("bf16,neon"))) uint8x8_t vreinterpret_u8_bf16(bfloat16x4_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vmaxq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vmaxq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) uint32x2_t vreinterpret_u32_bf16(bfloat16x4_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vmax_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vmax_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+__ai __attribute__((target("bf16,neon"))) uint64x1_t vreinterpret_u64_bf16(bfloat16x4_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vmax_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vmax_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) uint16x4_t vreinterpret_u16_bf16(bfloat16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vminq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vminq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+__ai __attribute__((target("bf16,neon"))) int8x8_t vreinterpret_s8_bf16(bfloat16x4_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vminq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vminq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) float32x2_t vreinterpret_f32_bf16(bfloat16x4_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vmin_f16(float16x4_t __p0, float16x4_t __p1) {
+__ai __attribute__((target("bf16,neon"))) float16x4_t vreinterpret_f16_bf16(bfloat16x4_t __p0) {
float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vmin_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+ __ret = (float16x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vmin_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vmin_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) int32x2_t vreinterpret_s32_bf16(bfloat16x4_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vmulq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = __p0 * __p1;
+__ai __attribute__((target("bf16,neon"))) int64x1_t vreinterpret_s64_bf16(bfloat16x4_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vmulq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 * __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) int16x4_t vreinterpret_s16_bf16(bfloat16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vmul_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = __p0 * __p1;
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_p8(poly8x16_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vmul_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 * __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_p64(poly64x2_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vmulq_lane_f16(__p0_153, __p1_153, __p2_153) __extension__ ({ \
- float16x8_t __ret_153; \
- float16x8_t __s0_153 = __p0_153; \
- float16x4_t __s1_153 = __p1_153; \
- __ret_153 = __s0_153 * splatq_lane_f16(__s1_153, __p2_153); \
- __ret_153; \
-})
-#else
-#define vmulq_lane_f16(__p0_154, __p1_154, __p2_154) __extension__ ({ \
- float16x8_t __ret_154; \
- float16x8_t __s0_154 = __p0_154; \
- float16x4_t __s1_154 = __p1_154; \
- float16x8_t __rev0_154; __rev0_154 = __builtin_shufflevector(__s0_154, __s0_154, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x4_t __rev1_154; __rev1_154 = __builtin_shufflevector(__s1_154, __s1_154, 3, 2, 1, 0); \
- __ret_154 = __rev0_154 * __noswap_splatq_lane_f16(__rev1_154, __p2_154); \
- __ret_154 = __builtin_shufflevector(__ret_154, __ret_154, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_154; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vmul_lane_f16(__p0_155, __p1_155, __p2_155) __extension__ ({ \
- float16x4_t __ret_155; \
- float16x4_t __s0_155 = __p0_155; \
- float16x4_t __s1_155 = __p1_155; \
- __ret_155 = __s0_155 * splat_lane_f16(__s1_155, __p2_155); \
- __ret_155; \
-})
-#else
-#define vmul_lane_f16(__p0_156, __p1_156, __p2_156) __extension__ ({ \
- float16x4_t __ret_156; \
- float16x4_t __s0_156 = __p0_156; \
- float16x4_t __s1_156 = __p1_156; \
- float16x4_t __rev0_156; __rev0_156 = __builtin_shufflevector(__s0_156, __s0_156, 3, 2, 1, 0); \
- float16x4_t __rev1_156; __rev1_156 = __builtin_shufflevector(__s1_156, __s1_156, 3, 2, 1, 0); \
- __ret_156 = __rev0_156 * __noswap_splat_lane_f16(__rev1_156, __p2_156); \
- __ret_156 = __builtin_shufflevector(__ret_156, __ret_156, 3, 2, 1, 0); \
- __ret_156; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vmulq_n_f16(__p0, __p1) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16_t __s1 = __p1; \
- __ret = __s0 * (float16x8_t) {__s1, __s1, __s1, __s1, __s1, __s1, __s1, __s1}; \
- __ret; \
-})
-#else
-#define vmulq_n_f16(__p0, __p1) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16_t __s1 = __p1; \
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = __rev0 * (float16x8_t) {__s1, __s1, __s1, __s1, __s1, __s1, __s1, __s1}; \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vmul_n_f16(__p0, __p1) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16_t __s1 = __p1; \
- __ret = __s0 * (float16x4_t) {__s1, __s1, __s1, __s1}; \
- __ret; \
-})
-#else
-#define vmul_n_f16(__p0, __p1) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16_t __s1 = __p1; \
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = __rev0 * (float16x4_t) {__s1, __s1, __s1, __s1}; \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vnegq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- __ret = -__p0;
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_p16(poly16x8_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vnegq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = -__rev0;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_u8(uint8x16_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vneg_f16(float16x4_t __p0) {
- float16x4_t __ret;
- __ret = -__p0;
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_u32(uint32x4_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vneg_f16(float16x4_t __p0) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = -__rev0;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_u64(uint64x2_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vpadd_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vpadd_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_u16(uint16x8_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vpadd_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vpadd_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_s8(int8x16_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vpmax_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vpmax_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_f32(float32x4_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vpmax_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vpmax_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_f16(float16x8_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vpmin_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vpmin_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_s32(int32x4_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vpmin_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vpmin_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_s64(int64x2_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vrecpeq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vrecpeq_f16((int8x16_t)__p0, 40);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_s16(int16x8_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vrecpeq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vrecpeq_f16((int8x16_t)__rev0, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_p8(poly8x8_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vrecpe_f16(float16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vrecpe_f16((int8x8_t)__p0, 8);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_p64(poly64x1_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vrecpe_f16(float16x4_t __p0) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vrecpe_f16((int8x8_t)__rev0, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_p16(poly16x4_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vrecpsq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vrecpsq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_u8(uint8x8_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vrecpsq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vrecpsq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_u32(uint32x2_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vrecps_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vrecps_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_u64(uint64x1_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vrecps_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vrecps_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_u16(uint16x4_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vrev64q_f16(float16x8_t __p0) {
- float16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_s8(int8x8_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vrev64q_f16(float16x8_t __p0) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_f32(float32x2_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vrev64_f16(float16x4_t __p0) {
- float16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_f16(float16x4_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vrev64_f16(float16x4_t __p0) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_s32(int32x2_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vrsqrteq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vrsqrteq_f16((int8x16_t)__p0, 40);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_s64(int64x1_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vrsqrteq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vrsqrteq_f16((int8x16_t)__rev0, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_s16(int16x4_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulhq_lane_s32(__p0_214, __p1_214, __p2_214) __extension__ ({ \
+ int32x4_t __ret_214; \
+ int32x4_t __s0_214 = __p0_214; \
+ int32x2_t __s1_214 = __p1_214; \
+ __ret_214 = vqdmulhq_s32(__s0_214, splatq_lane_s32(__s1_214, __p2_214)); \
+ __ret_214; \
+})
+#else
+#define vqdmulhq_lane_s32(__p0_215, __p1_215, __p2_215) __extension__ ({ \
+ int32x4_t __ret_215; \
+ int32x4_t __s0_215 = __p0_215; \
+ int32x2_t __s1_215 = __p1_215; \
+ int32x4_t __rev0_215; __rev0_215 = __builtin_shufflevector(__s0_215, __s0_215, 3, 2, 1, 0); \
+ int32x2_t __rev1_215; __rev1_215 = __builtin_shufflevector(__s1_215, __s1_215, 1, 0); \
+ __ret_215 = __noswap_vqdmulhq_s32(__rev0_215, __noswap_splatq_lane_s32(__rev1_215, __p2_215)); \
+ __ret_215 = __builtin_shufflevector(__ret_215, __ret_215, 3, 2, 1, 0); \
+ __ret_215; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vrsqrte_f16(float16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vrsqrte_f16((int8x8_t)__p0, 8);
- return __ret;
-}
+#define vqdmulhq_lane_s16(__p0_216, __p1_216, __p2_216) __extension__ ({ \
+ int16x8_t __ret_216; \
+ int16x8_t __s0_216 = __p0_216; \
+ int16x4_t __s1_216 = __p1_216; \
+ __ret_216 = vqdmulhq_s16(__s0_216, splatq_lane_s16(__s1_216, __p2_216)); \
+ __ret_216; \
+})
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vrsqrte_f16(float16x4_t __p0) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vrsqrte_f16((int8x8_t)__rev0, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vqdmulhq_lane_s16(__p0_217, __p1_217, __p2_217) __extension__ ({ \
+ int16x8_t __ret_217; \
+ int16x8_t __s0_217 = __p0_217; \
+ int16x4_t __s1_217 = __p1_217; \
+ int16x8_t __rev0_217; __rev0_217 = __builtin_shufflevector(__s0_217, __s0_217, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x4_t __rev1_217; __rev1_217 = __builtin_shufflevector(__s1_217, __s1_217, 3, 2, 1, 0); \
+ __ret_217 = __noswap_vqdmulhq_s16(__rev0_217, __noswap_splatq_lane_s16(__rev1_217, __p2_217)); \
+ __ret_217 = __builtin_shufflevector(__ret_217, __ret_217, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_217; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vrsqrtsq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vrsqrtsq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
- return __ret;
-}
+#define vqdmulh_lane_s32(__p0_218, __p1_218, __p2_218) __extension__ ({ \
+ int32x2_t __ret_218; \
+ int32x2_t __s0_218 = __p0_218; \
+ int32x2_t __s1_218 = __p1_218; \
+ __ret_218 = vqdmulh_s32(__s0_218, splat_lane_s32(__s1_218, __p2_218)); \
+ __ret_218; \
+})
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vrsqrtsq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vrsqrtsq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqdmulh_lane_s32(__p0_219, __p1_219, __p2_219) __extension__ ({ \
+ int32x2_t __ret_219; \
+ int32x2_t __s0_219 = __p0_219; \
+ int32x2_t __s1_219 = __p1_219; \
+ int32x2_t __rev0_219; __rev0_219 = __builtin_shufflevector(__s0_219, __s0_219, 1, 0); \
+ int32x2_t __rev1_219; __rev1_219 = __builtin_shufflevector(__s1_219, __s1_219, 1, 0); \
+ __ret_219 = __noswap_vqdmulh_s32(__rev0_219, __noswap_splat_lane_s32(__rev1_219, __p2_219)); \
+ __ret_219 = __builtin_shufflevector(__ret_219, __ret_219, 1, 0); \
+ __ret_219; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vrsqrts_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vrsqrts_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
- return __ret;
-}
+#define vqdmulh_lane_s16(__p0_220, __p1_220, __p2_220) __extension__ ({ \
+ int16x4_t __ret_220; \
+ int16x4_t __s0_220 = __p0_220; \
+ int16x4_t __s1_220 = __p1_220; \
+ __ret_220 = vqdmulh_s16(__s0_220, splat_lane_s16(__s1_220, __p2_220)); \
+ __ret_220; \
+})
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vrsqrts_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vrsqrts_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vqdmulh_lane_s16(__p0_221, __p1_221, __p2_221) __extension__ ({ \
+ int16x4_t __ret_221; \
+ int16x4_t __s0_221 = __p0_221; \
+ int16x4_t __s1_221 = __p1_221; \
+ int16x4_t __rev0_221; __rev0_221 = __builtin_shufflevector(__s0_221, __s0_221, 3, 2, 1, 0); \
+ int16x4_t __rev1_221; __rev1_221 = __builtin_shufflevector(__s1_221, __s1_221, 3, 2, 1, 0); \
+ __ret_221 = __noswap_vqdmulh_s16(__rev0_221, __noswap_splat_lane_s16(__rev1_221, __p2_221)); \
+ __ret_221 = __builtin_shufflevector(__ret_221, __ret_221, 3, 2, 1, 0); \
+ __ret_221; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vsubq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
+#define vqrdmulhq_lane_s32(__p0_222, __p1_222, __p2_222) __extension__ ({ \
+ int32x4_t __ret_222; \
+ int32x4_t __s0_222 = __p0_222; \
+ int32x2_t __s1_222 = __p1_222; \
+ __ret_222 = vqrdmulhq_s32(__s0_222, splatq_lane_s32(__s1_222, __p2_222)); \
+ __ret_222; \
+})
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vsubq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrdmulhq_lane_s32(__p0_223, __p1_223, __p2_223) __extension__ ({ \
+ int32x4_t __ret_223; \
+ int32x4_t __s0_223 = __p0_223; \
+ int32x2_t __s1_223 = __p1_223; \
+ int32x4_t __rev0_223; __rev0_223 = __builtin_shufflevector(__s0_223, __s0_223, 3, 2, 1, 0); \
+ int32x2_t __rev1_223; __rev1_223 = __builtin_shufflevector(__s1_223, __s1_223, 1, 0); \
+ __ret_223 = __noswap_vqrdmulhq_s32(__rev0_223, __noswap_splatq_lane_s32(__rev1_223, __p2_223)); \
+ __ret_223 = __builtin_shufflevector(__ret_223, __ret_223, 3, 2, 1, 0); \
+ __ret_223; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vsub_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = __p0 - __p1;
- return __ret;
-}
+#define vqrdmulhq_lane_s16(__p0_224, __p1_224, __p2_224) __extension__ ({ \
+ int16x8_t __ret_224; \
+ int16x8_t __s0_224 = __p0_224; \
+ int16x4_t __s1_224 = __p1_224; \
+ __ret_224 = vqrdmulhq_s16(__s0_224, splatq_lane_s16(__s1_224, __p2_224)); \
+ __ret_224; \
+})
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vsub_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrdmulhq_lane_s16(__p0_225, __p1_225, __p2_225) __extension__ ({ \
+ int16x8_t __ret_225; \
+ int16x8_t __s0_225 = __p0_225; \
+ int16x4_t __s1_225 = __p1_225; \
+ int16x8_t __rev0_225; __rev0_225 = __builtin_shufflevector(__s0_225, __s0_225, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x4_t __rev1_225; __rev1_225 = __builtin_shufflevector(__s1_225, __s1_225, 3, 2, 1, 0); \
+ __ret_225 = __noswap_vqrdmulhq_s16(__rev0_225, __noswap_splatq_lane_s16(__rev1_225, __p2_225)); \
+ __ret_225 = __builtin_shufflevector(__ret_225, __ret_225, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_225; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8x2_t vtrnq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8x2_t __ret;
- __builtin_neon_vtrnq_f16(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 40);
- return __ret;
-}
+#define vqrdmulh_lane_s32(__p0_226, __p1_226, __p2_226) __extension__ ({ \
+ int32x2_t __ret_226; \
+ int32x2_t __s0_226 = __p0_226; \
+ int32x2_t __s1_226 = __p1_226; \
+ __ret_226 = vqrdmulh_s32(__s0_226, splat_lane_s32(__s1_226, __p2_226)); \
+ __ret_226; \
+})
#else
-__ai __attribute__((target("fullfp16"))) float16x8x2_t vtrnq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8x2_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vtrnq_f16(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 40);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrdmulh_lane_s32(__p0_227, __p1_227, __p2_227) __extension__ ({ \
+ int32x2_t __ret_227; \
+ int32x2_t __s0_227 = __p0_227; \
+ int32x2_t __s1_227 = __p1_227; \
+ int32x2_t __rev0_227; __rev0_227 = __builtin_shufflevector(__s0_227, __s0_227, 1, 0); \
+ int32x2_t __rev1_227; __rev1_227 = __builtin_shufflevector(__s1_227, __s1_227, 1, 0); \
+ __ret_227 = __noswap_vqrdmulh_s32(__rev0_227, __noswap_splat_lane_s32(__rev1_227, __p2_227)); \
+ __ret_227 = __builtin_shufflevector(__ret_227, __ret_227, 1, 0); \
+ __ret_227; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4x2_t vtrn_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4x2_t __ret;
- __builtin_neon_vtrn_f16(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 8);
- return __ret;
-}
+#define vqrdmulh_lane_s16(__p0_228, __p1_228, __p2_228) __extension__ ({ \
+ int16x4_t __ret_228; \
+ int16x4_t __s0_228 = __p0_228; \
+ int16x4_t __s1_228 = __p1_228; \
+ __ret_228 = vqrdmulh_s16(__s0_228, splat_lane_s16(__s1_228, __p2_228)); \
+ __ret_228; \
+})
#else
-__ai __attribute__((target("fullfp16"))) float16x4x2_t vtrn_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4x2_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vtrn_f16(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 8);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
- return __ret;
-}
+#define vqrdmulh_lane_s16(__p0_229, __p1_229, __p2_229) __extension__ ({ \
+ int16x4_t __ret_229; \
+ int16x4_t __s0_229 = __p0_229; \
+ int16x4_t __s1_229 = __p1_229; \
+ int16x4_t __rev0_229; __rev0_229 = __builtin_shufflevector(__s0_229, __s0_229, 3, 2, 1, 0); \
+ int16x4_t __rev1_229; __rev1_229 = __builtin_shufflevector(__s1_229, __s1_229, 3, 2, 1, 0); \
+ __ret_229 = __noswap_vqrdmulh_s16(__rev0_229, __noswap_splat_lane_s16(__rev1_229, __p2_229)); \
+ __ret_229 = __builtin_shufflevector(__ret_229, __ret_229, 3, 2, 1, 0); \
+ __ret_229; \
+})
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8x2_t vuzpq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8x2_t __ret;
- __builtin_neon_vuzpq_f16(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 40);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_p16(poly16x4_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x8x2_t vuzpq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8x2_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vuzpq_f16(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 40);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_u8(uint8x8_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4x2_t vuzp_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4x2_t __ret;
- __builtin_neon_vuzp_f16(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 8);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_u32(uint32x2_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4x2_t vuzp_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4x2_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vuzp_f16(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 8);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_u64(uint64x1_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8x2_t vzipq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8x2_t __ret;
- __builtin_neon_vzipq_f16(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 40);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_u16(uint16x4_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x8x2_t vzipq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8x2_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __builtin_neon_vzipq_f16(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 40);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_s8(int8x8_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4x2_t vzip_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4x2_t __ret;
- __builtin_neon_vzip_f16(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 8);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_f32(float32x2_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4x2_t vzip_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4x2_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __builtin_neon_vzip_f16(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 8);
-
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_f16(float16x4_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("i8mm"))) uint32x4_t vmmlaq_u32(uint32x4_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vmmlaq_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_s32(int32x2_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("i8mm"))) uint32x4_t vmmlaq_u32(uint32x4_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vmmlaq_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_s64(int64x1_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("i8mm"))) int32x4_t vmmlaq_s32(int32x4_t __p0, int8x16_t __p1, int8x16_t __p2) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vmmlaq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_s16(int16x4_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("i8mm"))) int32x4_t vmmlaq_s32(int32x4_t __p0, int8x16_t __p1, int8x16_t __p2) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vmmlaq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_p8(poly8x8_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("i8mm"))) int32x4_t vusdotq_s32(int32x4_t __p0, uint8x16_t __p1, int8x16_t __p2) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vusdotq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_u8(uint8x8_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("i8mm"))) int32x4_t vusdotq_s32(int32x4_t __p0, uint8x16_t __p1, int8x16_t __p2) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vusdotq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_u32(uint32x2_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-__ai __attribute__((target("i8mm"))) int32x4_t __noswap_vusdotq_s32(int32x4_t __p0, uint8x16_t __p1, int8x16_t __p2) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vusdotq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_u64(uint64x1_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("i8mm"))) int32x2_t vusdot_s32(int32x2_t __p0, uint8x8_t __p1, int8x8_t __p2) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vusdot_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_u16(uint16x4_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("i8mm"))) int32x2_t vusdot_s32(int32x2_t __p0, uint8x8_t __p1, int8x8_t __p2) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vusdot_s32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_s8(int8x8_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-__ai __attribute__((target("i8mm"))) int32x2_t __noswap_vusdot_s32(int32x2_t __p0, uint8x8_t __p1, int8x8_t __p2) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vusdot_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_f32(float32x2_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vusdotq_lane_s32(__p0_157, __p1_157, __p2_157, __p3_157) __extension__ ({ \
- int32x4_t __ret_157; \
- int32x4_t __s0_157 = __p0_157; \
- uint8x16_t __s1_157 = __p1_157; \
- int8x8_t __s2_157 = __p2_157; \
-int8x8_t __reint_157 = __s2_157; \
- __ret_157 = vusdotq_s32(__s0_157, __s1_157, (int8x16_t)(splatq_lane_s32(*(int32x2_t *) &__reint_157, __p3_157))); \
- __ret_157; \
-})
-#else
-#define vusdotq_lane_s32(__p0_158, __p1_158, __p2_158, __p3_158) __extension__ ({ \
- int32x4_t __ret_158; \
- int32x4_t __s0_158 = __p0_158; \
- uint8x16_t __s1_158 = __p1_158; \
- int8x8_t __s2_158 = __p2_158; \
- int32x4_t __rev0_158; __rev0_158 = __builtin_shufflevector(__s0_158, __s0_158, 3, 2, 1, 0); \
- uint8x16_t __rev1_158; __rev1_158 = __builtin_shufflevector(__s1_158, __s1_158, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- int8x8_t __rev2_158; __rev2_158 = __builtin_shufflevector(__s2_158, __s2_158, 7, 6, 5, 4, 3, 2, 1, 0); \
-int8x8_t __reint_158 = __rev2_158; \
- __ret_158 = __noswap_vusdotq_s32(__rev0_158, __rev1_158, (int8x16_t)(__noswap_splatq_lane_s32(*(int32x2_t *) &__reint_158, __p3_158))); \
- __ret_158 = __builtin_shufflevector(__ret_158, __ret_158, 3, 2, 1, 0); \
- __ret_158; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vusdot_lane_s32(__p0_159, __p1_159, __p2_159, __p3_159) __extension__ ({ \
- int32x2_t __ret_159; \
- int32x2_t __s0_159 = __p0_159; \
- uint8x8_t __s1_159 = __p1_159; \
- int8x8_t __s2_159 = __p2_159; \
-int8x8_t __reint_159 = __s2_159; \
- __ret_159 = vusdot_s32(__s0_159, __s1_159, (int8x8_t)(splat_lane_s32(*(int32x2_t *) &__reint_159, __p3_159))); \
- __ret_159; \
-})
-#else
-#define vusdot_lane_s32(__p0_160, __p1_160, __p2_160, __p3_160) __extension__ ({ \
- int32x2_t __ret_160; \
- int32x2_t __s0_160 = __p0_160; \
- uint8x8_t __s1_160 = __p1_160; \
- int8x8_t __s2_160 = __p2_160; \
- int32x2_t __rev0_160; __rev0_160 = __builtin_shufflevector(__s0_160, __s0_160, 1, 0); \
- uint8x8_t __rev1_160; __rev1_160 = __builtin_shufflevector(__s1_160, __s1_160, 7, 6, 5, 4, 3, 2, 1, 0); \
- int8x8_t __rev2_160; __rev2_160 = __builtin_shufflevector(__s2_160, __s2_160, 7, 6, 5, 4, 3, 2, 1, 0); \
-int8x8_t __reint_160 = __rev2_160; \
- __ret_160 = __noswap_vusdot_s32(__rev0_160, __rev1_160, (int8x8_t)(__noswap_splat_lane_s32(*(int32x2_t *) &__reint_160, __p3_160))); \
- __ret_160 = __builtin_shufflevector(__ret_160, __ret_160, 1, 0); \
- __ret_160; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("i8mm"))) int32x4_t vusmmlaq_s32(int32x4_t __p0, uint8x16_t __p1, int8x16_t __p2) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vusmmlaq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_f16(float16x4_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("i8mm"))) int32x4_t vusmmlaq_s32(int32x4_t __p0, uint8x16_t __p1, int8x16_t __p2) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vusmmlaq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_s32(int32x2_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.1a"))) int32x4_t vqrdmlahq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqrdmlahq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_s64(int64x1_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.1a"))) int32x4_t vqrdmlahq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vqrdmlahq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_s16(int16x4_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.1a"))) int32x4_t __noswap_vqrdmlahq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqrdmlahq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_p16(poly16x8_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.1a"))) int16x8_t vqrdmlahq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vqrdmlahq_s16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_u8(uint8x16_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.1a"))) int16x8_t vqrdmlahq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vqrdmlahq_s16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_u32(uint32x4_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.1a"))) int16x8_t __noswap_vqrdmlahq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vqrdmlahq_s16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_u64(uint64x2_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.1a"))) int32x2_t vqrdmlah_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vqrdmlah_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_u16(uint16x8_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.1a"))) int32x2_t vqrdmlah_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- int32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vqrdmlah_s32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_s8(int8x16_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.1a"))) int32x2_t __noswap_vqrdmlah_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vqrdmlah_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_f32(float32x4_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.1a"))) int16x4_t vqrdmlah_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vqrdmlah_s16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 1);
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_f16(float16x8_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.1a"))) int16x4_t vqrdmlah_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- int16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vqrdmlah_s16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_s32(int32x4_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.1a"))) int16x4_t __noswap_vqrdmlah_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vqrdmlah_s16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 1);
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_s64(int64x2_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vqrdmlahq_lane_s32(__p0_161, __p1_161, __p2_161, __p3_161) __extension__ ({ \
- int32x4_t __ret_161; \
- int32x4_t __s0_161 = __p0_161; \
- int32x4_t __s1_161 = __p1_161; \
- int32x2_t __s2_161 = __p2_161; \
- __ret_161 = vqrdmlahq_s32(__s0_161, __s1_161, splatq_lane_s32(__s2_161, __p3_161)); \
- __ret_161; \
-})
-#else
-#define vqrdmlahq_lane_s32(__p0_162, __p1_162, __p2_162, __p3_162) __extension__ ({ \
- int32x4_t __ret_162; \
- int32x4_t __s0_162 = __p0_162; \
- int32x4_t __s1_162 = __p1_162; \
- int32x2_t __s2_162 = __p2_162; \
- int32x4_t __rev0_162; __rev0_162 = __builtin_shufflevector(__s0_162, __s0_162, 3, 2, 1, 0); \
- int32x4_t __rev1_162; __rev1_162 = __builtin_shufflevector(__s1_162, __s1_162, 3, 2, 1, 0); \
- int32x2_t __rev2_162; __rev2_162 = __builtin_shufflevector(__s2_162, __s2_162, 1, 0); \
- __ret_162 = __noswap_vqrdmlahq_s32(__rev0_162, __rev1_162, __noswap_splatq_lane_s32(__rev2_162, __p3_162)); \
- __ret_162 = __builtin_shufflevector(__ret_162, __ret_162, 3, 2, 1, 0); \
- __ret_162; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vqrdmlahq_lane_s16(__p0_163, __p1_163, __p2_163, __p3_163) __extension__ ({ \
- int16x8_t __ret_163; \
- int16x8_t __s0_163 = __p0_163; \
- int16x8_t __s1_163 = __p1_163; \
- int16x4_t __s2_163 = __p2_163; \
- __ret_163 = vqrdmlahq_s16(__s0_163, __s1_163, splatq_lane_s16(__s2_163, __p3_163)); \
- __ret_163; \
-})
-#else
-#define vqrdmlahq_lane_s16(__p0_164, __p1_164, __p2_164, __p3_164) __extension__ ({ \
- int16x8_t __ret_164; \
- int16x8_t __s0_164 = __p0_164; \
- int16x8_t __s1_164 = __p1_164; \
- int16x4_t __s2_164 = __p2_164; \
- int16x8_t __rev0_164; __rev0_164 = __builtin_shufflevector(__s0_164, __s0_164, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1_164; __rev1_164 = __builtin_shufflevector(__s1_164, __s1_164, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x4_t __rev2_164; __rev2_164 = __builtin_shufflevector(__s2_164, __s2_164, 3, 2, 1, 0); \
- __ret_164 = __noswap_vqrdmlahq_s16(__rev0_164, __rev1_164, __noswap_splatq_lane_s16(__rev2_164, __p3_164)); \
- __ret_164 = __builtin_shufflevector(__ret_164, __ret_164, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_164; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vqrdmlah_lane_s32(__p0_165, __p1_165, __p2_165, __p3_165) __extension__ ({ \
- int32x2_t __ret_165; \
- int32x2_t __s0_165 = __p0_165; \
- int32x2_t __s1_165 = __p1_165; \
- int32x2_t __s2_165 = __p2_165; \
- __ret_165 = vqrdmlah_s32(__s0_165, __s1_165, splat_lane_s32(__s2_165, __p3_165)); \
- __ret_165; \
-})
-#else
-#define vqrdmlah_lane_s32(__p0_166, __p1_166, __p2_166, __p3_166) __extension__ ({ \
- int32x2_t __ret_166; \
- int32x2_t __s0_166 = __p0_166; \
- int32x2_t __s1_166 = __p1_166; \
- int32x2_t __s2_166 = __p2_166; \
- int32x2_t __rev0_166; __rev0_166 = __builtin_shufflevector(__s0_166, __s0_166, 1, 0); \
- int32x2_t __rev1_166; __rev1_166 = __builtin_shufflevector(__s1_166, __s1_166, 1, 0); \
- int32x2_t __rev2_166; __rev2_166 = __builtin_shufflevector(__s2_166, __s2_166, 1, 0); \
- __ret_166 = __noswap_vqrdmlah_s32(__rev0_166, __rev1_166, __noswap_splat_lane_s32(__rev2_166, __p3_166)); \
- __ret_166 = __builtin_shufflevector(__ret_166, __ret_166, 1, 0); \
- __ret_166; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vqrdmlah_lane_s16(__p0_167, __p1_167, __p2_167, __p3_167) __extension__ ({ \
- int16x4_t __ret_167; \
- int16x4_t __s0_167 = __p0_167; \
- int16x4_t __s1_167 = __p1_167; \
- int16x4_t __s2_167 = __p2_167; \
- __ret_167 = vqrdmlah_s16(__s0_167, __s1_167, splat_lane_s16(__s2_167, __p3_167)); \
- __ret_167; \
-})
-#else
-#define vqrdmlah_lane_s16(__p0_168, __p1_168, __p2_168, __p3_168) __extension__ ({ \
- int16x4_t __ret_168; \
- int16x4_t __s0_168 = __p0_168; \
- int16x4_t __s1_168 = __p1_168; \
- int16x4_t __s2_168 = __p2_168; \
- int16x4_t __rev0_168; __rev0_168 = __builtin_shufflevector(__s0_168, __s0_168, 3, 2, 1, 0); \
- int16x4_t __rev1_168; __rev1_168 = __builtin_shufflevector(__s1_168, __s1_168, 3, 2, 1, 0); \
- int16x4_t __rev2_168; __rev2_168 = __builtin_shufflevector(__s2_168, __s2_168, 3, 2, 1, 0); \
- __ret_168 = __noswap_vqrdmlah_s16(__rev0_168, __rev1_168, __noswap_splat_lane_s16(__rev2_168, __p3_168)); \
- __ret_168 = __builtin_shufflevector(__ret_168, __ret_168, 3, 2, 1, 0); \
- __ret_168; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.1a"))) int32x4_t vqrdmlshq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqrdmlshq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_s16(int16x8_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.1a"))) int32x4_t vqrdmlshq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vqrdmlshq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_p8(poly8x16_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.1a"))) int32x4_t __noswap_vqrdmlshq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vqrdmlshq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_u8(uint8x16_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.1a"))) int16x8_t vqrdmlshq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vqrdmlshq_s16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_u32(uint32x4_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.1a"))) int16x8_t vqrdmlshq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vqrdmlshq_s16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_u64(uint64x2_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.1a"))) int16x8_t __noswap_vqrdmlshq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vqrdmlshq_s16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_u16(uint16x8_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.1a"))) int32x2_t vqrdmlsh_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vqrdmlsh_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_s8(int8x16_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.1a"))) int32x2_t vqrdmlsh_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- int32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vqrdmlsh_s32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_f32(float32x4_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.1a"))) int32x2_t __noswap_vqrdmlsh_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vqrdmlsh_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_f16(float16x8_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.1a"))) int16x4_t vqrdmlsh_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vqrdmlsh_s16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 1);
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_s32(int32x4_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.1a"))) int16x4_t vqrdmlsh_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- int16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vqrdmlsh_s16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_s64(int64x2_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.1a"))) int16x4_t __noswap_vqrdmlsh_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vqrdmlsh_s16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 1);
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_s16(int16x8_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vqrdmlshq_lane_s32(__p0_169, __p1_169, __p2_169, __p3_169) __extension__ ({ \
- int32x4_t __ret_169; \
- int32x4_t __s0_169 = __p0_169; \
- int32x4_t __s1_169 = __p1_169; \
- int32x2_t __s2_169 = __p2_169; \
- __ret_169 = vqrdmlshq_s32(__s0_169, __s1_169, splatq_lane_s32(__s2_169, __p3_169)); \
- __ret_169; \
-})
-#else
-#define vqrdmlshq_lane_s32(__p0_170, __p1_170, __p2_170, __p3_170) __extension__ ({ \
- int32x4_t __ret_170; \
- int32x4_t __s0_170 = __p0_170; \
- int32x4_t __s1_170 = __p1_170; \
- int32x2_t __s2_170 = __p2_170; \
- int32x4_t __rev0_170; __rev0_170 = __builtin_shufflevector(__s0_170, __s0_170, 3, 2, 1, 0); \
- int32x4_t __rev1_170; __rev1_170 = __builtin_shufflevector(__s1_170, __s1_170, 3, 2, 1, 0); \
- int32x2_t __rev2_170; __rev2_170 = __builtin_shufflevector(__s2_170, __s2_170, 1, 0); \
- __ret_170 = __noswap_vqrdmlshq_s32(__rev0_170, __rev1_170, __noswap_splatq_lane_s32(__rev2_170, __p3_170)); \
- __ret_170 = __builtin_shufflevector(__ret_170, __ret_170, 3, 2, 1, 0); \
- __ret_170; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vqrdmlshq_lane_s16(__p0_171, __p1_171, __p2_171, __p3_171) __extension__ ({ \
- int16x8_t __ret_171; \
- int16x8_t __s0_171 = __p0_171; \
- int16x8_t __s1_171 = __p1_171; \
- int16x4_t __s2_171 = __p2_171; \
- __ret_171 = vqrdmlshq_s16(__s0_171, __s1_171, splatq_lane_s16(__s2_171, __p3_171)); \
- __ret_171; \
-})
-#else
-#define vqrdmlshq_lane_s16(__p0_172, __p1_172, __p2_172, __p3_172) __extension__ ({ \
- int16x8_t __ret_172; \
- int16x8_t __s0_172 = __p0_172; \
- int16x8_t __s1_172 = __p1_172; \
- int16x4_t __s2_172 = __p2_172; \
- int16x8_t __rev0_172; __rev0_172 = __builtin_shufflevector(__s0_172, __s0_172, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1_172; __rev1_172 = __builtin_shufflevector(__s1_172, __s1_172, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x4_t __rev2_172; __rev2_172 = __builtin_shufflevector(__s2_172, __s2_172, 3, 2, 1, 0); \
- __ret_172 = __noswap_vqrdmlshq_s16(__rev0_172, __rev1_172, __noswap_splatq_lane_s16(__rev2_172, __p3_172)); \
- __ret_172 = __builtin_shufflevector(__ret_172, __ret_172, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_172; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vqrdmlsh_lane_s32(__p0_173, __p1_173, __p2_173, __p3_173) __extension__ ({ \
- int32x2_t __ret_173; \
- int32x2_t __s0_173 = __p0_173; \
- int32x2_t __s1_173 = __p1_173; \
- int32x2_t __s2_173 = __p2_173; \
- __ret_173 = vqrdmlsh_s32(__s0_173, __s1_173, splat_lane_s32(__s2_173, __p3_173)); \
- __ret_173; \
-})
-#else
-#define vqrdmlsh_lane_s32(__p0_174, __p1_174, __p2_174, __p3_174) __extension__ ({ \
- int32x2_t __ret_174; \
- int32x2_t __s0_174 = __p0_174; \
- int32x2_t __s1_174 = __p1_174; \
- int32x2_t __s2_174 = __p2_174; \
- int32x2_t __rev0_174; __rev0_174 = __builtin_shufflevector(__s0_174, __s0_174, 1, 0); \
- int32x2_t __rev1_174; __rev1_174 = __builtin_shufflevector(__s1_174, __s1_174, 1, 0); \
- int32x2_t __rev2_174; __rev2_174 = __builtin_shufflevector(__s2_174, __s2_174, 1, 0); \
- __ret_174 = __noswap_vqrdmlsh_s32(__rev0_174, __rev1_174, __noswap_splat_lane_s32(__rev2_174, __p3_174)); \
- __ret_174 = __builtin_shufflevector(__ret_174, __ret_174, 1, 0); \
- __ret_174; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vqrdmlsh_lane_s16(__p0_175, __p1_175, __p2_175, __p3_175) __extension__ ({ \
- int16x4_t __ret_175; \
- int16x4_t __s0_175 = __p0_175; \
- int16x4_t __s1_175 = __p1_175; \
- int16x4_t __s2_175 = __p2_175; \
- __ret_175 = vqrdmlsh_s16(__s0_175, __s1_175, splat_lane_s16(__s2_175, __p3_175)); \
- __ret_175; \
-})
-#else
-#define vqrdmlsh_lane_s16(__p0_176, __p1_176, __p2_176, __p3_176) __extension__ ({ \
- int16x4_t __ret_176; \
- int16x4_t __s0_176 = __p0_176; \
- int16x4_t __s1_176 = __p1_176; \
- int16x4_t __s2_176 = __p2_176; \
- int16x4_t __rev0_176; __rev0_176 = __builtin_shufflevector(__s0_176, __s0_176, 3, 2, 1, 0); \
- int16x4_t __rev1_176; __rev1_176 = __builtin_shufflevector(__s1_176, __s1_176, 3, 2, 1, 0); \
- int16x4_t __rev2_176; __rev2_176 = __builtin_shufflevector(__s2_176, __s2_176, 3, 2, 1, 0); \
- __ret_176 = __noswap_vqrdmlsh_s16(__rev0_176, __rev1_176, __noswap_splat_lane_s16(__rev2_176, __p3_176)); \
- __ret_176 = __builtin_shufflevector(__ret_176, __ret_176, 3, 2, 1, 0); \
- __ret_176; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a"))) float32x2_t vcadd_rot270_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vcadd_rot270_f32((int8x8_t)__p0, (int8x8_t)__p1, 9);
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_p8(poly8x16_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a"))) float32x2_t vcadd_rot270_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vcadd_rot270_f32((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_p16(poly16x8_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a"))) float32x2_t vcadd_rot90_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vcadd_rot90_f32((int8x8_t)__p0, (int8x8_t)__p1, 9);
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_u32(uint32x4_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a"))) float32x2_t vcadd_rot90_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vcadd_rot90_f32((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_u64(uint64x2_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a"))) float32x4_t vcaddq_rot270_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vcaddq_rot270_f32((int8x16_t)__p0, (int8x16_t)__p1, 41);
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_u16(uint16x8_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a"))) float32x4_t vcaddq_rot270_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vcaddq_rot270_f32((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_s8(int8x16_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a"))) float32x4_t vcaddq_rot90_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vcaddq_rot90_f32((int8x16_t)__p0, (int8x16_t)__p1, 41);
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_f32(float32x4_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a"))) float32x4_t vcaddq_rot90_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vcaddq_rot90_f32((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_f16(float16x8_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a"))) float32x4_t vcmlaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vcmlaq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_s32(int32x4_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a"))) float32x4_t vcmlaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- float32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vcmlaq_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_s64(int64x2_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.3a"))) float32x4_t __noswap_vcmlaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vcmlaq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_s16(int16x8_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a"))) float32x2_t vcmla_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vcmla_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_p8(poly8x16_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a"))) float32x2_t vcmla_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- float32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vcmla_f32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_p16(poly16x8_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.3a"))) float32x2_t __noswap_vcmla_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vcmla_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_u8(uint8x16_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmla_lane_f32(__p0_177, __p1_177, __p2_177, __p3_177) __extension__ ({ \
- float32x2_t __ret_177; \
- float32x2_t __s0_177 = __p0_177; \
- float32x2_t __s1_177 = __p1_177; \
- float32x2_t __s2_177 = __p2_177; \
-float32x2_t __reint_177 = __s2_177; \
-uint64x1_t __reint1_177 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_177, __p3_177)}; \
- __ret_177 = vcmla_f32(__s0_177, __s1_177, *(float32x2_t *) &__reint1_177); \
- __ret_177; \
-})
-#else
-#define vcmla_lane_f32(__p0_178, __p1_178, __p2_178, __p3_178) __extension__ ({ \
- float32x2_t __ret_178; \
- float32x2_t __s0_178 = __p0_178; \
- float32x2_t __s1_178 = __p1_178; \
- float32x2_t __s2_178 = __p2_178; \
- float32x2_t __rev0_178; __rev0_178 = __builtin_shufflevector(__s0_178, __s0_178, 1, 0); \
- float32x2_t __rev1_178; __rev1_178 = __builtin_shufflevector(__s1_178, __s1_178, 1, 0); \
- float32x2_t __rev2_178; __rev2_178 = __builtin_shufflevector(__s2_178, __s2_178, 1, 0); \
-float32x2_t __reint_178 = __rev2_178; \
-uint64x1_t __reint1_178 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_178, __p3_178)}; \
- __ret_178 = __noswap_vcmla_f32(__rev0_178, __rev1_178, *(float32x2_t *) &__reint1_178); \
- __ret_178 = __builtin_shufflevector(__ret_178, __ret_178, 1, 0); \
- __ret_178; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_lane_f32(__p0_179, __p1_179, __p2_179, __p3_179) __extension__ ({ \
- float32x4_t __ret_179; \
- float32x4_t __s0_179 = __p0_179; \
- float32x4_t __s1_179 = __p1_179; \
- float32x2_t __s2_179 = __p2_179; \
-float32x2_t __reint_179 = __s2_179; \
-uint64x2_t __reint1_179 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_179, __p3_179), vget_lane_u64(*(uint64x1_t *) &__reint_179, __p3_179)}; \
- __ret_179 = vcmlaq_f32(__s0_179, __s1_179, *(float32x4_t *) &__reint1_179); \
- __ret_179; \
-})
-#else
-#define vcmlaq_lane_f32(__p0_180, __p1_180, __p2_180, __p3_180) __extension__ ({ \
- float32x4_t __ret_180; \
- float32x4_t __s0_180 = __p0_180; \
- float32x4_t __s1_180 = __p1_180; \
- float32x2_t __s2_180 = __p2_180; \
- float32x4_t __rev0_180; __rev0_180 = __builtin_shufflevector(__s0_180, __s0_180, 3, 2, 1, 0); \
- float32x4_t __rev1_180; __rev1_180 = __builtin_shufflevector(__s1_180, __s1_180, 3, 2, 1, 0); \
- float32x2_t __rev2_180; __rev2_180 = __builtin_shufflevector(__s2_180, __s2_180, 1, 0); \
-float32x2_t __reint_180 = __rev2_180; \
-uint64x2_t __reint1_180 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_180, __p3_180), vget_lane_u64(*(uint64x1_t *) &__reint_180, __p3_180)}; \
- __ret_180 = __noswap_vcmlaq_f32(__rev0_180, __rev1_180, *(float32x4_t *) &__reint1_180); \
- __ret_180 = __builtin_shufflevector(__ret_180, __ret_180, 3, 2, 1, 0); \
- __ret_180; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmla_laneq_f32(__p0_181, __p1_181, __p2_181, __p3_181) __extension__ ({ \
- float32x2_t __ret_181; \
- float32x2_t __s0_181 = __p0_181; \
- float32x2_t __s1_181 = __p1_181; \
- float32x4_t __s2_181 = __p2_181; \
-float32x4_t __reint_181 = __s2_181; \
-uint64x1_t __reint1_181 = (uint64x1_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_181, __p3_181)}; \
- __ret_181 = vcmla_f32(__s0_181, __s1_181, *(float32x2_t *) &__reint1_181); \
- __ret_181; \
-})
-#else
-#define vcmla_laneq_f32(__p0_182, __p1_182, __p2_182, __p3_182) __extension__ ({ \
- float32x2_t __ret_182; \
- float32x2_t __s0_182 = __p0_182; \
- float32x2_t __s1_182 = __p1_182; \
- float32x4_t __s2_182 = __p2_182; \
- float32x2_t __rev0_182; __rev0_182 = __builtin_shufflevector(__s0_182, __s0_182, 1, 0); \
- float32x2_t __rev1_182; __rev1_182 = __builtin_shufflevector(__s1_182, __s1_182, 1, 0); \
- float32x4_t __rev2_182; __rev2_182 = __builtin_shufflevector(__s2_182, __s2_182, 3, 2, 1, 0); \
-float32x4_t __reint_182 = __rev2_182; \
-uint64x1_t __reint1_182 = (uint64x1_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_182, __p3_182)}; \
- __ret_182 = __noswap_vcmla_f32(__rev0_182, __rev1_182, *(float32x2_t *) &__reint1_182); \
- __ret_182 = __builtin_shufflevector(__ret_182, __ret_182, 1, 0); \
- __ret_182; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_laneq_f32(__p0_183, __p1_183, __p2_183, __p3_183) __extension__ ({ \
- float32x4_t __ret_183; \
- float32x4_t __s0_183 = __p0_183; \
- float32x4_t __s1_183 = __p1_183; \
- float32x4_t __s2_183 = __p2_183; \
-float32x4_t __reint_183 = __s2_183; \
-uint64x2_t __reint1_183 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_183, __p3_183), vgetq_lane_u64(*(uint64x2_t *) &__reint_183, __p3_183)}; \
- __ret_183 = vcmlaq_f32(__s0_183, __s1_183, *(float32x4_t *) &__reint1_183); \
- __ret_183; \
-})
-#else
-#define vcmlaq_laneq_f32(__p0_184, __p1_184, __p2_184, __p3_184) __extension__ ({ \
- float32x4_t __ret_184; \
- float32x4_t __s0_184 = __p0_184; \
- float32x4_t __s1_184 = __p1_184; \
- float32x4_t __s2_184 = __p2_184; \
- float32x4_t __rev0_184; __rev0_184 = __builtin_shufflevector(__s0_184, __s0_184, 3, 2, 1, 0); \
- float32x4_t __rev1_184; __rev1_184 = __builtin_shufflevector(__s1_184, __s1_184, 3, 2, 1, 0); \
- float32x4_t __rev2_184; __rev2_184 = __builtin_shufflevector(__s2_184, __s2_184, 3, 2, 1, 0); \
-float32x4_t __reint_184 = __rev2_184; \
-uint64x2_t __reint1_184 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_184, __p3_184), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_184, __p3_184)}; \
- __ret_184 = __noswap_vcmlaq_f32(__rev0_184, __rev1_184, *(float32x4_t *) &__reint1_184); \
- __ret_184 = __builtin_shufflevector(__ret_184, __ret_184, 3, 2, 1, 0); \
- __ret_184; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a"))) float32x4_t vcmlaq_rot180_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vcmlaq_rot180_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_u64(uint64x2_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a"))) float32x4_t vcmlaq_rot180_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- float32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vcmlaq_rot180_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_u16(uint16x8_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.3a"))) float32x4_t __noswap_vcmlaq_rot180_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vcmlaq_rot180_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_s8(int8x16_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a"))) float32x2_t vcmla_rot180_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vcmla_rot180_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_f32(float32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a"))) float32x2_t vcmla_rot180_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- float32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vcmla_rot180_f32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_f16(float16x8_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.3a"))) float32x2_t __noswap_vcmla_rot180_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vcmla_rot180_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_s32(int32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmla_rot180_lane_f32(__p0_185, __p1_185, __p2_185, __p3_185) __extension__ ({ \
- float32x2_t __ret_185; \
- float32x2_t __s0_185 = __p0_185; \
- float32x2_t __s1_185 = __p1_185; \
- float32x2_t __s2_185 = __p2_185; \
-float32x2_t __reint_185 = __s2_185; \
-uint64x1_t __reint1_185 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_185, __p3_185)}; \
- __ret_185 = vcmla_rot180_f32(__s0_185, __s1_185, *(float32x2_t *) &__reint1_185); \
- __ret_185; \
-})
-#else
-#define vcmla_rot180_lane_f32(__p0_186, __p1_186, __p2_186, __p3_186) __extension__ ({ \
- float32x2_t __ret_186; \
- float32x2_t __s0_186 = __p0_186; \
- float32x2_t __s1_186 = __p1_186; \
- float32x2_t __s2_186 = __p2_186; \
- float32x2_t __rev0_186; __rev0_186 = __builtin_shufflevector(__s0_186, __s0_186, 1, 0); \
- float32x2_t __rev1_186; __rev1_186 = __builtin_shufflevector(__s1_186, __s1_186, 1, 0); \
- float32x2_t __rev2_186; __rev2_186 = __builtin_shufflevector(__s2_186, __s2_186, 1, 0); \
-float32x2_t __reint_186 = __rev2_186; \
-uint64x1_t __reint1_186 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_186, __p3_186)}; \
- __ret_186 = __noswap_vcmla_rot180_f32(__rev0_186, __rev1_186, *(float32x2_t *) &__reint1_186); \
- __ret_186 = __builtin_shufflevector(__ret_186, __ret_186, 1, 0); \
- __ret_186; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_rot180_lane_f32(__p0_187, __p1_187, __p2_187, __p3_187) __extension__ ({ \
- float32x4_t __ret_187; \
- float32x4_t __s0_187 = __p0_187; \
- float32x4_t __s1_187 = __p1_187; \
- float32x2_t __s2_187 = __p2_187; \
-float32x2_t __reint_187 = __s2_187; \
-uint64x2_t __reint1_187 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_187, __p3_187), vget_lane_u64(*(uint64x1_t *) &__reint_187, __p3_187)}; \
- __ret_187 = vcmlaq_rot180_f32(__s0_187, __s1_187, *(float32x4_t *) &__reint1_187); \
- __ret_187; \
-})
-#else
-#define vcmlaq_rot180_lane_f32(__p0_188, __p1_188, __p2_188, __p3_188) __extension__ ({ \
- float32x4_t __ret_188; \
- float32x4_t __s0_188 = __p0_188; \
- float32x4_t __s1_188 = __p1_188; \
- float32x2_t __s2_188 = __p2_188; \
- float32x4_t __rev0_188; __rev0_188 = __builtin_shufflevector(__s0_188, __s0_188, 3, 2, 1, 0); \
- float32x4_t __rev1_188; __rev1_188 = __builtin_shufflevector(__s1_188, __s1_188, 3, 2, 1, 0); \
- float32x2_t __rev2_188; __rev2_188 = __builtin_shufflevector(__s2_188, __s2_188, 1, 0); \
-float32x2_t __reint_188 = __rev2_188; \
-uint64x2_t __reint1_188 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_188, __p3_188), vget_lane_u64(*(uint64x1_t *) &__reint_188, __p3_188)}; \
- __ret_188 = __noswap_vcmlaq_rot180_f32(__rev0_188, __rev1_188, *(float32x4_t *) &__reint1_188); \
- __ret_188 = __builtin_shufflevector(__ret_188, __ret_188, 3, 2, 1, 0); \
- __ret_188; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmla_rot180_laneq_f32(__p0_189, __p1_189, __p2_189, __p3_189) __extension__ ({ \
- float32x2_t __ret_189; \
- float32x2_t __s0_189 = __p0_189; \
- float32x2_t __s1_189 = __p1_189; \
- float32x4_t __s2_189 = __p2_189; \
-float32x4_t __reint_189 = __s2_189; \
-uint64x1_t __reint1_189 = (uint64x1_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_189, __p3_189)}; \
- __ret_189 = vcmla_rot180_f32(__s0_189, __s1_189, *(float32x2_t *) &__reint1_189); \
- __ret_189; \
-})
-#else
-#define vcmla_rot180_laneq_f32(__p0_190, __p1_190, __p2_190, __p3_190) __extension__ ({ \
- float32x2_t __ret_190; \
- float32x2_t __s0_190 = __p0_190; \
- float32x2_t __s1_190 = __p1_190; \
- float32x4_t __s2_190 = __p2_190; \
- float32x2_t __rev0_190; __rev0_190 = __builtin_shufflevector(__s0_190, __s0_190, 1, 0); \
- float32x2_t __rev1_190; __rev1_190 = __builtin_shufflevector(__s1_190, __s1_190, 1, 0); \
- float32x4_t __rev2_190; __rev2_190 = __builtin_shufflevector(__s2_190, __s2_190, 3, 2, 1, 0); \
-float32x4_t __reint_190 = __rev2_190; \
-uint64x1_t __reint1_190 = (uint64x1_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_190, __p3_190)}; \
- __ret_190 = __noswap_vcmla_rot180_f32(__rev0_190, __rev1_190, *(float32x2_t *) &__reint1_190); \
- __ret_190 = __builtin_shufflevector(__ret_190, __ret_190, 1, 0); \
- __ret_190; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_rot180_laneq_f32(__p0_191, __p1_191, __p2_191, __p3_191) __extension__ ({ \
- float32x4_t __ret_191; \
- float32x4_t __s0_191 = __p0_191; \
- float32x4_t __s1_191 = __p1_191; \
- float32x4_t __s2_191 = __p2_191; \
-float32x4_t __reint_191 = __s2_191; \
-uint64x2_t __reint1_191 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_191, __p3_191), vgetq_lane_u64(*(uint64x2_t *) &__reint_191, __p3_191)}; \
- __ret_191 = vcmlaq_rot180_f32(__s0_191, __s1_191, *(float32x4_t *) &__reint1_191); \
- __ret_191; \
-})
-#else
-#define vcmlaq_rot180_laneq_f32(__p0_192, __p1_192, __p2_192, __p3_192) __extension__ ({ \
- float32x4_t __ret_192; \
- float32x4_t __s0_192 = __p0_192; \
- float32x4_t __s1_192 = __p1_192; \
- float32x4_t __s2_192 = __p2_192; \
- float32x4_t __rev0_192; __rev0_192 = __builtin_shufflevector(__s0_192, __s0_192, 3, 2, 1, 0); \
- float32x4_t __rev1_192; __rev1_192 = __builtin_shufflevector(__s1_192, __s1_192, 3, 2, 1, 0); \
- float32x4_t __rev2_192; __rev2_192 = __builtin_shufflevector(__s2_192, __s2_192, 3, 2, 1, 0); \
-float32x4_t __reint_192 = __rev2_192; \
-uint64x2_t __reint1_192 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_192, __p3_192), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_192, __p3_192)}; \
- __ret_192 = __noswap_vcmlaq_rot180_f32(__rev0_192, __rev1_192, *(float32x4_t *) &__reint1_192); \
- __ret_192 = __builtin_shufflevector(__ret_192, __ret_192, 3, 2, 1, 0); \
- __ret_192; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a"))) float32x4_t vcmlaq_rot270_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vcmlaq_rot270_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_s64(int64x2_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a"))) float32x4_t vcmlaq_rot270_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- float32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vcmlaq_rot270_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_s16(int16x8_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.3a"))) float32x4_t __noswap_vcmlaq_rot270_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vcmlaq_rot270_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_p8(poly8x16_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a"))) float32x2_t vcmla_rot270_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vcmla_rot270_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_p16(poly16x8_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a"))) float32x2_t vcmla_rot270_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- float32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vcmla_rot270_f32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_u8(uint8x16_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.3a"))) float32x2_t __noswap_vcmla_rot270_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vcmla_rot270_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_u32(uint32x4_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmla_rot270_lane_f32(__p0_193, __p1_193, __p2_193, __p3_193) __extension__ ({ \
- float32x2_t __ret_193; \
- float32x2_t __s0_193 = __p0_193; \
- float32x2_t __s1_193 = __p1_193; \
- float32x2_t __s2_193 = __p2_193; \
-float32x2_t __reint_193 = __s2_193; \
-uint64x1_t __reint1_193 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_193, __p3_193)}; \
- __ret_193 = vcmla_rot270_f32(__s0_193, __s1_193, *(float32x2_t *) &__reint1_193); \
- __ret_193; \
-})
-#else
-#define vcmla_rot270_lane_f32(__p0_194, __p1_194, __p2_194, __p3_194) __extension__ ({ \
- float32x2_t __ret_194; \
- float32x2_t __s0_194 = __p0_194; \
- float32x2_t __s1_194 = __p1_194; \
- float32x2_t __s2_194 = __p2_194; \
- float32x2_t __rev0_194; __rev0_194 = __builtin_shufflevector(__s0_194, __s0_194, 1, 0); \
- float32x2_t __rev1_194; __rev1_194 = __builtin_shufflevector(__s1_194, __s1_194, 1, 0); \
- float32x2_t __rev2_194; __rev2_194 = __builtin_shufflevector(__s2_194, __s2_194, 1, 0); \
-float32x2_t __reint_194 = __rev2_194; \
-uint64x1_t __reint1_194 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_194, __p3_194)}; \
- __ret_194 = __noswap_vcmla_rot270_f32(__rev0_194, __rev1_194, *(float32x2_t *) &__reint1_194); \
- __ret_194 = __builtin_shufflevector(__ret_194, __ret_194, 1, 0); \
- __ret_194; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_rot270_lane_f32(__p0_195, __p1_195, __p2_195, __p3_195) __extension__ ({ \
- float32x4_t __ret_195; \
- float32x4_t __s0_195 = __p0_195; \
- float32x4_t __s1_195 = __p1_195; \
- float32x2_t __s2_195 = __p2_195; \
-float32x2_t __reint_195 = __s2_195; \
-uint64x2_t __reint1_195 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_195, __p3_195), vget_lane_u64(*(uint64x1_t *) &__reint_195, __p3_195)}; \
- __ret_195 = vcmlaq_rot270_f32(__s0_195, __s1_195, *(float32x4_t *) &__reint1_195); \
- __ret_195; \
-})
-#else
-#define vcmlaq_rot270_lane_f32(__p0_196, __p1_196, __p2_196, __p3_196) __extension__ ({ \
- float32x4_t __ret_196; \
- float32x4_t __s0_196 = __p0_196; \
- float32x4_t __s1_196 = __p1_196; \
- float32x2_t __s2_196 = __p2_196; \
- float32x4_t __rev0_196; __rev0_196 = __builtin_shufflevector(__s0_196, __s0_196, 3, 2, 1, 0); \
- float32x4_t __rev1_196; __rev1_196 = __builtin_shufflevector(__s1_196, __s1_196, 3, 2, 1, 0); \
- float32x2_t __rev2_196; __rev2_196 = __builtin_shufflevector(__s2_196, __s2_196, 1, 0); \
-float32x2_t __reint_196 = __rev2_196; \
-uint64x2_t __reint1_196 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_196, __p3_196), vget_lane_u64(*(uint64x1_t *) &__reint_196, __p3_196)}; \
- __ret_196 = __noswap_vcmlaq_rot270_f32(__rev0_196, __rev1_196, *(float32x4_t *) &__reint1_196); \
- __ret_196 = __builtin_shufflevector(__ret_196, __ret_196, 3, 2, 1, 0); \
- __ret_196; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmla_rot270_laneq_f32(__p0_197, __p1_197, __p2_197, __p3_197) __extension__ ({ \
- float32x2_t __ret_197; \
- float32x2_t __s0_197 = __p0_197; \
- float32x2_t __s1_197 = __p1_197; \
- float32x4_t __s2_197 = __p2_197; \
-float32x4_t __reint_197 = __s2_197; \
-uint64x1_t __reint1_197 = (uint64x1_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_197, __p3_197)}; \
- __ret_197 = vcmla_rot270_f32(__s0_197, __s1_197, *(float32x2_t *) &__reint1_197); \
- __ret_197; \
-})
-#else
-#define vcmla_rot270_laneq_f32(__p0_198, __p1_198, __p2_198, __p3_198) __extension__ ({ \
- float32x2_t __ret_198; \
- float32x2_t __s0_198 = __p0_198; \
- float32x2_t __s1_198 = __p1_198; \
- float32x4_t __s2_198 = __p2_198; \
- float32x2_t __rev0_198; __rev0_198 = __builtin_shufflevector(__s0_198, __s0_198, 1, 0); \
- float32x2_t __rev1_198; __rev1_198 = __builtin_shufflevector(__s1_198, __s1_198, 1, 0); \
- float32x4_t __rev2_198; __rev2_198 = __builtin_shufflevector(__s2_198, __s2_198, 3, 2, 1, 0); \
-float32x4_t __reint_198 = __rev2_198; \
-uint64x1_t __reint1_198 = (uint64x1_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_198, __p3_198)}; \
- __ret_198 = __noswap_vcmla_rot270_f32(__rev0_198, __rev1_198, *(float32x2_t *) &__reint1_198); \
- __ret_198 = __builtin_shufflevector(__ret_198, __ret_198, 1, 0); \
- __ret_198; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_rot270_laneq_f32(__p0_199, __p1_199, __p2_199, __p3_199) __extension__ ({ \
- float32x4_t __ret_199; \
- float32x4_t __s0_199 = __p0_199; \
- float32x4_t __s1_199 = __p1_199; \
- float32x4_t __s2_199 = __p2_199; \
-float32x4_t __reint_199 = __s2_199; \
-uint64x2_t __reint1_199 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_199, __p3_199), vgetq_lane_u64(*(uint64x2_t *) &__reint_199, __p3_199)}; \
- __ret_199 = vcmlaq_rot270_f32(__s0_199, __s1_199, *(float32x4_t *) &__reint1_199); \
- __ret_199; \
-})
-#else
-#define vcmlaq_rot270_laneq_f32(__p0_200, __p1_200, __p2_200, __p3_200) __extension__ ({ \
- float32x4_t __ret_200; \
- float32x4_t __s0_200 = __p0_200; \
- float32x4_t __s1_200 = __p1_200; \
- float32x4_t __s2_200 = __p2_200; \
- float32x4_t __rev0_200; __rev0_200 = __builtin_shufflevector(__s0_200, __s0_200, 3, 2, 1, 0); \
- float32x4_t __rev1_200; __rev1_200 = __builtin_shufflevector(__s1_200, __s1_200, 3, 2, 1, 0); \
- float32x4_t __rev2_200; __rev2_200 = __builtin_shufflevector(__s2_200, __s2_200, 3, 2, 1, 0); \
-float32x4_t __reint_200 = __rev2_200; \
-uint64x2_t __reint1_200 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_200, __p3_200), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_200, __p3_200)}; \
- __ret_200 = __noswap_vcmlaq_rot270_f32(__rev0_200, __rev1_200, *(float32x4_t *) &__reint1_200); \
- __ret_200 = __builtin_shufflevector(__ret_200, __ret_200, 3, 2, 1, 0); \
- __ret_200; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a"))) float32x4_t vcmlaq_rot90_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_u16(uint16x8_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_s8(int8x16_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_f32(float32x4_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_f16(float16x8_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_s32(int32x4_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_s64(int64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_s16(int16x8_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_p8(poly8x16_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_p16(poly16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_u8(uint8x16_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_u32(uint32x4_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_u64(uint64x2_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_s8(int8x16_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_f32(float32x4_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_s32(int32x4_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_s64(int64x2_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_s16(int16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_p8(poly8x16_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_p16(poly16x8_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_u8(uint8x16_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_u32(uint32x4_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_u64(uint64x2_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_u16(uint16x8_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_f32(float32x4_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_f16(float16x8_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_s32(int32x4_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_s64(int64x2_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_s16(int16x8_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_p8(poly8x16_t __p0) {
float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vcmlaq_rot90_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+ __ret = (float32x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a"))) float32x4_t vcmlaq_rot90_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_p16(poly16x8_t __p0) {
float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- float32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vcmlaq_rot90_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ __ret = (float32x4_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.3a"))) float32x4_t __noswap_vcmlaq_rot90_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_u8(uint8x16_t __p0) {
float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vcmlaq_rot90_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+ __ret = (float32x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a"))) float32x2_t vcmla_rot90_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vcmla_rot90_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_u32(uint32x4_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a"))) float32x2_t vcmla_rot90_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- float32x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vcmla_rot90_f32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_u64(uint64x2_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.3a"))) float32x2_t __noswap_vcmla_rot90_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vcmla_rot90_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_u16(uint16x8_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmla_rot90_lane_f32(__p0_201, __p1_201, __p2_201, __p3_201) __extension__ ({ \
- float32x2_t __ret_201; \
- float32x2_t __s0_201 = __p0_201; \
- float32x2_t __s1_201 = __p1_201; \
- float32x2_t __s2_201 = __p2_201; \
-float32x2_t __reint_201 = __s2_201; \
-uint64x1_t __reint1_201 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_201, __p3_201)}; \
- __ret_201 = vcmla_rot90_f32(__s0_201, __s1_201, *(float32x2_t *) &__reint1_201); \
- __ret_201; \
-})
-#else
-#define vcmla_rot90_lane_f32(__p0_202, __p1_202, __p2_202, __p3_202) __extension__ ({ \
- float32x2_t __ret_202; \
- float32x2_t __s0_202 = __p0_202; \
- float32x2_t __s1_202 = __p1_202; \
- float32x2_t __s2_202 = __p2_202; \
- float32x2_t __rev0_202; __rev0_202 = __builtin_shufflevector(__s0_202, __s0_202, 1, 0); \
- float32x2_t __rev1_202; __rev1_202 = __builtin_shufflevector(__s1_202, __s1_202, 1, 0); \
- float32x2_t __rev2_202; __rev2_202 = __builtin_shufflevector(__s2_202, __s2_202, 1, 0); \
-float32x2_t __reint_202 = __rev2_202; \
-uint64x1_t __reint1_202 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_202, __p3_202)}; \
- __ret_202 = __noswap_vcmla_rot90_f32(__rev0_202, __rev1_202, *(float32x2_t *) &__reint1_202); \
- __ret_202 = __builtin_shufflevector(__ret_202, __ret_202, 1, 0); \
- __ret_202; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_rot90_lane_f32(__p0_203, __p1_203, __p2_203, __p3_203) __extension__ ({ \
- float32x4_t __ret_203; \
- float32x4_t __s0_203 = __p0_203; \
- float32x4_t __s1_203 = __p1_203; \
- float32x2_t __s2_203 = __p2_203; \
-float32x2_t __reint_203 = __s2_203; \
-uint64x2_t __reint1_203 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_203, __p3_203), vget_lane_u64(*(uint64x1_t *) &__reint_203, __p3_203)}; \
- __ret_203 = vcmlaq_rot90_f32(__s0_203, __s1_203, *(float32x4_t *) &__reint1_203); \
- __ret_203; \
-})
-#else
-#define vcmlaq_rot90_lane_f32(__p0_204, __p1_204, __p2_204, __p3_204) __extension__ ({ \
- float32x4_t __ret_204; \
- float32x4_t __s0_204 = __p0_204; \
- float32x4_t __s1_204 = __p1_204; \
- float32x2_t __s2_204 = __p2_204; \
- float32x4_t __rev0_204; __rev0_204 = __builtin_shufflevector(__s0_204, __s0_204, 3, 2, 1, 0); \
- float32x4_t __rev1_204; __rev1_204 = __builtin_shufflevector(__s1_204, __s1_204, 3, 2, 1, 0); \
- float32x2_t __rev2_204; __rev2_204 = __builtin_shufflevector(__s2_204, __s2_204, 1, 0); \
-float32x2_t __reint_204 = __rev2_204; \
-uint64x2_t __reint1_204 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_204, __p3_204), vget_lane_u64(*(uint64x1_t *) &__reint_204, __p3_204)}; \
- __ret_204 = __noswap_vcmlaq_rot90_f32(__rev0_204, __rev1_204, *(float32x4_t *) &__reint1_204); \
- __ret_204 = __builtin_shufflevector(__ret_204, __ret_204, 3, 2, 1, 0); \
- __ret_204; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmla_rot90_laneq_f32(__p0_205, __p1_205, __p2_205, __p3_205) __extension__ ({ \
- float32x2_t __ret_205; \
- float32x2_t __s0_205 = __p0_205; \
- float32x2_t __s1_205 = __p1_205; \
- float32x4_t __s2_205 = __p2_205; \
-float32x4_t __reint_205 = __s2_205; \
-uint64x1_t __reint1_205 = (uint64x1_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_205, __p3_205)}; \
- __ret_205 = vcmla_rot90_f32(__s0_205, __s1_205, *(float32x2_t *) &__reint1_205); \
- __ret_205; \
-})
-#else
-#define vcmla_rot90_laneq_f32(__p0_206, __p1_206, __p2_206, __p3_206) __extension__ ({ \
- float32x2_t __ret_206; \
- float32x2_t __s0_206 = __p0_206; \
- float32x2_t __s1_206 = __p1_206; \
- float32x4_t __s2_206 = __p2_206; \
- float32x2_t __rev0_206; __rev0_206 = __builtin_shufflevector(__s0_206, __s0_206, 1, 0); \
- float32x2_t __rev1_206; __rev1_206 = __builtin_shufflevector(__s1_206, __s1_206, 1, 0); \
- float32x4_t __rev2_206; __rev2_206 = __builtin_shufflevector(__s2_206, __s2_206, 3, 2, 1, 0); \
-float32x4_t __reint_206 = __rev2_206; \
-uint64x1_t __reint1_206 = (uint64x1_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_206, __p3_206)}; \
- __ret_206 = __noswap_vcmla_rot90_f32(__rev0_206, __rev1_206, *(float32x2_t *) &__reint1_206); \
- __ret_206 = __builtin_shufflevector(__ret_206, __ret_206, 1, 0); \
- __ret_206; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_rot90_laneq_f32(__p0_207, __p1_207, __p2_207, __p3_207) __extension__ ({ \
- float32x4_t __ret_207; \
- float32x4_t __s0_207 = __p0_207; \
- float32x4_t __s1_207 = __p1_207; \
- float32x4_t __s2_207 = __p2_207; \
-float32x4_t __reint_207 = __s2_207; \
-uint64x2_t __reint1_207 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_207, __p3_207), vgetq_lane_u64(*(uint64x2_t *) &__reint_207, __p3_207)}; \
- __ret_207 = vcmlaq_rot90_f32(__s0_207, __s1_207, *(float32x4_t *) &__reint1_207); \
- __ret_207; \
-})
-#else
-#define vcmlaq_rot90_laneq_f32(__p0_208, __p1_208, __p2_208, __p3_208) __extension__ ({ \
- float32x4_t __ret_208; \
- float32x4_t __s0_208 = __p0_208; \
- float32x4_t __s1_208 = __p1_208; \
- float32x4_t __s2_208 = __p2_208; \
- float32x4_t __rev0_208; __rev0_208 = __builtin_shufflevector(__s0_208, __s0_208, 3, 2, 1, 0); \
- float32x4_t __rev1_208; __rev1_208 = __builtin_shufflevector(__s1_208, __s1_208, 3, 2, 1, 0); \
- float32x4_t __rev2_208; __rev2_208 = __builtin_shufflevector(__s2_208, __s2_208, 3, 2, 1, 0); \
-float32x4_t __reint_208 = __rev2_208; \
-uint64x2_t __reint1_208 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_208, __p3_208), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_208, __p3_208)}; \
- __ret_208 = __noswap_vcmlaq_rot90_f32(__rev0_208, __rev1_208, *(float32x4_t *) &__reint1_208); \
- __ret_208 = __builtin_shufflevector(__ret_208, __ret_208, 3, 2, 1, 0); \
- __ret_208; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x4_t vcadd_rot270_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vcadd_rot270_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_s8(int8x16_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x4_t vcadd_rot270_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vcadd_rot270_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_f16(float16x8_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x4_t vcadd_rot90_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vcadd_rot90_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_s32(int32x4_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x4_t vcadd_rot90_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vcadd_rot90_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_s64(int64x2_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x8_t vcaddq_rot270_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vcaddq_rot270_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_s16(int16x8_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x8_t vcaddq_rot270_f16(float16x8_t __p0, float16x8_t __p1) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_p8(poly8x16_t __p0) {
float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vcaddq_rot270_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x8_t vcaddq_rot90_f16(float16x8_t __p0, float16x8_t __p1) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_p16(poly16x8_t __p0) {
float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vcaddq_rot90_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+ __ret = (float16x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x8_t vcaddq_rot90_f16(float16x8_t __p0, float16x8_t __p1) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_u8(uint8x16_t __p0) {
float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vcaddq_rot90_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x8_t vcmlaq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_u32(uint32x4_t __p0) {
float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vcmlaq_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+ __ret = (float16x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x8_t vcmlaq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_u64(uint64x2_t __p0) {
float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vcmlaq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x8_t __noswap_vcmlaq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_u16(uint16x8_t __p0) {
float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vcmlaq_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+ __ret = (float16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x4_t vcmla_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vcmla_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_s8(int8x16_t __p0) {
+ float16x8_t __ret;
+ __ret = (float16x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x4_t vcmla_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vcmla_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_f32(float32x4_t __p0) {
+ float16x8_t __ret;
+ __ret = (float16x8_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x4_t __noswap_vcmla_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vcmla_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_s32(int32x4_t __p0) {
+ float16x8_t __ret;
+ __ret = (float16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmla_lane_f16(__p0_209, __p1_209, __p2_209, __p3_209) __extension__ ({ \
- float16x4_t __ret_209; \
- float16x4_t __s0_209 = __p0_209; \
- float16x4_t __s1_209 = __p1_209; \
- float16x4_t __s2_209 = __p2_209; \
-float16x4_t __reint_209 = __s2_209; \
-uint32x2_t __reint1_209 = (uint32x2_t) {vget_lane_u32(*(uint32x2_t *) &__reint_209, __p3_209), vget_lane_u32(*(uint32x2_t *) &__reint_209, __p3_209)}; \
- __ret_209 = vcmla_f16(__s0_209, __s1_209, *(float16x4_t *) &__reint1_209); \
- __ret_209; \
-})
-#else
-#define vcmla_lane_f16(__p0_210, __p1_210, __p2_210, __p3_210) __extension__ ({ \
- float16x4_t __ret_210; \
- float16x4_t __s0_210 = __p0_210; \
- float16x4_t __s1_210 = __p1_210; \
- float16x4_t __s2_210 = __p2_210; \
- float16x4_t __rev0_210; __rev0_210 = __builtin_shufflevector(__s0_210, __s0_210, 3, 2, 1, 0); \
- float16x4_t __rev1_210; __rev1_210 = __builtin_shufflevector(__s1_210, __s1_210, 3, 2, 1, 0); \
- float16x4_t __rev2_210; __rev2_210 = __builtin_shufflevector(__s2_210, __s2_210, 3, 2, 1, 0); \
-float16x4_t __reint_210 = __rev2_210; \
-uint32x2_t __reint1_210 = (uint32x2_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_210, __p3_210), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_210, __p3_210)}; \
- __ret_210 = __noswap_vcmla_f16(__rev0_210, __rev1_210, *(float16x4_t *) &__reint1_210); \
- __ret_210 = __builtin_shufflevector(__ret_210, __ret_210, 3, 2, 1, 0); \
- __ret_210; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_lane_f16(__p0_211, __p1_211, __p2_211, __p3_211) __extension__ ({ \
- float16x8_t __ret_211; \
- float16x8_t __s0_211 = __p0_211; \
- float16x8_t __s1_211 = __p1_211; \
- float16x4_t __s2_211 = __p2_211; \
-float16x4_t __reint_211 = __s2_211; \
-uint32x4_t __reint1_211 = (uint32x4_t) {vget_lane_u32(*(uint32x2_t *) &__reint_211, __p3_211), vget_lane_u32(*(uint32x2_t *) &__reint_211, __p3_211), vget_lane_u32(*(uint32x2_t *) &__reint_211, __p3_211), vget_lane_u32(*(uint32x2_t *) &__reint_211, __p3_211)}; \
- __ret_211 = vcmlaq_f16(__s0_211, __s1_211, *(float16x8_t *) &__reint1_211); \
- __ret_211; \
-})
-#else
-#define vcmlaq_lane_f16(__p0_212, __p1_212, __p2_212, __p3_212) __extension__ ({ \
- float16x8_t __ret_212; \
- float16x8_t __s0_212 = __p0_212; \
- float16x8_t __s1_212 = __p1_212; \
- float16x4_t __s2_212 = __p2_212; \
- float16x8_t __rev0_212; __rev0_212 = __builtin_shufflevector(__s0_212, __s0_212, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev1_212; __rev1_212 = __builtin_shufflevector(__s1_212, __s1_212, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x4_t __rev2_212; __rev2_212 = __builtin_shufflevector(__s2_212, __s2_212, 3, 2, 1, 0); \
-float16x4_t __reint_212 = __rev2_212; \
-uint32x4_t __reint1_212 = (uint32x4_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_212, __p3_212), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_212, __p3_212), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_212, __p3_212), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_212, __p3_212)}; \
- __ret_212 = __noswap_vcmlaq_f16(__rev0_212, __rev1_212, *(float16x8_t *) &__reint1_212); \
- __ret_212 = __builtin_shufflevector(__ret_212, __ret_212, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_212; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmla_laneq_f16(__p0_213, __p1_213, __p2_213, __p3_213) __extension__ ({ \
- float16x4_t __ret_213; \
- float16x4_t __s0_213 = __p0_213; \
- float16x4_t __s1_213 = __p1_213; \
- float16x8_t __s2_213 = __p2_213; \
-float16x8_t __reint_213 = __s2_213; \
-uint32x2_t __reint1_213 = (uint32x2_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_213, __p3_213), vgetq_lane_u32(*(uint32x4_t *) &__reint_213, __p3_213)}; \
- __ret_213 = vcmla_f16(__s0_213, __s1_213, *(float16x4_t *) &__reint1_213); \
- __ret_213; \
-})
-#else
-#define vcmla_laneq_f16(__p0_214, __p1_214, __p2_214, __p3_214) __extension__ ({ \
- float16x4_t __ret_214; \
- float16x4_t __s0_214 = __p0_214; \
- float16x4_t __s1_214 = __p1_214; \
- float16x8_t __s2_214 = __p2_214; \
- float16x4_t __rev0_214; __rev0_214 = __builtin_shufflevector(__s0_214, __s0_214, 3, 2, 1, 0); \
- float16x4_t __rev1_214; __rev1_214 = __builtin_shufflevector(__s1_214, __s1_214, 3, 2, 1, 0); \
- float16x8_t __rev2_214; __rev2_214 = __builtin_shufflevector(__s2_214, __s2_214, 7, 6, 5, 4, 3, 2, 1, 0); \
-float16x8_t __reint_214 = __rev2_214; \
-uint32x2_t __reint1_214 = (uint32x2_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_214, __p3_214), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_214, __p3_214)}; \
- __ret_214 = __noswap_vcmla_f16(__rev0_214, __rev1_214, *(float16x4_t *) &__reint1_214); \
- __ret_214 = __builtin_shufflevector(__ret_214, __ret_214, 3, 2, 1, 0); \
- __ret_214; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_laneq_f16(__p0_215, __p1_215, __p2_215, __p3_215) __extension__ ({ \
- float16x8_t __ret_215; \
- float16x8_t __s0_215 = __p0_215; \
- float16x8_t __s1_215 = __p1_215; \
- float16x8_t __s2_215 = __p2_215; \
-float16x8_t __reint_215 = __s2_215; \
-uint32x4_t __reint1_215 = (uint32x4_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_215, __p3_215), vgetq_lane_u32(*(uint32x4_t *) &__reint_215, __p3_215), vgetq_lane_u32(*(uint32x4_t *) &__reint_215, __p3_215), vgetq_lane_u32(*(uint32x4_t *) &__reint_215, __p3_215)}; \
- __ret_215 = vcmlaq_f16(__s0_215, __s1_215, *(float16x8_t *) &__reint1_215); \
- __ret_215; \
-})
-#else
-#define vcmlaq_laneq_f16(__p0_216, __p1_216, __p2_216, __p3_216) __extension__ ({ \
- float16x8_t __ret_216; \
- float16x8_t __s0_216 = __p0_216; \
- float16x8_t __s1_216 = __p1_216; \
- float16x8_t __s2_216 = __p2_216; \
- float16x8_t __rev0_216; __rev0_216 = __builtin_shufflevector(__s0_216, __s0_216, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev1_216; __rev1_216 = __builtin_shufflevector(__s1_216, __s1_216, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev2_216; __rev2_216 = __builtin_shufflevector(__s2_216, __s2_216, 7, 6, 5, 4, 3, 2, 1, 0); \
-float16x8_t __reint_216 = __rev2_216; \
-uint32x4_t __reint1_216 = (uint32x4_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_216, __p3_216), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_216, __p3_216), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_216, __p3_216), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_216, __p3_216)}; \
- __ret_216 = __noswap_vcmlaq_f16(__rev0_216, __rev1_216, *(float16x8_t *) &__reint1_216); \
- __ret_216 = __builtin_shufflevector(__ret_216, __ret_216, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_216; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x8_t vcmlaq_rot180_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_s64(int64x2_t __p0) {
float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vcmlaq_rot180_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+ __ret = (float16x8_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x8_t vcmlaq_rot180_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_s16(int16x8_t __p0) {
float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vcmlaq_rot180_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x8_t __noswap_vcmlaq_rot180_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vcmlaq_rot180_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_p8(poly8x16_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x4_t vcmla_rot180_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vcmla_rot180_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_p16(poly16x8_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x4_t vcmla_rot180_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vcmla_rot180_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_u8(uint8x16_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x4_t __noswap_vcmla_rot180_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vcmla_rot180_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_u32(uint32x4_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmla_rot180_lane_f16(__p0_217, __p1_217, __p2_217, __p3_217) __extension__ ({ \
- float16x4_t __ret_217; \
- float16x4_t __s0_217 = __p0_217; \
- float16x4_t __s1_217 = __p1_217; \
- float16x4_t __s2_217 = __p2_217; \
-float16x4_t __reint_217 = __s2_217; \
-uint32x2_t __reint1_217 = (uint32x2_t) {vget_lane_u32(*(uint32x2_t *) &__reint_217, __p3_217), vget_lane_u32(*(uint32x2_t *) &__reint_217, __p3_217)}; \
- __ret_217 = vcmla_rot180_f16(__s0_217, __s1_217, *(float16x4_t *) &__reint1_217); \
- __ret_217; \
-})
-#else
-#define vcmla_rot180_lane_f16(__p0_218, __p1_218, __p2_218, __p3_218) __extension__ ({ \
- float16x4_t __ret_218; \
- float16x4_t __s0_218 = __p0_218; \
- float16x4_t __s1_218 = __p1_218; \
- float16x4_t __s2_218 = __p2_218; \
- float16x4_t __rev0_218; __rev0_218 = __builtin_shufflevector(__s0_218, __s0_218, 3, 2, 1, 0); \
- float16x4_t __rev1_218; __rev1_218 = __builtin_shufflevector(__s1_218, __s1_218, 3, 2, 1, 0); \
- float16x4_t __rev2_218; __rev2_218 = __builtin_shufflevector(__s2_218, __s2_218, 3, 2, 1, 0); \
-float16x4_t __reint_218 = __rev2_218; \
-uint32x2_t __reint1_218 = (uint32x2_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_218, __p3_218), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_218, __p3_218)}; \
- __ret_218 = __noswap_vcmla_rot180_f16(__rev0_218, __rev1_218, *(float16x4_t *) &__reint1_218); \
- __ret_218 = __builtin_shufflevector(__ret_218, __ret_218, 3, 2, 1, 0); \
- __ret_218; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_rot180_lane_f16(__p0_219, __p1_219, __p2_219, __p3_219) __extension__ ({ \
- float16x8_t __ret_219; \
- float16x8_t __s0_219 = __p0_219; \
- float16x8_t __s1_219 = __p1_219; \
- float16x4_t __s2_219 = __p2_219; \
-float16x4_t __reint_219 = __s2_219; \
-uint32x4_t __reint1_219 = (uint32x4_t) {vget_lane_u32(*(uint32x2_t *) &__reint_219, __p3_219), vget_lane_u32(*(uint32x2_t *) &__reint_219, __p3_219), vget_lane_u32(*(uint32x2_t *) &__reint_219, __p3_219), vget_lane_u32(*(uint32x2_t *) &__reint_219, __p3_219)}; \
- __ret_219 = vcmlaq_rot180_f16(__s0_219, __s1_219, *(float16x8_t *) &__reint1_219); \
- __ret_219; \
-})
-#else
-#define vcmlaq_rot180_lane_f16(__p0_220, __p1_220, __p2_220, __p3_220) __extension__ ({ \
- float16x8_t __ret_220; \
- float16x8_t __s0_220 = __p0_220; \
- float16x8_t __s1_220 = __p1_220; \
- float16x4_t __s2_220 = __p2_220; \
- float16x8_t __rev0_220; __rev0_220 = __builtin_shufflevector(__s0_220, __s0_220, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev1_220; __rev1_220 = __builtin_shufflevector(__s1_220, __s1_220, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x4_t __rev2_220; __rev2_220 = __builtin_shufflevector(__s2_220, __s2_220, 3, 2, 1, 0); \
-float16x4_t __reint_220 = __rev2_220; \
-uint32x4_t __reint1_220 = (uint32x4_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_220, __p3_220), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_220, __p3_220), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_220, __p3_220), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_220, __p3_220)}; \
- __ret_220 = __noswap_vcmlaq_rot180_f16(__rev0_220, __rev1_220, *(float16x8_t *) &__reint1_220); \
- __ret_220 = __builtin_shufflevector(__ret_220, __ret_220, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_220; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmla_rot180_laneq_f16(__p0_221, __p1_221, __p2_221, __p3_221) __extension__ ({ \
- float16x4_t __ret_221; \
- float16x4_t __s0_221 = __p0_221; \
- float16x4_t __s1_221 = __p1_221; \
- float16x8_t __s2_221 = __p2_221; \
-float16x8_t __reint_221 = __s2_221; \
-uint32x2_t __reint1_221 = (uint32x2_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_221, __p3_221), vgetq_lane_u32(*(uint32x4_t *) &__reint_221, __p3_221)}; \
- __ret_221 = vcmla_rot180_f16(__s0_221, __s1_221, *(float16x4_t *) &__reint1_221); \
- __ret_221; \
-})
-#else
-#define vcmla_rot180_laneq_f16(__p0_222, __p1_222, __p2_222, __p3_222) __extension__ ({ \
- float16x4_t __ret_222; \
- float16x4_t __s0_222 = __p0_222; \
- float16x4_t __s1_222 = __p1_222; \
- float16x8_t __s2_222 = __p2_222; \
- float16x4_t __rev0_222; __rev0_222 = __builtin_shufflevector(__s0_222, __s0_222, 3, 2, 1, 0); \
- float16x4_t __rev1_222; __rev1_222 = __builtin_shufflevector(__s1_222, __s1_222, 3, 2, 1, 0); \
- float16x8_t __rev2_222; __rev2_222 = __builtin_shufflevector(__s2_222, __s2_222, 7, 6, 5, 4, 3, 2, 1, 0); \
-float16x8_t __reint_222 = __rev2_222; \
-uint32x2_t __reint1_222 = (uint32x2_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_222, __p3_222), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_222, __p3_222)}; \
- __ret_222 = __noswap_vcmla_rot180_f16(__rev0_222, __rev1_222, *(float16x4_t *) &__reint1_222); \
- __ret_222 = __builtin_shufflevector(__ret_222, __ret_222, 3, 2, 1, 0); \
- __ret_222; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_rot180_laneq_f16(__p0_223, __p1_223, __p2_223, __p3_223) __extension__ ({ \
- float16x8_t __ret_223; \
- float16x8_t __s0_223 = __p0_223; \
- float16x8_t __s1_223 = __p1_223; \
- float16x8_t __s2_223 = __p2_223; \
-float16x8_t __reint_223 = __s2_223; \
-uint32x4_t __reint1_223 = (uint32x4_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_223, __p3_223), vgetq_lane_u32(*(uint32x4_t *) &__reint_223, __p3_223), vgetq_lane_u32(*(uint32x4_t *) &__reint_223, __p3_223), vgetq_lane_u32(*(uint32x4_t *) &__reint_223, __p3_223)}; \
- __ret_223 = vcmlaq_rot180_f16(__s0_223, __s1_223, *(float16x8_t *) &__reint1_223); \
- __ret_223; \
-})
-#else
-#define vcmlaq_rot180_laneq_f16(__p0_224, __p1_224, __p2_224, __p3_224) __extension__ ({ \
- float16x8_t __ret_224; \
- float16x8_t __s0_224 = __p0_224; \
- float16x8_t __s1_224 = __p1_224; \
- float16x8_t __s2_224 = __p2_224; \
- float16x8_t __rev0_224; __rev0_224 = __builtin_shufflevector(__s0_224, __s0_224, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev1_224; __rev1_224 = __builtin_shufflevector(__s1_224, __s1_224, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev2_224; __rev2_224 = __builtin_shufflevector(__s2_224, __s2_224, 7, 6, 5, 4, 3, 2, 1, 0); \
-float16x8_t __reint_224 = __rev2_224; \
-uint32x4_t __reint1_224 = (uint32x4_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_224, __p3_224), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_224, __p3_224), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_224, __p3_224), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_224, __p3_224)}; \
- __ret_224 = __noswap_vcmlaq_rot180_f16(__rev0_224, __rev1_224, *(float16x8_t *) &__reint1_224); \
- __ret_224 = __builtin_shufflevector(__ret_224, __ret_224, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_224; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x8_t vcmlaq_rot270_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vcmlaq_rot270_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_u64(uint64x2_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x8_t vcmlaq_rot270_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vcmlaq_rot270_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_u16(uint16x8_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x8_t __noswap_vcmlaq_rot270_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vcmlaq_rot270_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_s8(int8x16_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x4_t vcmla_rot270_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vcmla_rot270_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_f32(float32x4_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x4_t vcmla_rot270_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vcmla_rot270_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_f16(float16x8_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x4_t __noswap_vcmla_rot270_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vcmla_rot270_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_s64(int64x2_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmla_rot270_lane_f16(__p0_225, __p1_225, __p2_225, __p3_225) __extension__ ({ \
- float16x4_t __ret_225; \
- float16x4_t __s0_225 = __p0_225; \
- float16x4_t __s1_225 = __p1_225; \
- float16x4_t __s2_225 = __p2_225; \
-float16x4_t __reint_225 = __s2_225; \
-uint32x2_t __reint1_225 = (uint32x2_t) {vget_lane_u32(*(uint32x2_t *) &__reint_225, __p3_225), vget_lane_u32(*(uint32x2_t *) &__reint_225, __p3_225)}; \
- __ret_225 = vcmla_rot270_f16(__s0_225, __s1_225, *(float16x4_t *) &__reint1_225); \
- __ret_225; \
-})
-#else
-#define vcmla_rot270_lane_f16(__p0_226, __p1_226, __p2_226, __p3_226) __extension__ ({ \
- float16x4_t __ret_226; \
- float16x4_t __s0_226 = __p0_226; \
- float16x4_t __s1_226 = __p1_226; \
- float16x4_t __s2_226 = __p2_226; \
- float16x4_t __rev0_226; __rev0_226 = __builtin_shufflevector(__s0_226, __s0_226, 3, 2, 1, 0); \
- float16x4_t __rev1_226; __rev1_226 = __builtin_shufflevector(__s1_226, __s1_226, 3, 2, 1, 0); \
- float16x4_t __rev2_226; __rev2_226 = __builtin_shufflevector(__s2_226, __s2_226, 3, 2, 1, 0); \
-float16x4_t __reint_226 = __rev2_226; \
-uint32x2_t __reint1_226 = (uint32x2_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_226, __p3_226), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_226, __p3_226)}; \
- __ret_226 = __noswap_vcmla_rot270_f16(__rev0_226, __rev1_226, *(float16x4_t *) &__reint1_226); \
- __ret_226 = __builtin_shufflevector(__ret_226, __ret_226, 3, 2, 1, 0); \
- __ret_226; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_rot270_lane_f16(__p0_227, __p1_227, __p2_227, __p3_227) __extension__ ({ \
- float16x8_t __ret_227; \
- float16x8_t __s0_227 = __p0_227; \
- float16x8_t __s1_227 = __p1_227; \
- float16x4_t __s2_227 = __p2_227; \
-float16x4_t __reint_227 = __s2_227; \
-uint32x4_t __reint1_227 = (uint32x4_t) {vget_lane_u32(*(uint32x2_t *) &__reint_227, __p3_227), vget_lane_u32(*(uint32x2_t *) &__reint_227, __p3_227), vget_lane_u32(*(uint32x2_t *) &__reint_227, __p3_227), vget_lane_u32(*(uint32x2_t *) &__reint_227, __p3_227)}; \
- __ret_227 = vcmlaq_rot270_f16(__s0_227, __s1_227, *(float16x8_t *) &__reint1_227); \
- __ret_227; \
-})
-#else
-#define vcmlaq_rot270_lane_f16(__p0_228, __p1_228, __p2_228, __p3_228) __extension__ ({ \
- float16x8_t __ret_228; \
- float16x8_t __s0_228 = __p0_228; \
- float16x8_t __s1_228 = __p1_228; \
- float16x4_t __s2_228 = __p2_228; \
- float16x8_t __rev0_228; __rev0_228 = __builtin_shufflevector(__s0_228, __s0_228, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev1_228; __rev1_228 = __builtin_shufflevector(__s1_228, __s1_228, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x4_t __rev2_228; __rev2_228 = __builtin_shufflevector(__s2_228, __s2_228, 3, 2, 1, 0); \
-float16x4_t __reint_228 = __rev2_228; \
-uint32x4_t __reint1_228 = (uint32x4_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_228, __p3_228), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_228, __p3_228), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_228, __p3_228), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_228, __p3_228)}; \
- __ret_228 = __noswap_vcmlaq_rot270_f16(__rev0_228, __rev1_228, *(float16x8_t *) &__reint1_228); \
- __ret_228 = __builtin_shufflevector(__ret_228, __ret_228, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_228; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmla_rot270_laneq_f16(__p0_229, __p1_229, __p2_229, __p3_229) __extension__ ({ \
- float16x4_t __ret_229; \
- float16x4_t __s0_229 = __p0_229; \
- float16x4_t __s1_229 = __p1_229; \
- float16x8_t __s2_229 = __p2_229; \
-float16x8_t __reint_229 = __s2_229; \
-uint32x2_t __reint1_229 = (uint32x2_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_229, __p3_229), vgetq_lane_u32(*(uint32x4_t *) &__reint_229, __p3_229)}; \
- __ret_229 = vcmla_rot270_f16(__s0_229, __s1_229, *(float16x4_t *) &__reint1_229); \
- __ret_229; \
-})
-#else
-#define vcmla_rot270_laneq_f16(__p0_230, __p1_230, __p2_230, __p3_230) __extension__ ({ \
- float16x4_t __ret_230; \
- float16x4_t __s0_230 = __p0_230; \
- float16x4_t __s1_230 = __p1_230; \
- float16x8_t __s2_230 = __p2_230; \
- float16x4_t __rev0_230; __rev0_230 = __builtin_shufflevector(__s0_230, __s0_230, 3, 2, 1, 0); \
- float16x4_t __rev1_230; __rev1_230 = __builtin_shufflevector(__s1_230, __s1_230, 3, 2, 1, 0); \
- float16x8_t __rev2_230; __rev2_230 = __builtin_shufflevector(__s2_230, __s2_230, 7, 6, 5, 4, 3, 2, 1, 0); \
-float16x8_t __reint_230 = __rev2_230; \
-uint32x2_t __reint1_230 = (uint32x2_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_230, __p3_230), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_230, __p3_230)}; \
- __ret_230 = __noswap_vcmla_rot270_f16(__rev0_230, __rev1_230, *(float16x4_t *) &__reint1_230); \
- __ret_230 = __builtin_shufflevector(__ret_230, __ret_230, 3, 2, 1, 0); \
- __ret_230; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_rot270_laneq_f16(__p0_231, __p1_231, __p2_231, __p3_231) __extension__ ({ \
- float16x8_t __ret_231; \
- float16x8_t __s0_231 = __p0_231; \
- float16x8_t __s1_231 = __p1_231; \
- float16x8_t __s2_231 = __p2_231; \
-float16x8_t __reint_231 = __s2_231; \
-uint32x4_t __reint1_231 = (uint32x4_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_231, __p3_231), vgetq_lane_u32(*(uint32x4_t *) &__reint_231, __p3_231), vgetq_lane_u32(*(uint32x4_t *) &__reint_231, __p3_231), vgetq_lane_u32(*(uint32x4_t *) &__reint_231, __p3_231)}; \
- __ret_231 = vcmlaq_rot270_f16(__s0_231, __s1_231, *(float16x8_t *) &__reint1_231); \
- __ret_231; \
-})
-#else
-#define vcmlaq_rot270_laneq_f16(__p0_232, __p1_232, __p2_232, __p3_232) __extension__ ({ \
- float16x8_t __ret_232; \
- float16x8_t __s0_232 = __p0_232; \
- float16x8_t __s1_232 = __p1_232; \
- float16x8_t __s2_232 = __p2_232; \
- float16x8_t __rev0_232; __rev0_232 = __builtin_shufflevector(__s0_232, __s0_232, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev1_232; __rev1_232 = __builtin_shufflevector(__s1_232, __s1_232, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev2_232; __rev2_232 = __builtin_shufflevector(__s2_232, __s2_232, 7, 6, 5, 4, 3, 2, 1, 0); \
-float16x8_t __reint_232 = __rev2_232; \
-uint32x4_t __reint1_232 = (uint32x4_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_232, __p3_232), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_232, __p3_232), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_232, __p3_232), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_232, __p3_232)}; \
- __ret_232 = __noswap_vcmlaq_rot270_f16(__rev0_232, __rev1_232, *(float16x8_t *) &__reint1_232); \
- __ret_232 = __builtin_shufflevector(__ret_232, __ret_232, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_232; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x8_t vcmlaq_rot90_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vcmlaq_rot90_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_s16(int16x8_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x8_t vcmlaq_rot90_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vcmlaq_rot90_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_p8(poly8x16_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x8_t __noswap_vcmlaq_rot90_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vcmlaq_rot90_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_p16(poly16x8_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x4_t vcmla_rot90_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vcmla_rot90_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_u8(uint8x16_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t)(__p0);
return __ret;
}
-#else
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x4_t vcmla_rot90_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vcmla_rot90_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_u32(uint32x4_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t)(__p0);
return __ret;
}
-__ai __attribute__((target("v8.3a,fullfp16"))) float16x4_t __noswap_vcmla_rot90_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vcmla_rot90_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_u64(uint64x2_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmla_rot90_lane_f16(__p0_233, __p1_233, __p2_233, __p3_233) __extension__ ({ \
- float16x4_t __ret_233; \
- float16x4_t __s0_233 = __p0_233; \
- float16x4_t __s1_233 = __p1_233; \
- float16x4_t __s2_233 = __p2_233; \
-float16x4_t __reint_233 = __s2_233; \
-uint32x2_t __reint1_233 = (uint32x2_t) {vget_lane_u32(*(uint32x2_t *) &__reint_233, __p3_233), vget_lane_u32(*(uint32x2_t *) &__reint_233, __p3_233)}; \
- __ret_233 = vcmla_rot90_f16(__s0_233, __s1_233, *(float16x4_t *) &__reint1_233); \
- __ret_233; \
-})
-#else
-#define vcmla_rot90_lane_f16(__p0_234, __p1_234, __p2_234, __p3_234) __extension__ ({ \
- float16x4_t __ret_234; \
- float16x4_t __s0_234 = __p0_234; \
- float16x4_t __s1_234 = __p1_234; \
- float16x4_t __s2_234 = __p2_234; \
- float16x4_t __rev0_234; __rev0_234 = __builtin_shufflevector(__s0_234, __s0_234, 3, 2, 1, 0); \
- float16x4_t __rev1_234; __rev1_234 = __builtin_shufflevector(__s1_234, __s1_234, 3, 2, 1, 0); \
- float16x4_t __rev2_234; __rev2_234 = __builtin_shufflevector(__s2_234, __s2_234, 3, 2, 1, 0); \
-float16x4_t __reint_234 = __rev2_234; \
-uint32x2_t __reint1_234 = (uint32x2_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_234, __p3_234), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_234, __p3_234)}; \
- __ret_234 = __noswap_vcmla_rot90_f16(__rev0_234, __rev1_234, *(float16x4_t *) &__reint1_234); \
- __ret_234 = __builtin_shufflevector(__ret_234, __ret_234, 3, 2, 1, 0); \
- __ret_234; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_rot90_lane_f16(__p0_235, __p1_235, __p2_235, __p3_235) __extension__ ({ \
- float16x8_t __ret_235; \
- float16x8_t __s0_235 = __p0_235; \
- float16x8_t __s1_235 = __p1_235; \
- float16x4_t __s2_235 = __p2_235; \
-float16x4_t __reint_235 = __s2_235; \
-uint32x4_t __reint1_235 = (uint32x4_t) {vget_lane_u32(*(uint32x2_t *) &__reint_235, __p3_235), vget_lane_u32(*(uint32x2_t *) &__reint_235, __p3_235), vget_lane_u32(*(uint32x2_t *) &__reint_235, __p3_235), vget_lane_u32(*(uint32x2_t *) &__reint_235, __p3_235)}; \
- __ret_235 = vcmlaq_rot90_f16(__s0_235, __s1_235, *(float16x8_t *) &__reint1_235); \
- __ret_235; \
-})
-#else
-#define vcmlaq_rot90_lane_f16(__p0_236, __p1_236, __p2_236, __p3_236) __extension__ ({ \
- float16x8_t __ret_236; \
- float16x8_t __s0_236 = __p0_236; \
- float16x8_t __s1_236 = __p1_236; \
- float16x4_t __s2_236 = __p2_236; \
- float16x8_t __rev0_236; __rev0_236 = __builtin_shufflevector(__s0_236, __s0_236, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev1_236; __rev1_236 = __builtin_shufflevector(__s1_236, __s1_236, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x4_t __rev2_236; __rev2_236 = __builtin_shufflevector(__s2_236, __s2_236, 3, 2, 1, 0); \
-float16x4_t __reint_236 = __rev2_236; \
-uint32x4_t __reint1_236 = (uint32x4_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_236, __p3_236), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_236, __p3_236), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_236, __p3_236), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_236, __p3_236)}; \
- __ret_236 = __noswap_vcmlaq_rot90_f16(__rev0_236, __rev1_236, *(float16x8_t *) &__reint1_236); \
- __ret_236 = __builtin_shufflevector(__ret_236, __ret_236, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_236; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmla_rot90_laneq_f16(__p0_237, __p1_237, __p2_237, __p3_237) __extension__ ({ \
- float16x4_t __ret_237; \
- float16x4_t __s0_237 = __p0_237; \
- float16x4_t __s1_237 = __p1_237; \
- float16x8_t __s2_237 = __p2_237; \
-float16x8_t __reint_237 = __s2_237; \
-uint32x2_t __reint1_237 = (uint32x2_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_237, __p3_237), vgetq_lane_u32(*(uint32x4_t *) &__reint_237, __p3_237)}; \
- __ret_237 = vcmla_rot90_f16(__s0_237, __s1_237, *(float16x4_t *) &__reint1_237); \
- __ret_237; \
-})
-#else
-#define vcmla_rot90_laneq_f16(__p0_238, __p1_238, __p2_238, __p3_238) __extension__ ({ \
- float16x4_t __ret_238; \
- float16x4_t __s0_238 = __p0_238; \
- float16x4_t __s1_238 = __p1_238; \
- float16x8_t __s2_238 = __p2_238; \
- float16x4_t __rev0_238; __rev0_238 = __builtin_shufflevector(__s0_238, __s0_238, 3, 2, 1, 0); \
- float16x4_t __rev1_238; __rev1_238 = __builtin_shufflevector(__s1_238, __s1_238, 3, 2, 1, 0); \
- float16x8_t __rev2_238; __rev2_238 = __builtin_shufflevector(__s2_238, __s2_238, 7, 6, 5, 4, 3, 2, 1, 0); \
-float16x8_t __reint_238 = __rev2_238; \
-uint32x2_t __reint1_238 = (uint32x2_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_238, __p3_238), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_238, __p3_238)}; \
- __ret_238 = __noswap_vcmla_rot90_f16(__rev0_238, __rev1_238, *(float16x4_t *) &__reint1_238); \
- __ret_238 = __builtin_shufflevector(__ret_238, __ret_238, 3, 2, 1, 0); \
- __ret_238; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_rot90_laneq_f16(__p0_239, __p1_239, __p2_239, __p3_239) __extension__ ({ \
- float16x8_t __ret_239; \
- float16x8_t __s0_239 = __p0_239; \
- float16x8_t __s1_239 = __p1_239; \
- float16x8_t __s2_239 = __p2_239; \
-float16x8_t __reint_239 = __s2_239; \
-uint32x4_t __reint1_239 = (uint32x4_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_239, __p3_239), vgetq_lane_u32(*(uint32x4_t *) &__reint_239, __p3_239), vgetq_lane_u32(*(uint32x4_t *) &__reint_239, __p3_239), vgetq_lane_u32(*(uint32x4_t *) &__reint_239, __p3_239)}; \
- __ret_239 = vcmlaq_rot90_f16(__s0_239, __s1_239, *(float16x8_t *) &__reint1_239); \
- __ret_239; \
-})
-#else
-#define vcmlaq_rot90_laneq_f16(__p0_240, __p1_240, __p2_240, __p3_240) __extension__ ({ \
- float16x8_t __ret_240; \
- float16x8_t __s0_240 = __p0_240; \
- float16x8_t __s1_240 = __p1_240; \
- float16x8_t __s2_240 = __p2_240; \
- float16x8_t __rev0_240; __rev0_240 = __builtin_shufflevector(__s0_240, __s0_240, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev1_240; __rev1_240 = __builtin_shufflevector(__s1_240, __s1_240, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev2_240; __rev2_240 = __builtin_shufflevector(__s2_240, __s2_240, 7, 6, 5, 4, 3, 2, 1, 0); \
-float16x8_t __reint_240 = __rev2_240; \
-uint32x4_t __reint1_240 = (uint32x4_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_240, __p3_240), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_240, __p3_240), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_240, __p3_240), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_240, __p3_240)}; \
- __ret_240 = __noswap_vcmlaq_rot90_f16(__rev0_240, __rev1_240, *(float16x8_t *) &__reint1_240); \
- __ret_240 = __builtin_shufflevector(__ret_240, __ret_240, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_240; \
-})
-#endif
-
-#if !defined(__aarch64__)
-#ifdef __LITTLE_ENDIAN__
-#define vqdmulhq_lane_s32(__p0_241, __p1_241, __p2_241) __extension__ ({ \
- int32x4_t __ret_241; \
- int32x4_t __s0_241 = __p0_241; \
- int32x2_t __s1_241 = __p1_241; \
- __ret_241 = vqdmulhq_s32(__s0_241, splatq_lane_s32(__s1_241, __p2_241)); \
- __ret_241; \
-})
-#else
-#define vqdmulhq_lane_s32(__p0_242, __p1_242, __p2_242) __extension__ ({ \
- int32x4_t __ret_242; \
- int32x4_t __s0_242 = __p0_242; \
- int32x2_t __s1_242 = __p1_242; \
- int32x4_t __rev0_242; __rev0_242 = __builtin_shufflevector(__s0_242, __s0_242, 3, 2, 1, 0); \
- int32x2_t __rev1_242; __rev1_242 = __builtin_shufflevector(__s1_242, __s1_242, 1, 0); \
- __ret_242 = __noswap_vqdmulhq_s32(__rev0_242, __noswap_splatq_lane_s32(__rev1_242, __p2_242)); \
- __ret_242 = __builtin_shufflevector(__ret_242, __ret_242, 3, 2, 1, 0); \
- __ret_242; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vqdmulhq_lane_s16(__p0_243, __p1_243, __p2_243) __extension__ ({ \
- int16x8_t __ret_243; \
- int16x8_t __s0_243 = __p0_243; \
- int16x4_t __s1_243 = __p1_243; \
- __ret_243 = vqdmulhq_s16(__s0_243, splatq_lane_s16(__s1_243, __p2_243)); \
- __ret_243; \
-})
-#else
-#define vqdmulhq_lane_s16(__p0_244, __p1_244, __p2_244) __extension__ ({ \
- int16x8_t __ret_244; \
- int16x8_t __s0_244 = __p0_244; \
- int16x4_t __s1_244 = __p1_244; \
- int16x8_t __rev0_244; __rev0_244 = __builtin_shufflevector(__s0_244, __s0_244, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x4_t __rev1_244; __rev1_244 = __builtin_shufflevector(__s1_244, __s1_244, 3, 2, 1, 0); \
- __ret_244 = __noswap_vqdmulhq_s16(__rev0_244, __noswap_splatq_lane_s16(__rev1_244, __p2_244)); \
- __ret_244 = __builtin_shufflevector(__ret_244, __ret_244, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_244; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vqdmulh_lane_s32(__p0_245, __p1_245, __p2_245) __extension__ ({ \
- int32x2_t __ret_245; \
- int32x2_t __s0_245 = __p0_245; \
- int32x2_t __s1_245 = __p1_245; \
- __ret_245 = vqdmulh_s32(__s0_245, splat_lane_s32(__s1_245, __p2_245)); \
- __ret_245; \
-})
-#else
-#define vqdmulh_lane_s32(__p0_246, __p1_246, __p2_246) __extension__ ({ \
- int32x2_t __ret_246; \
- int32x2_t __s0_246 = __p0_246; \
- int32x2_t __s1_246 = __p1_246; \
- int32x2_t __rev0_246; __rev0_246 = __builtin_shufflevector(__s0_246, __s0_246, 1, 0); \
- int32x2_t __rev1_246; __rev1_246 = __builtin_shufflevector(__s1_246, __s1_246, 1, 0); \
- __ret_246 = __noswap_vqdmulh_s32(__rev0_246, __noswap_splat_lane_s32(__rev1_246, __p2_246)); \
- __ret_246 = __builtin_shufflevector(__ret_246, __ret_246, 1, 0); \
- __ret_246; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vqdmulh_lane_s16(__p0_247, __p1_247, __p2_247) __extension__ ({ \
- int16x4_t __ret_247; \
- int16x4_t __s0_247 = __p0_247; \
- int16x4_t __s1_247 = __p1_247; \
- __ret_247 = vqdmulh_s16(__s0_247, splat_lane_s16(__s1_247, __p2_247)); \
- __ret_247; \
-})
-#else
-#define vqdmulh_lane_s16(__p0_248, __p1_248, __p2_248) __extension__ ({ \
- int16x4_t __ret_248; \
- int16x4_t __s0_248 = __p0_248; \
- int16x4_t __s1_248 = __p1_248; \
- int16x4_t __rev0_248; __rev0_248 = __builtin_shufflevector(__s0_248, __s0_248, 3, 2, 1, 0); \
- int16x4_t __rev1_248; __rev1_248 = __builtin_shufflevector(__s1_248, __s1_248, 3, 2, 1, 0); \
- __ret_248 = __noswap_vqdmulh_s16(__rev0_248, __noswap_splat_lane_s16(__rev1_248, __p2_248)); \
- __ret_248 = __builtin_shufflevector(__ret_248, __ret_248, 3, 2, 1, 0); \
- __ret_248; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vqrdmulhq_lane_s32(__p0_249, __p1_249, __p2_249) __extension__ ({ \
- int32x4_t __ret_249; \
- int32x4_t __s0_249 = __p0_249; \
- int32x2_t __s1_249 = __p1_249; \
- __ret_249 = vqrdmulhq_s32(__s0_249, splatq_lane_s32(__s1_249, __p2_249)); \
- __ret_249; \
-})
-#else
-#define vqrdmulhq_lane_s32(__p0_250, __p1_250, __p2_250) __extension__ ({ \
- int32x4_t __ret_250; \
- int32x4_t __s0_250 = __p0_250; \
- int32x2_t __s1_250 = __p1_250; \
- int32x4_t __rev0_250; __rev0_250 = __builtin_shufflevector(__s0_250, __s0_250, 3, 2, 1, 0); \
- int32x2_t __rev1_250; __rev1_250 = __builtin_shufflevector(__s1_250, __s1_250, 1, 0); \
- __ret_250 = __noswap_vqrdmulhq_s32(__rev0_250, __noswap_splatq_lane_s32(__rev1_250, __p2_250)); \
- __ret_250 = __builtin_shufflevector(__ret_250, __ret_250, 3, 2, 1, 0); \
- __ret_250; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vqrdmulhq_lane_s16(__p0_251, __p1_251, __p2_251) __extension__ ({ \
- int16x8_t __ret_251; \
- int16x8_t __s0_251 = __p0_251; \
- int16x4_t __s1_251 = __p1_251; \
- __ret_251 = vqrdmulhq_s16(__s0_251, splatq_lane_s16(__s1_251, __p2_251)); \
- __ret_251; \
-})
-#else
-#define vqrdmulhq_lane_s16(__p0_252, __p1_252, __p2_252) __extension__ ({ \
- int16x8_t __ret_252; \
- int16x8_t __s0_252 = __p0_252; \
- int16x4_t __s1_252 = __p1_252; \
- int16x8_t __rev0_252; __rev0_252 = __builtin_shufflevector(__s0_252, __s0_252, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x4_t __rev1_252; __rev1_252 = __builtin_shufflevector(__s1_252, __s1_252, 3, 2, 1, 0); \
- __ret_252 = __noswap_vqrdmulhq_s16(__rev0_252, __noswap_splatq_lane_s16(__rev1_252, __p2_252)); \
- __ret_252 = __builtin_shufflevector(__ret_252, __ret_252, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_252; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vqrdmulh_lane_s32(__p0_253, __p1_253, __p2_253) __extension__ ({ \
- int32x2_t __ret_253; \
- int32x2_t __s0_253 = __p0_253; \
- int32x2_t __s1_253 = __p1_253; \
- __ret_253 = vqrdmulh_s32(__s0_253, splat_lane_s32(__s1_253, __p2_253)); \
- __ret_253; \
-})
-#else
-#define vqrdmulh_lane_s32(__p0_254, __p1_254, __p2_254) __extension__ ({ \
- int32x2_t __ret_254; \
- int32x2_t __s0_254 = __p0_254; \
- int32x2_t __s1_254 = __p1_254; \
- int32x2_t __rev0_254; __rev0_254 = __builtin_shufflevector(__s0_254, __s0_254, 1, 0); \
- int32x2_t __rev1_254; __rev1_254 = __builtin_shufflevector(__s1_254, __s1_254, 1, 0); \
- __ret_254 = __noswap_vqrdmulh_s32(__rev0_254, __noswap_splat_lane_s32(__rev1_254, __p2_254)); \
- __ret_254 = __builtin_shufflevector(__ret_254, __ret_254, 1, 0); \
- __ret_254; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vqrdmulh_lane_s16(__p0_255, __p1_255, __p2_255) __extension__ ({ \
- int16x4_t __ret_255; \
- int16x4_t __s0_255 = __p0_255; \
- int16x4_t __s1_255 = __p1_255; \
- __ret_255 = vqrdmulh_s16(__s0_255, splat_lane_s16(__s1_255, __p2_255)); \
- __ret_255; \
-})
-#else
-#define vqrdmulh_lane_s16(__p0_256, __p1_256, __p2_256) __extension__ ({ \
- int16x4_t __ret_256; \
- int16x4_t __s0_256 = __p0_256; \
- int16x4_t __s1_256 = __p1_256; \
- int16x4_t __rev0_256; __rev0_256 = __builtin_shufflevector(__s0_256, __s0_256, 3, 2, 1, 0); \
- int16x4_t __rev1_256; __rev1_256 = __builtin_shufflevector(__s1_256, __s1_256, 3, 2, 1, 0); \
- __ret_256 = __noswap_vqrdmulh_s16(__rev0_256, __noswap_splat_lane_s16(__rev1_256, __p2_256)); \
- __ret_256 = __builtin_shufflevector(__ret_256, __ret_256, 3, 2, 1, 0); \
- __ret_256; \
-})
-#endif
-
-__ai poly8x8_t vreinterpret_p8_p16(poly16x4_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_u16(uint16x8_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t)(__p0);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_u8(uint8x8_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_s8(int8x16_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t)(__p0);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_u32(uint32x2_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_f32(float32x4_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t)(__p0);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_u64(uint64x1_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_f16(float16x8_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t)(__p0);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_u16(uint16x4_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_s32(int32x4_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t)(__p0);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_s8(int8x8_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_s16(int16x8_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t)(__p0);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_f32(float32x2_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_p8(poly8x16_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t)(__p0);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_f16(float16x4_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_p16(poly16x8_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t)(__p0);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_s32(int32x2_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_u8(uint8x16_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t)(__p0);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_s64(int64x1_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_u32(uint32x4_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t)(__p0);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_s16(int16x4_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_u64(uint64x2_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t)(__p0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_p8(poly8x8_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_u16(uint16x8_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t)(__p0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_u8(uint8x8_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_s8(int8x16_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t)(__p0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_u32(uint32x2_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_f32(float32x4_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t)(__p0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_u64(uint64x1_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_f16(float16x8_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t)(__p0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_u16(uint16x4_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_s32(int32x4_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t)(__p0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_s8(int8x8_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_s64(int64x2_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t)(__p0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_f32(float32x2_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_p8(poly8x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_f16(float16x4_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_p16(poly16x4_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_s32(int32x2_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_u32(uint32x2_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_s64(int64x1_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_u64(uint64x1_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_s16(int16x4_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_u16(uint16x4_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_p16(poly16x8_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_s8(int8x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_u8(uint8x16_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_f32(float32x2_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_u32(uint32x4_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_f16(float16x4_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_u64(uint64x2_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_s32(int32x2_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_u16(uint16x8_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_s64(int64x1_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_s8(int8x16_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_s16(int16x4_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_f32(float32x4_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_p8(poly8x8_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_f16(float16x8_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_p16(poly16x4_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_s32(int32x4_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_u8(uint8x8_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_s64(int64x2_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_u64(uint64x1_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_s16(int16x8_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_u16(uint16x4_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_p8(poly8x16_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_s8(int8x8_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_u8(uint8x16_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_f32(float32x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_u32(uint32x4_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_f16(float16x4_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_u64(uint64x2_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_s32(int32x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_u16(uint16x8_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_s64(int64x1_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_s8(int8x16_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_s16(int16x4_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_f32(float32x4_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_p8(poly8x8_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_f16(float16x8_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_p16(poly16x4_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_s32(int32x4_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_u8(uint8x8_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_s64(int64x2_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_u32(uint32x2_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_s16(int16x8_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_u16(uint16x4_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_p8(poly8x16_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_s8(int8x8_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_p16(poly16x8_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_f32(float32x2_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_u32(uint32x4_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_f16(float16x4_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_u64(uint64x2_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_s32(int32x2_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_u16(uint16x8_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_s64(int64x1_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_s8(int8x16_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_s16(int16x4_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_f32(float32x4_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_p8(poly8x8_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_f16(float16x8_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_p16(poly16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_s32(int32x4_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_u8(uint8x8_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_s64(int64x2_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_u32(uint32x2_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_s16(int16x8_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_u64(uint64x1_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_p8(poly8x16_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_s8(int8x8_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_p16(poly16x8_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_f32(float32x2_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_u8(uint8x16_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_f16(float16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_u64(uint64x2_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_s32(int32x2_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_u16(uint16x8_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_s64(int64x1_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_s8(int8x16_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_s16(int16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_f32(float32x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_p8(poly8x8_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_f16(float16x8_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_p16(poly16x4_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_s32(int32x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_u8(uint8x8_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_s64(int64x2_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_u32(uint32x2_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_s16(int16x8_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_u64(uint64x1_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_p8(poly8x16_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_u16(uint16x4_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_p16(poly16x8_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_f32(float32x2_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_u8(uint8x16_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_f16(float16x4_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_u32(uint32x4_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_s32(int32x2_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_u16(uint16x8_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_s64(int64x1_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_s8(int8x16_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_s16(int16x4_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_f32(float32x4_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_p8(poly8x8_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_f16(float16x8_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_p16(poly16x4_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_s32(int32x4_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_u8(uint8x8_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_s64(int64x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_u32(uint32x2_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_s16(int16x8_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_u64(uint64x1_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_p8(poly8x16_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_u16(uint16x4_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_p16(poly16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_s8(int8x8_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_u8(uint8x16_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_f16(float16x4_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_u32(uint32x4_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_s32(int32x2_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_u64(uint64x2_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_s64(int64x1_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_s8(int8x16_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_s16(int16x4_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_f32(float32x4_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_p8(poly8x8_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_p16(poly16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_s32(int32x4_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_u8(uint8x8_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_s64(int64x2_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_u32(uint32x2_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_s16(int16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_u64(uint64x1_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_p8(poly8x16_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t)(__p0);
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_u16(uint16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_p16(poly16x8_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t)(__p0);
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_s8(int8x8_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_u8(uint8x16_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t)(__p0);
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_f32(float32x2_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_u32(uint32x4_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t)(__p0);
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_s32(int32x2_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_u64(uint64x2_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t)(__p0);
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_s64(int64x1_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_u16(uint16x8_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t)(__p0);
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_s16(int16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_f32(float32x4_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t)(__p0);
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_p8(poly8x8_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_f16(float16x8_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t)(__p0);
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_p16(poly16x4_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_s32(int32x4_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t)(__p0);
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_u8(uint8x8_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_s64(int64x2_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t)(__p0);
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_u32(uint32x2_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_s16(int16x8_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t)(__p0);
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_u64(uint64x1_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_p8(poly8x16_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t)(__p0);
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_u16(uint16x4_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_p16(poly16x8_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t)(__p0);
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_s8(int8x8_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_u8(uint8x16_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t)(__p0);
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_f32(float32x2_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_u32(uint32x4_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t)(__p0);
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_f16(float16x4_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_u64(uint64x2_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t)(__p0);
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_s64(int64x1_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_u16(uint16x8_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t)(__p0);
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_s16(int16x4_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_s8(int8x16_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t)(__p0);
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_p8(poly8x8_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_f16(float16x8_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t)(__p0);
- return __ret;
-}
-__ai float32x4_t vreinterpretq_f32_s32(int32x4_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t)(__p0);
- return __ret;
-}
-__ai float32x4_t vreinterpretq_f32_s64(int64x2_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t)(__p0);
- return __ret;
-}
-__ai float32x4_t vreinterpretq_f32_s16(int16x8_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t)(__p0);
- return __ret;
-}
-__ai float16x8_t vreinterpretq_f16_p8(poly8x16_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t)(__p0);
- return __ret;
-}
-__ai float16x8_t vreinterpretq_f16_p16(poly16x8_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t)(__p0);
- return __ret;
-}
-__ai float16x8_t vreinterpretq_f16_u8(uint8x16_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t)(__p0);
- return __ret;
-}
-__ai float16x8_t vreinterpretq_f16_u32(uint32x4_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t)(__p0);
- return __ret;
-}
-__ai float16x8_t vreinterpretq_f16_u64(uint64x2_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t)(__p0);
- return __ret;
-}
-__ai float16x8_t vreinterpretq_f16_u16(uint16x8_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t)(__p0);
- return __ret;
-}
-__ai float16x8_t vreinterpretq_f16_s8(int8x16_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t)(__p0);
- return __ret;
-}
-__ai float16x8_t vreinterpretq_f16_f32(float32x4_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t)(__p0);
- return __ret;
-}
-__ai float16x8_t vreinterpretq_f16_s32(int32x4_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t)(__p0);
- return __ret;
-}
-__ai float16x8_t vreinterpretq_f16_s64(int64x2_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t)(__p0);
- return __ret;
-}
-__ai float16x8_t vreinterpretq_f16_s16(int16x8_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t)(__p0);
- return __ret;
-}
-__ai int32x4_t vreinterpretq_s32_p8(poly8x16_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t)(__p0);
- return __ret;
-}
-__ai int32x4_t vreinterpretq_s32_p16(poly16x8_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t)(__p0);
- return __ret;
-}
-__ai int32x4_t vreinterpretq_s32_u8(uint8x16_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t)(__p0);
- return __ret;
-}
-__ai int32x4_t vreinterpretq_s32_u32(uint32x4_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t)(__p0);
- return __ret;
-}
-__ai int32x4_t vreinterpretq_s32_u64(uint64x2_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t)(__p0);
- return __ret;
-}
-__ai int32x4_t vreinterpretq_s32_u16(uint16x8_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t)(__p0);
- return __ret;
-}
-__ai int32x4_t vreinterpretq_s32_s8(int8x16_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t)(__p0);
- return __ret;
-}
-__ai int32x4_t vreinterpretq_s32_f32(float32x4_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t)(__p0);
- return __ret;
-}
-__ai int32x4_t vreinterpretq_s32_f16(float16x8_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t)(__p0);
- return __ret;
-}
-__ai int32x4_t vreinterpretq_s32_s64(int64x2_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t)(__p0);
- return __ret;
-}
-__ai int32x4_t vreinterpretq_s32_s16(int16x8_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t)(__p0);
- return __ret;
-}
-__ai int64x2_t vreinterpretq_s64_p8(poly8x16_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t)(__p0);
- return __ret;
-}
-__ai int64x2_t vreinterpretq_s64_p16(poly16x8_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t)(__p0);
- return __ret;
-}
-__ai int64x2_t vreinterpretq_s64_u8(uint8x16_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t)(__p0);
- return __ret;
-}
-__ai int64x2_t vreinterpretq_s64_u32(uint32x4_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t)(__p0);
- return __ret;
-}
-__ai int64x2_t vreinterpretq_s64_u64(uint64x2_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t)(__p0);
- return __ret;
-}
-__ai int64x2_t vreinterpretq_s64_u16(uint16x8_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t)(__p0);
- return __ret;
-}
-__ai int64x2_t vreinterpretq_s64_s8(int8x16_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t)(__p0);
- return __ret;
-}
-__ai int64x2_t vreinterpretq_s64_f32(float32x4_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t)(__p0);
- return __ret;
-}
-__ai int64x2_t vreinterpretq_s64_f16(float16x8_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t)(__p0);
- return __ret;
-}
-__ai int64x2_t vreinterpretq_s64_s32(int32x4_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t)(__p0);
- return __ret;
-}
-__ai int64x2_t vreinterpretq_s64_s16(int16x8_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t)(__p0);
- return __ret;
-}
-__ai int16x8_t vreinterpretq_s16_p8(poly8x16_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t)(__p0);
- return __ret;
-}
-__ai int16x8_t vreinterpretq_s16_p16(poly16x8_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t)(__p0);
- return __ret;
-}
-__ai int16x8_t vreinterpretq_s16_u8(uint8x16_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t)(__p0);
- return __ret;
-}
-__ai int16x8_t vreinterpretq_s16_u32(uint32x4_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t)(__p0);
- return __ret;
-}
-__ai int16x8_t vreinterpretq_s16_u64(uint64x2_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t)(__p0);
- return __ret;
-}
-__ai int16x8_t vreinterpretq_s16_u16(uint16x8_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t)(__p0);
- return __ret;
-}
-__ai int16x8_t vreinterpretq_s16_s8(int8x16_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t)(__p0);
- return __ret;
-}
-__ai int16x8_t vreinterpretq_s16_f32(float32x4_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t)(__p0);
- return __ret;
-}
-__ai int16x8_t vreinterpretq_s16_f16(float16x8_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t)(__p0);
- return __ret;
-}
-__ai int16x8_t vreinterpretq_s16_s32(int32x4_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t)(__p0);
- return __ret;
-}
-__ai int16x8_t vreinterpretq_s16_s64(int64x2_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t)(__p0);
- return __ret;
-}
-__ai uint8x8_t vreinterpret_u8_p8(poly8x8_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0);
- return __ret;
-}
-__ai uint8x8_t vreinterpret_u8_p16(poly16x4_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0);
- return __ret;
-}
-__ai uint8x8_t vreinterpret_u8_u32(uint32x2_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0);
- return __ret;
-}
-__ai uint8x8_t vreinterpret_u8_u64(uint64x1_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0);
- return __ret;
-}
-__ai uint8x8_t vreinterpret_u8_u16(uint16x4_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0);
- return __ret;
-}
-__ai uint8x8_t vreinterpret_u8_s8(int8x8_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0);
- return __ret;
-}
-__ai uint8x8_t vreinterpret_u8_f32(float32x2_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0);
- return __ret;
-}
-__ai uint8x8_t vreinterpret_u8_f16(float16x4_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0);
- return __ret;
-}
-__ai uint8x8_t vreinterpret_u8_s32(int32x2_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0);
- return __ret;
-}
-__ai uint8x8_t vreinterpret_u8_s64(int64x1_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0);
- return __ret;
-}
-__ai uint8x8_t vreinterpret_u8_s16(int16x4_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0);
- return __ret;
-}
-__ai uint32x2_t vreinterpret_u32_p8(poly8x8_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0);
- return __ret;
-}
-__ai uint32x2_t vreinterpret_u32_p16(poly16x4_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0);
- return __ret;
-}
-__ai uint32x2_t vreinterpret_u32_u8(uint8x8_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0);
- return __ret;
-}
-__ai uint32x2_t vreinterpret_u32_u64(uint64x1_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0);
- return __ret;
-}
-__ai uint32x2_t vreinterpret_u32_u16(uint16x4_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0);
- return __ret;
-}
-__ai uint32x2_t vreinterpret_u32_s8(int8x8_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0);
- return __ret;
-}
-__ai uint32x2_t vreinterpret_u32_f32(float32x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0);
- return __ret;
-}
-__ai uint32x2_t vreinterpret_u32_f16(float16x4_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0);
- return __ret;
-}
-__ai uint32x2_t vreinterpret_u32_s32(int32x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0);
- return __ret;
-}
-__ai uint32x2_t vreinterpret_u32_s64(int64x1_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0);
- return __ret;
-}
-__ai uint32x2_t vreinterpret_u32_s16(int16x4_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0);
- return __ret;
-}
-__ai uint64x1_t vreinterpret_u64_p8(poly8x8_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0);
- return __ret;
-}
-__ai uint64x1_t vreinterpret_u64_p16(poly16x4_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0);
- return __ret;
-}
-__ai uint64x1_t vreinterpret_u64_u8(uint8x8_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0);
- return __ret;
-}
-__ai uint64x1_t vreinterpret_u64_u32(uint32x2_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0);
- return __ret;
-}
-__ai uint64x1_t vreinterpret_u64_u16(uint16x4_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0);
- return __ret;
-}
-__ai uint64x1_t vreinterpret_u64_s8(int8x8_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0);
- return __ret;
-}
-__ai uint64x1_t vreinterpret_u64_f32(float32x2_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0);
- return __ret;
-}
-__ai uint64x1_t vreinterpret_u64_f16(float16x4_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0);
- return __ret;
-}
-__ai uint64x1_t vreinterpret_u64_s32(int32x2_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0);
- return __ret;
-}
-__ai uint64x1_t vreinterpret_u64_s64(int64x1_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0);
- return __ret;
-}
-__ai uint64x1_t vreinterpret_u64_s16(int16x4_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0);
- return __ret;
-}
-__ai uint16x4_t vreinterpret_u16_p8(poly8x8_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0);
- return __ret;
-}
-__ai uint16x4_t vreinterpret_u16_p16(poly16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0);
- return __ret;
-}
-__ai uint16x4_t vreinterpret_u16_u8(uint8x8_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0);
- return __ret;
-}
-__ai uint16x4_t vreinterpret_u16_u32(uint32x2_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0);
- return __ret;
-}
-__ai uint16x4_t vreinterpret_u16_u64(uint64x1_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0);
- return __ret;
-}
-__ai uint16x4_t vreinterpret_u16_s8(int8x8_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0);
- return __ret;
-}
-__ai uint16x4_t vreinterpret_u16_f32(float32x2_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0);
- return __ret;
-}
-__ai uint16x4_t vreinterpret_u16_f16(float16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0);
- return __ret;
-}
-__ai uint16x4_t vreinterpret_u16_s32(int32x2_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0);
- return __ret;
-}
-__ai uint16x4_t vreinterpret_u16_s64(int64x1_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0);
- return __ret;
-}
-__ai uint16x4_t vreinterpret_u16_s16(int16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_p8(poly8x8_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_p16(poly16x4_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_u8(uint8x8_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_u32(uint32x2_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_u64(uint64x1_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_u16(uint16x4_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_f32(float32x2_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_f16(float16x4_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_p16(poly16x4_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
return __ret;
}
-__ai int8x8_t vreinterpret_s8_s32(int32x2_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_u8(uint8x8_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
return __ret;
}
-__ai int8x8_t vreinterpret_s8_s64(int64x1_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_u32(uint32x2_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
return __ret;
}
-__ai int8x8_t vreinterpret_s8_s16(int16x4_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_u64(uint64x1_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
return __ret;
}
-__ai float32x2_t vreinterpret_f32_p8(poly8x8_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_u16(uint16x4_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
return __ret;
}
-__ai float32x2_t vreinterpret_f32_p16(poly16x4_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_s8(int8x8_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
return __ret;
}
-__ai float32x2_t vreinterpret_f32_u8(uint8x8_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_f32(float32x2_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
return __ret;
}
-__ai float32x2_t vreinterpret_f32_u32(uint32x2_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_f16(float16x4_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
return __ret;
}
-__ai float32x2_t vreinterpret_f32_u64(uint64x1_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_s32(int32x2_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
return __ret;
}
-__ai float32x2_t vreinterpret_f32_u16(uint16x4_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_s16(int16x4_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
return __ret;
}
-__ai float32x2_t vreinterpret_f32_s8(int8x8_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_p8(poly8x8_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
return __ret;
}
-__ai float32x2_t vreinterpret_f32_f16(float16x4_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_p16(poly16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
return __ret;
}
-__ai float32x2_t vreinterpret_f32_s32(int32x2_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_u8(uint8x8_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
return __ret;
}
-__ai float32x2_t vreinterpret_f32_s64(int64x1_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_u32(uint32x2_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
return __ret;
}
-__ai float32x2_t vreinterpret_f32_s16(int16x4_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_u64(uint64x1_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
return __ret;
}
-__ai float16x4_t vreinterpret_f16_p8(poly8x8_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_u16(uint16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
return __ret;
}
-__ai float16x4_t vreinterpret_f16_p16(poly16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_s8(int8x8_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
return __ret;
}
-__ai float16x4_t vreinterpret_f16_u8(uint8x8_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_f32(float32x2_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
return __ret;
}
-__ai float16x4_t vreinterpret_f16_u32(uint32x2_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_f16(float16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
return __ret;
}
-__ai float16x4_t vreinterpret_f16_u64(uint64x1_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_s32(int32x2_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
return __ret;
}
-__ai float16x4_t vreinterpret_f16_u16(uint16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_s64(int64x1_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
return __ret;
}
-__ai float16x4_t vreinterpret_f16_s8(int8x8_t __p0) {
+#endif
+#if (__ARM_FP & 2)
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x4_t vcvt_f16_f32(float32x4_t __p0) {
float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
+ __ret = (float16x4_t) __builtin_neon_vcvt_f16_f32((int8x16_t)__p0, 41);
return __ret;
}
-__ai float16x4_t vreinterpret_f16_f32(float32x2_t __p0) {
+#else
+__ai __attribute__((target("neon"))) float16x4_t vcvt_f16_f32(float32x4_t __p0) {
float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vcvt_f16_f32((int8x16_t)__rev0, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai float16x4_t vreinterpret_f16_s32(int32x2_t __p0) {
+__ai __attribute__((target("neon"))) float16x4_t __noswap_vcvt_f16_f32(float32x4_t __p0) {
float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
+ __ret = (float16x4_t) __builtin_neon_vcvt_f16_f32((int8x16_t)__p0, 41);
return __ret;
}
-__ai float16x4_t vreinterpret_f16_s64(int64x1_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vcvt_f32_f16(float16x4_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vcvt_f32_f16((int8x8_t)__p0, 8);
return __ret;
}
-__ai float16x4_t vreinterpret_f16_s16(int16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) float32x4_t vcvt_f32_f16(float16x4_t __p0) {
+ float32x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vcvt_f32_f16((int8x8_t)__rev0, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int32x2_t vreinterpret_s32_p8(poly8x8_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_p16(poly16x4_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_u8(uint8x8_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_u32(uint32x2_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_u64(uint64x1_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_u16(uint16x4_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_s8(int8x8_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_f32(float32x2_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_f16(float16x4_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_s64(int64x1_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_s16(int16x4_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_p8(poly8x8_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_p16(poly16x4_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_u8(uint8x8_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_u32(uint32x2_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_u64(uint64x1_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_u16(uint16x4_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_s8(int8x8_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_f32(float32x2_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_f16(float16x4_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_s32(int32x2_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_s16(int16x4_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_p8(poly8x8_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_p16(poly16x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_u8(uint8x8_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_u32(uint32x2_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_u64(uint64x1_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_u16(uint16x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_s8(int8x8_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_f32(float32x2_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_f16(float16x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_s32(int32x2_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_s64(int64x1_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) bfloat16x4_t __a32_vcvt_bf16_f32(float32x4_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t) __builtin_neon___a32_vcvt_bf16_f32((int8x16_t)__p0, 11);
- return __ret;
-}
-#else
-__ai __attribute__((target("bf16"))) bfloat16x4_t __a32_vcvt_bf16_f32(float32x4_t __p0) {
- bfloat16x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (bfloat16x4_t) __builtin_neon___a32_vcvt_bf16_f32((int8x16_t)__rev0, 11);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x4_t __noswap___a32_vcvt_bf16_f32(float32x4_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t) __builtin_neon___a32_vcvt_bf16_f32((int8x16_t)__p0, 11);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) bfloat16x4_t vcvt_bf16_f32(float32x4_t __p0) {
- bfloat16x4_t __ret;
- __ret = __a32_vcvt_bf16_f32(__p0);
- return __ret;
-}
-#else
-__ai __attribute__((target("bf16"))) bfloat16x4_t vcvt_bf16_f32(float32x4_t __p0) {
- bfloat16x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __noswap___a32_vcvt_bf16_f32(__rev0);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) bfloat16x8_t vcvtq_high_bf16_f32(bfloat16x8_t __p0, float32x4_t __p1) {
- bfloat16x8_t __ret;
- __ret = vcombine_bf16(__a32_vcvt_bf16_f32(__p1), vget_low_bf16(__p0));
- return __ret;
-}
-#else
-__ai __attribute__((target("bf16"))) bfloat16x8_t vcvtq_high_bf16_f32(bfloat16x8_t __p0, float32x4_t __p1) {
- bfloat16x8_t __ret;
- bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vcombine_bf16(__noswap___a32_vcvt_bf16_f32(__rev1), __noswap_vget_low_bf16(__rev0));
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) bfloat16x8_t vcvtq_low_bf16_f32(float32x4_t __p0) {
- bfloat16x8_t __ret;
- __ret = vcombine_bf16((bfloat16x4_t)(0ULL), __a32_vcvt_bf16_f32(__p0));
- return __ret;
-}
-#else
-__ai __attribute__((target("bf16"))) bfloat16x8_t vcvtq_low_bf16_f32(float32x4_t __p0) {
- bfloat16x8_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __noswap_vcombine_bf16((bfloat16x4_t)(0ULL), __noswap___a32_vcvt_bf16_f32(__rev0));
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-__ai __attribute__((target("bf16"))) poly8x8_t vreinterpret_p8_bf16(bfloat16x4_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) poly64x1_t vreinterpret_p64_bf16(bfloat16x4_t __p0) {
- poly64x1_t __ret;
- __ret = (poly64x1_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) poly16x4_t vreinterpret_p16_bf16(bfloat16x4_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) poly8x16_t vreinterpretq_p8_bf16(bfloat16x8_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) poly64x2_t vreinterpretq_p64_bf16(bfloat16x8_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) poly16x8_t vreinterpretq_p16_bf16(bfloat16x8_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) uint8x16_t vreinterpretq_u8_bf16(bfloat16x8_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) uint32x4_t vreinterpretq_u32_bf16(bfloat16x8_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) uint64x2_t vreinterpretq_u64_bf16(bfloat16x8_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) uint16x8_t vreinterpretq_u16_bf16(bfloat16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) int8x16_t vreinterpretq_s8_bf16(bfloat16x8_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) float32x4_t vreinterpretq_f32_bf16(bfloat16x8_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) float16x8_t vreinterpretq_f16_bf16(bfloat16x8_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) int32x4_t vreinterpretq_s32_bf16(bfloat16x8_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) int64x2_t vreinterpretq_s64_bf16(bfloat16x8_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) int16x8_t vreinterpretq_s16_bf16(bfloat16x8_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) uint8x8_t vreinterpret_u8_bf16(bfloat16x4_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) uint32x2_t vreinterpret_u32_bf16(bfloat16x4_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) uint64x1_t vreinterpret_u64_bf16(bfloat16x4_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) uint16x4_t vreinterpret_u16_bf16(bfloat16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) int8x8_t vreinterpret_s8_bf16(bfloat16x4_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) float32x2_t vreinterpret_f32_bf16(bfloat16x4_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) float16x4_t vreinterpret_f16_bf16(bfloat16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) int32x2_t vreinterpret_s32_bf16(bfloat16x4_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) int64x1_t vreinterpret_s64_bf16(bfloat16x4_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) int16x4_t vreinterpret_s16_bf16(bfloat16x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_p8(poly8x16_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_p64(poly64x2_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_p16(poly16x8_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_u8(uint8x16_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_u32(uint32x4_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_u64(uint64x2_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_u16(uint16x8_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_s8(int8x16_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_f32(float32x4_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_f16(float16x8_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_s32(int32x4_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_s64(int64x2_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_s16(int16x8_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_p8(poly8x8_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_p64(poly64x1_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_p16(poly16x4_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_u8(uint8x8_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_u32(uint32x2_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_u64(uint64x1_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_u16(uint16x4_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_s8(int8x8_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_f32(float32x2_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_f16(float16x4_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_s32(int32x2_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_s64(int64x1_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_s16(int16x4_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
- return __ret;
-}
-#endif
-#if (__ARM_FP & 2)
-#ifdef __LITTLE_ENDIAN__
-__ai float16x4_t vcvt_f16_f32(float32x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vcvt_f16_f32((int8x16_t)__p0, 41);
- return __ret;
-}
-#else
-__ai float16x4_t vcvt_f16_f32(float32x4_t __p0) {
- float16x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vcvt_f16_f32((int8x16_t)__rev0, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai float16x4_t __noswap_vcvt_f16_f32(float32x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vcvt_f16_f32((int8x16_t)__p0, 41);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vcvt_f32_f16(float16x4_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vcvt_f32_f16((int8x8_t)__p0, 8);
- return __ret;
-}
-#else
-__ai float32x4_t vcvt_f32_f16(float16x4_t __p0) {
- float32x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vcvt_f32_f16((int8x8_t)__rev0, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai float32x4_t __noswap_vcvt_f32_f16(float16x4_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vcvt_f32_f16((int8x8_t)__p0, 8);
+__ai __attribute__((target("neon"))) float32x4_t __noswap_vcvt_f32_f16(float16x4_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vcvt_f32_f16((int8x8_t)__p0, 8);
return __ret;
}
#endif
@@ -40237,16 +39888,277 @@ __ai float32x4_t __noswap_vcvt_f32_f16(float16x4_t __p0) {
})
#endif
+#endif
+#if (defined(__aarch64__) || defined(__arm64ec__)) && defined(__ARM_FEATURE_NUMERIC_MAXMIN)
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vmaxnmq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vmaxnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vmaxnmq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vmaxnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vmaxnm_f64(float64x1_t __p0, float64x1_t __p1) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vmaxnm_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
+ return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vminnmq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vminnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vminnmq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vminnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vminnm_f64(float64x1_t __p0, float64x1_t __p1) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vminnm_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
+ return __ret;
+}
+#endif
+#if (defined(__aarch64__) || defined(__arm64ec__)) && defined(__ARM_FEATURE_DIRECTED_ROUNDING)
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrndq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vrndq_v((int8x16_t)__p0, 42);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrndq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vrndq_v((int8x16_t)__rev0, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrnd_f64(float64x1_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vrnd_v((int8x8_t)__p0, 10);
+ return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrndaq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vrndaq_v((int8x16_t)__p0, 42);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrndaq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vrndaq_v((int8x16_t)__rev0, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrnda_f64(float64x1_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vrnda_v((int8x8_t)__p0, 10);
+ return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrndiq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vrndiq_v((int8x16_t)__p0, 42);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrndiq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vrndiq_v((int8x16_t)__rev0, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrndi_f64(float64x1_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vrndi_v((int8x8_t)__p0, 10);
+ return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrndmq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vrndmq_v((int8x16_t)__p0, 42);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrndmq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vrndmq_v((int8x16_t)__rev0, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrndm_f64(float64x1_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vrndm_v((int8x8_t)__p0, 10);
+ return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrndnq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vrndnq_v((int8x16_t)__p0, 42);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrndnq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vrndnq_v((int8x16_t)__rev0, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrndn_f64(float64x1_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vrndn_v((int8x8_t)__p0, 10);
+ return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrndpq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vrndpq_v((int8x16_t)__p0, 42);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrndpq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vrndpq_v((int8x16_t)__rev0, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrndp_f64(float64x1_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vrndp_v((int8x8_t)__p0, 10);
+ return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrndxq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vrndxq_v((int8x16_t)__p0, 42);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrndxq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vrndxq_v((int8x16_t)__rev0, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrndx_f64(float64x1_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vrndx_v((int8x8_t)__p0, 10);
+ return __ret;
+}
#endif
#if __ARM_ARCH >= 8
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vcvtaq_s32_f32(float32x4_t __p0) {
+__ai __attribute__((target("aes,neon"))) uint8x16_t vaesdq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vaesdq_u8((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ return __ret;
+}
+#else
+__ai __attribute__((target("aes,neon"))) uint8x16_t vaesdq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vaesdq_u8((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("aes,neon"))) uint8x16_t vaeseq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vaeseq_u8((int8x16_t)__p0, (int8x16_t)__p1, 48);
+ return __ret;
+}
+#else
+__ai __attribute__((target("aes,neon"))) uint8x16_t vaeseq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vaeseq_u8((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("aes,neon"))) uint8x16_t vaesimcq_u8(uint8x16_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vaesimcq_u8((int8x16_t)__p0, 48);
+ return __ret;
+}
+#else
+__ai __attribute__((target("aes,neon"))) uint8x16_t vaesimcq_u8(uint8x16_t __p0) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vaesimcq_u8((int8x16_t)__rev0, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("aes,neon"))) uint8x16_t vaesmcq_u8(uint8x16_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vaesmcq_u8((int8x16_t)__p0, 48);
+ return __ret;
+}
+#else
+__ai __attribute__((target("aes,neon"))) uint8x16_t vaesmcq_u8(uint8x16_t __p0) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vaesmcq_u8((int8x16_t)__rev0, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vcvtaq_s32_f32(float32x4_t __p0) {
int32x4_t __ret;
__ret = (int32x4_t) __builtin_neon_vcvtaq_s32_v((int8x16_t)__p0, 34);
return __ret;
}
#else
-__ai int32x4_t vcvtaq_s32_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vcvtaq_s32_f32(float32x4_t __p0) {
int32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (int32x4_t) __builtin_neon_vcvtaq_s32_v((int8x16_t)__rev0, 34);
@@ -40256,13 +40168,13 @@ __ai int32x4_t vcvtaq_s32_f32(float32x4_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vcvta_s32_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vcvta_s32_f32(float32x2_t __p0) {
int32x2_t __ret;
__ret = (int32x2_t) __builtin_neon_vcvta_s32_v((int8x8_t)__p0, 2);
return __ret;
}
#else
-__ai int32x2_t vcvta_s32_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vcvta_s32_f32(float32x2_t __p0) {
int32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (int32x2_t) __builtin_neon_vcvta_s32_v((int8x8_t)__rev0, 2);
@@ -40272,13 +40184,13 @@ __ai int32x2_t vcvta_s32_f32(float32x2_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcvtaq_u32_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vcvtaq_u32_f32(float32x4_t __p0) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vcvtaq_u32_v((int8x16_t)__p0, 50);
return __ret;
}
#else
-__ai uint32x4_t vcvtaq_u32_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vcvtaq_u32_f32(float32x4_t __p0) {
uint32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (uint32x4_t) __builtin_neon_vcvtaq_u32_v((int8x16_t)__rev0, 50);
@@ -40288,13 +40200,13 @@ __ai uint32x4_t vcvtaq_u32_f32(float32x4_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcvta_u32_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vcvta_u32_f32(float32x2_t __p0) {
uint32x2_t __ret;
__ret = (uint32x2_t) __builtin_neon_vcvta_u32_v((int8x8_t)__p0, 18);
return __ret;
}
#else
-__ai uint32x2_t vcvta_u32_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vcvta_u32_f32(float32x2_t __p0) {
uint32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (uint32x2_t) __builtin_neon_vcvta_u32_v((int8x8_t)__rev0, 18);
@@ -40304,13 +40216,13 @@ __ai uint32x2_t vcvta_u32_f32(float32x2_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vcvtmq_s32_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vcvtmq_s32_f32(float32x4_t __p0) {
int32x4_t __ret;
__ret = (int32x4_t) __builtin_neon_vcvtmq_s32_v((int8x16_t)__p0, 34);
return __ret;
}
#else
-__ai int32x4_t vcvtmq_s32_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vcvtmq_s32_f32(float32x4_t __p0) {
int32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (int32x4_t) __builtin_neon_vcvtmq_s32_v((int8x16_t)__rev0, 34);
@@ -40320,13 +40232,13 @@ __ai int32x4_t vcvtmq_s32_f32(float32x4_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vcvtm_s32_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vcvtm_s32_f32(float32x2_t __p0) {
int32x2_t __ret;
__ret = (int32x2_t) __builtin_neon_vcvtm_s32_v((int8x8_t)__p0, 2);
return __ret;
}
#else
-__ai int32x2_t vcvtm_s32_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vcvtm_s32_f32(float32x2_t __p0) {
int32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (int32x2_t) __builtin_neon_vcvtm_s32_v((int8x8_t)__rev0, 2);
@@ -40336,13 +40248,13 @@ __ai int32x2_t vcvtm_s32_f32(float32x2_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcvtmq_u32_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vcvtmq_u32_f32(float32x4_t __p0) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vcvtmq_u32_v((int8x16_t)__p0, 50);
return __ret;
}
#else
-__ai uint32x4_t vcvtmq_u32_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vcvtmq_u32_f32(float32x4_t __p0) {
uint32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (uint32x4_t) __builtin_neon_vcvtmq_u32_v((int8x16_t)__rev0, 50);
@@ -40352,13 +40264,13 @@ __ai uint32x4_t vcvtmq_u32_f32(float32x4_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcvtm_u32_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vcvtm_u32_f32(float32x2_t __p0) {
uint32x2_t __ret;
__ret = (uint32x2_t) __builtin_neon_vcvtm_u32_v((int8x8_t)__p0, 18);
return __ret;
}
#else
-__ai uint32x2_t vcvtm_u32_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vcvtm_u32_f32(float32x2_t __p0) {
uint32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (uint32x2_t) __builtin_neon_vcvtm_u32_v((int8x8_t)__rev0, 18);
@@ -40368,13 +40280,13 @@ __ai uint32x2_t vcvtm_u32_f32(float32x2_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vcvtnq_s32_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vcvtnq_s32_f32(float32x4_t __p0) {
int32x4_t __ret;
__ret = (int32x4_t) __builtin_neon_vcvtnq_s32_v((int8x16_t)__p0, 34);
return __ret;
}
#else
-__ai int32x4_t vcvtnq_s32_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vcvtnq_s32_f32(float32x4_t __p0) {
int32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (int32x4_t) __builtin_neon_vcvtnq_s32_v((int8x16_t)__rev0, 34);
@@ -40384,13 +40296,13 @@ __ai int32x4_t vcvtnq_s32_f32(float32x4_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vcvtn_s32_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vcvtn_s32_f32(float32x2_t __p0) {
int32x2_t __ret;
__ret = (int32x2_t) __builtin_neon_vcvtn_s32_v((int8x8_t)__p0, 2);
return __ret;
}
#else
-__ai int32x2_t vcvtn_s32_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vcvtn_s32_f32(float32x2_t __p0) {
int32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (int32x2_t) __builtin_neon_vcvtn_s32_v((int8x8_t)__rev0, 2);
@@ -40400,13 +40312,13 @@ __ai int32x2_t vcvtn_s32_f32(float32x2_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcvtnq_u32_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vcvtnq_u32_f32(float32x4_t __p0) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vcvtnq_u32_v((int8x16_t)__p0, 50);
return __ret;
}
#else
-__ai uint32x4_t vcvtnq_u32_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vcvtnq_u32_f32(float32x4_t __p0) {
uint32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (uint32x4_t) __builtin_neon_vcvtnq_u32_v((int8x16_t)__rev0, 50);
@@ -40416,13 +40328,13 @@ __ai uint32x4_t vcvtnq_u32_f32(float32x4_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcvtn_u32_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vcvtn_u32_f32(float32x2_t __p0) {
uint32x2_t __ret;
__ret = (uint32x2_t) __builtin_neon_vcvtn_u32_v((int8x8_t)__p0, 18);
return __ret;
}
#else
-__ai uint32x2_t vcvtn_u32_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vcvtn_u32_f32(float32x2_t __p0) {
uint32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (uint32x2_t) __builtin_neon_vcvtn_u32_v((int8x8_t)__rev0, 18);
@@ -40432,13 +40344,13 @@ __ai uint32x2_t vcvtn_u32_f32(float32x2_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vcvtpq_s32_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vcvtpq_s32_f32(float32x4_t __p0) {
int32x4_t __ret;
__ret = (int32x4_t) __builtin_neon_vcvtpq_s32_v((int8x16_t)__p0, 34);
return __ret;
}
#else
-__ai int32x4_t vcvtpq_s32_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vcvtpq_s32_f32(float32x4_t __p0) {
int32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (int32x4_t) __builtin_neon_vcvtpq_s32_v((int8x16_t)__rev0, 34);
@@ -40448,13 +40360,13 @@ __ai int32x4_t vcvtpq_s32_f32(float32x4_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vcvtp_s32_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vcvtp_s32_f32(float32x2_t __p0) {
int32x2_t __ret;
__ret = (int32x2_t) __builtin_neon_vcvtp_s32_v((int8x8_t)__p0, 2);
return __ret;
}
#else
-__ai int32x2_t vcvtp_s32_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x2_t vcvtp_s32_f32(float32x2_t __p0) {
int32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (int32x2_t) __builtin_neon_vcvtp_s32_v((int8x8_t)__rev0, 2);
@@ -40464,13 +40376,13 @@ __ai int32x2_t vcvtp_s32_f32(float32x2_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcvtpq_u32_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vcvtpq_u32_f32(float32x4_t __p0) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vcvtpq_u32_v((int8x16_t)__p0, 50);
return __ret;
}
#else
-__ai uint32x4_t vcvtpq_u32_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x4_t vcvtpq_u32_f32(float32x4_t __p0) {
uint32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (uint32x4_t) __builtin_neon_vcvtpq_u32_v((int8x16_t)__rev0, 50);
@@ -40480,13 +40392,13 @@ __ai uint32x4_t vcvtpq_u32_f32(float32x4_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcvtp_u32_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vcvtp_u32_f32(float32x2_t __p0) {
uint32x2_t __ret;
__ret = (uint32x2_t) __builtin_neon_vcvtp_u32_v((int8x8_t)__p0, 18);
return __ret;
}
#else
-__ai uint32x2_t vcvtp_u32_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vcvtp_u32_f32(float32x2_t __p0) {
uint32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (uint32x2_t) __builtin_neon_vcvtp_u32_v((int8x8_t)__rev0, 18);
@@ -40496,79 +40408,13 @@ __ai uint32x2_t vcvtp_u32_f32(float32x2_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("aes"))) uint8x16_t vaesdq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vaesdq_u8((int8x16_t)__p0, (int8x16_t)__p1, 48);
- return __ret;
-}
-#else
-__ai __attribute__((target("aes"))) uint8x16_t vaesdq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vaesdq_u8((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("aes"))) uint8x16_t vaeseq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vaeseq_u8((int8x16_t)__p0, (int8x16_t)__p1, 48);
- return __ret;
-}
-#else
-__ai __attribute__((target("aes"))) uint8x16_t vaeseq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vaeseq_u8((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("aes"))) uint8x16_t vaesimcq_u8(uint8x16_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vaesimcq_u8((int8x16_t)__p0, 48);
- return __ret;
-}
-#else
-__ai __attribute__((target("aes"))) uint8x16_t vaesimcq_u8(uint8x16_t __p0) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vaesimcq_u8((int8x16_t)__rev0, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("aes"))) uint8x16_t vaesmcq_u8(uint8x16_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vaesmcq_u8((int8x16_t)__p0, 48);
- return __ret;
-}
-#else
-__ai __attribute__((target("aes"))) uint8x16_t vaesmcq_u8(uint8x16_t __p0) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vaesmcq_u8((int8x16_t)__rev0, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha2"))) uint32x4_t vsha1cq_u32(uint32x4_t __p0, uint32_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1cq_u32(uint32x4_t __p0, uint32_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vsha1cq_u32(__p0, __p1, __p2);
return __ret;
}
#else
-__ai __attribute__((target("sha2"))) uint32x4_t vsha1cq_u32(uint32x4_t __p0, uint32_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1cq_u32(uint32x4_t __p0, uint32_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
@@ -40578,19 +40424,19 @@ __ai __attribute__((target("sha2"))) uint32x4_t vsha1cq_u32(uint32x4_t __p0, uin
}
#endif
-__ai __attribute__((target("sha2"))) uint32_t vsha1h_u32(uint32_t __p0) {
+__ai __attribute__((target("sha2,neon"))) uint32_t vsha1h_u32(uint32_t __p0) {
uint32_t __ret;
__ret = (uint32_t) __builtin_neon_vsha1h_u32(__p0);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha2"))) uint32x4_t vsha1mq_u32(uint32x4_t __p0, uint32_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1mq_u32(uint32x4_t __p0, uint32_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vsha1mq_u32(__p0, __p1, __p2);
return __ret;
}
#else
-__ai __attribute__((target("sha2"))) uint32x4_t vsha1mq_u32(uint32x4_t __p0, uint32_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1mq_u32(uint32x4_t __p0, uint32_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
@@ -40601,13 +40447,13 @@ __ai __attribute__((target("sha2"))) uint32x4_t vsha1mq_u32(uint32x4_t __p0, uin
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha2"))) uint32x4_t vsha1pq_u32(uint32x4_t __p0, uint32_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1pq_u32(uint32x4_t __p0, uint32_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vsha1pq_u32(__p0, __p1, __p2);
return __ret;
}
#else
-__ai __attribute__((target("sha2"))) uint32x4_t vsha1pq_u32(uint32x4_t __p0, uint32_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1pq_u32(uint32x4_t __p0, uint32_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
@@ -40618,13 +40464,13 @@ __ai __attribute__((target("sha2"))) uint32x4_t vsha1pq_u32(uint32x4_t __p0, uin
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha2"))) uint32x4_t vsha1su0q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1su0q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vsha1su0q_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
return __ret;
}
#else
-__ai __attribute__((target("sha2"))) uint32x4_t vsha1su0q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1su0q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -40636,13 +40482,13 @@ __ai __attribute__((target("sha2"))) uint32x4_t vsha1su0q_u32(uint32x4_t __p0, u
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha2"))) uint32x4_t vsha1su1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1su1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vsha1su1q_u32((int8x16_t)__p0, (int8x16_t)__p1, 50);
return __ret;
}
#else
-__ai __attribute__((target("sha2"))) uint32x4_t vsha1su1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1su1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -40653,13 +40499,13 @@ __ai __attribute__((target("sha2"))) uint32x4_t vsha1su1q_u32(uint32x4_t __p0, u
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha2"))) uint32x4_t vsha256hq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha256hq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vsha256hq_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
return __ret;
}
#else
-__ai __attribute__((target("sha2"))) uint32x4_t vsha256hq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha256hq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -40671,13 +40517,13 @@ __ai __attribute__((target("sha2"))) uint32x4_t vsha256hq_u32(uint32x4_t __p0, u
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha2"))) uint32x4_t vsha256h2q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha256h2q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vsha256h2q_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
return __ret;
}
#else
-__ai __attribute__((target("sha2"))) uint32x4_t vsha256h2q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha256h2q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -40689,13 +40535,13 @@ __ai __attribute__((target("sha2"))) uint32x4_t vsha256h2q_u32(uint32x4_t __p0,
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha2"))) uint32x4_t vsha256su0q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha256su0q_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vsha256su0q_u32((int8x16_t)__p0, (int8x16_t)__p1, 50);
return __ret;
}
#else
-__ai __attribute__((target("sha2"))) uint32x4_t vsha256su0q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha256su0q_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -40706,13 +40552,13 @@ __ai __attribute__((target("sha2"))) uint32x4_t vsha256su0q_u32(uint32x4_t __p0,
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha2"))) uint32x4_t vsha256su1q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha256su1q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vsha256su1q_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
return __ret;
}
#else
-__ai __attribute__((target("sha2"))) uint32x4_t vsha256su1q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha256su1q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -40726,13 +40572,205 @@ __ai __attribute__((target("sha2"))) uint32x4_t vsha256su1q_u32(uint32x4_t __p0,
#endif
#if __ARM_ARCH >= 8 && defined(__ARM_FEATURE_DIRECTED_ROUNDING)
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vrndq_f32(float32x4_t __p0) {
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vrndq_f16((int8x16_t)__p0, 40);
+ return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vrndq_f16((int8x16_t)__rev0, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrnd_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vrnd_f16((int8x8_t)__p0, 8);
+ return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrnd_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vrnd_f16((int8x8_t)__rev0, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndaq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vrndaq_f16((int8x16_t)__p0, 40);
+ return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndaq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vrndaq_f16((int8x16_t)__rev0, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrnda_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vrnda_f16((int8x8_t)__p0, 8);
+ return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrnda_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vrnda_f16((int8x8_t)__rev0, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndmq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vrndmq_f16((int8x16_t)__p0, 40);
+ return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndmq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vrndmq_f16((int8x16_t)__rev0, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndm_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vrndm_f16((int8x8_t)__p0, 8);
+ return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndm_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vrndm_f16((int8x8_t)__rev0, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndnq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vrndnq_f16((int8x16_t)__p0, 40);
+ return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndnq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vrndnq_f16((int8x16_t)__rev0, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndn_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vrndn_f16((int8x8_t)__p0, 8);
+ return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndn_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vrndn_f16((int8x8_t)__rev0, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndpq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vrndpq_f16((int8x16_t)__p0, 40);
+ return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndpq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vrndpq_f16((int8x16_t)__rev0, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndp_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vrndp_f16((int8x8_t)__p0, 8);
+ return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndp_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vrndp_f16((int8x8_t)__rev0, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndxq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vrndxq_f16((int8x16_t)__p0, 40);
+ return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndxq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vrndxq_f16((int8x16_t)__rev0, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndx_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vrndx_f16((int8x8_t)__p0, 8);
+ return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndx_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vrndx_f16((int8x8_t)__rev0, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vrndq_f32(float32x4_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t) __builtin_neon_vrndq_v((int8x16_t)__p0, 41);
return __ret;
}
#else
-__ai float32x4_t vrndq_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vrndq_f32(float32x4_t __p0) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (float32x4_t) __builtin_neon_vrndq_v((int8x16_t)__rev0, 41);
@@ -40742,13 +40780,13 @@ __ai float32x4_t vrndq_f32(float32x4_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vrnd_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vrnd_f32(float32x2_t __p0) {
float32x2_t __ret;
__ret = (float32x2_t) __builtin_neon_vrnd_v((int8x8_t)__p0, 9);
return __ret;
}
#else
-__ai float32x2_t vrnd_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vrnd_f32(float32x2_t __p0) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (float32x2_t) __builtin_neon_vrnd_v((int8x8_t)__rev0, 9);
@@ -40758,13 +40796,13 @@ __ai float32x2_t vrnd_f32(float32x2_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vrndaq_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vrndaq_f32(float32x4_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t) __builtin_neon_vrndaq_v((int8x16_t)__p0, 41);
return __ret;
}
#else
-__ai float32x4_t vrndaq_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vrndaq_f32(float32x4_t __p0) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (float32x4_t) __builtin_neon_vrndaq_v((int8x16_t)__rev0, 41);
@@ -40774,13 +40812,13 @@ __ai float32x4_t vrndaq_f32(float32x4_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vrnda_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vrnda_f32(float32x2_t __p0) {
float32x2_t __ret;
__ret = (float32x2_t) __builtin_neon_vrnda_v((int8x8_t)__p0, 9);
return __ret;
}
#else
-__ai float32x2_t vrnda_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vrnda_f32(float32x2_t __p0) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (float32x2_t) __builtin_neon_vrnda_v((int8x8_t)__rev0, 9);
@@ -40790,13 +40828,13 @@ __ai float32x2_t vrnda_f32(float32x2_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vrndiq_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vrndiq_f32(float32x4_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t) __builtin_neon_vrndiq_v((int8x16_t)__p0, 41);
return __ret;
}
#else
-__ai float32x4_t vrndiq_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vrndiq_f32(float32x4_t __p0) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (float32x4_t) __builtin_neon_vrndiq_v((int8x16_t)__rev0, 41);
@@ -40806,13 +40844,13 @@ __ai float32x4_t vrndiq_f32(float32x4_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vrndi_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vrndi_f32(float32x2_t __p0) {
float32x2_t __ret;
__ret = (float32x2_t) __builtin_neon_vrndi_v((int8x8_t)__p0, 9);
return __ret;
}
#else
-__ai float32x2_t vrndi_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vrndi_f32(float32x2_t __p0) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (float32x2_t) __builtin_neon_vrndi_v((int8x8_t)__rev0, 9);
@@ -40822,13 +40860,13 @@ __ai float32x2_t vrndi_f32(float32x2_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vrndmq_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vrndmq_f32(float32x4_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t) __builtin_neon_vrndmq_v((int8x16_t)__p0, 41);
return __ret;
}
#else
-__ai float32x4_t vrndmq_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vrndmq_f32(float32x4_t __p0) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (float32x4_t) __builtin_neon_vrndmq_v((int8x16_t)__rev0, 41);
@@ -40838,13 +40876,13 @@ __ai float32x4_t vrndmq_f32(float32x4_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vrndm_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vrndm_f32(float32x2_t __p0) {
float32x2_t __ret;
__ret = (float32x2_t) __builtin_neon_vrndm_v((int8x8_t)__p0, 9);
return __ret;
}
#else
-__ai float32x2_t vrndm_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vrndm_f32(float32x2_t __p0) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (float32x2_t) __builtin_neon_vrndm_v((int8x8_t)__rev0, 9);
@@ -40854,13 +40892,13 @@ __ai float32x2_t vrndm_f32(float32x2_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vrndnq_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vrndnq_f32(float32x4_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t) __builtin_neon_vrndnq_v((int8x16_t)__p0, 41);
return __ret;
}
#else
-__ai float32x4_t vrndnq_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vrndnq_f32(float32x4_t __p0) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (float32x4_t) __builtin_neon_vrndnq_v((int8x16_t)__rev0, 41);
@@ -40870,13 +40908,13 @@ __ai float32x4_t vrndnq_f32(float32x4_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vrndn_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vrndn_f32(float32x2_t __p0) {
float32x2_t __ret;
__ret = (float32x2_t) __builtin_neon_vrndn_v((int8x8_t)__p0, 9);
return __ret;
}
#else
-__ai float32x2_t vrndn_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vrndn_f32(float32x2_t __p0) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (float32x2_t) __builtin_neon_vrndn_v((int8x8_t)__rev0, 9);
@@ -40885,19 +40923,19 @@ __ai float32x2_t vrndn_f32(float32x2_t __p0) {
}
#endif
-__ai float32_t vrndns_f32(float32_t __p0) {
+__ai __attribute__((target("neon"))) float32_t vrndns_f32(float32_t __p0) {
float32_t __ret;
__ret = (float32_t) __builtin_neon_vrndns_f32(__p0);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vrndpq_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vrndpq_f32(float32x4_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t) __builtin_neon_vrndpq_v((int8x16_t)__p0, 41);
return __ret;
}
#else
-__ai float32x4_t vrndpq_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vrndpq_f32(float32x4_t __p0) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (float32x4_t) __builtin_neon_vrndpq_v((int8x16_t)__rev0, 41);
@@ -40907,13 +40945,13 @@ __ai float32x4_t vrndpq_f32(float32x4_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vrndp_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vrndp_f32(float32x2_t __p0) {
float32x2_t __ret;
__ret = (float32x2_t) __builtin_neon_vrndp_v((int8x8_t)__p0, 9);
return __ret;
}
#else
-__ai float32x2_t vrndp_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vrndp_f32(float32x2_t __p0) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (float32x2_t) __builtin_neon_vrndp_v((int8x8_t)__rev0, 9);
@@ -40923,13 +40961,13 @@ __ai float32x2_t vrndp_f32(float32x2_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vrndxq_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vrndxq_f32(float32x4_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t) __builtin_neon_vrndxq_v((int8x16_t)__p0, 41);
return __ret;
}
#else
-__ai float32x4_t vrndxq_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vrndxq_f32(float32x4_t __p0) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (float32x4_t) __builtin_neon_vrndxq_v((int8x16_t)__rev0, 41);
@@ -40939,13 +40977,13 @@ __ai float32x4_t vrndxq_f32(float32x4_t __p0) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vrndx_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vrndx_f32(float32x2_t __p0) {
float32x2_t __ret;
__ret = (float32x2_t) __builtin_neon_vrndx_v((int8x8_t)__p0, 9);
return __ret;
}
#else
-__ai float32x2_t vrndx_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x2_t vrndx_f32(float32x2_t __p0) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (float32x2_t) __builtin_neon_vrndx_v((int8x8_t)__rev0, 9);
@@ -40954,259 +40992,135 @@ __ai float32x2_t vrndx_f32(float32x2_t __p0) {
}
#endif
+#endif
+#if __ARM_ARCH >= 8 && defined(__ARM_FEATURE_NUMERIC_MAXMIN)
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vrndq_f16(float16x8_t __p0) {
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vmaxnmq_f16(float16x8_t __p0, float16x8_t __p1) {
float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vrndq_f16((int8x16_t)__p0, 40);
+ __ret = (float16x8_t) __builtin_neon_vmaxnmq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vrndq_f16(float16x8_t __p0) {
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vmaxnmq_f16(float16x8_t __p0, float16x8_t __p1) {
float16x8_t __ret;
float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vrndq_f16((int8x16_t)__rev0, 40);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vmaxnmq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vrnd_f16(float16x4_t __p0) {
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmaxnm_f16(float16x4_t __p0, float16x4_t __p1) {
float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vrnd_f16((int8x8_t)__p0, 8);
+ __ret = (float16x4_t) __builtin_neon_vmaxnm_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vrnd_f16(float16x4_t __p0) {
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmaxnm_f16(float16x4_t __p0, float16x4_t __p1) {
float16x4_t __ret;
float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vrnd_f16((int8x8_t)__rev0, 8);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vmaxnm_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vrndaq_f16(float16x8_t __p0) {
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vminnmq_f16(float16x8_t __p0, float16x8_t __p1) {
float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vrndaq_f16((int8x16_t)__p0, 40);
+ __ret = (float16x8_t) __builtin_neon_vminnmq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vrndaq_f16(float16x8_t __p0) {
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vminnmq_f16(float16x8_t __p0, float16x8_t __p1) {
float16x8_t __ret;
float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vrndaq_f16((int8x16_t)__rev0, 40);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vminnmq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vrnda_f16(float16x4_t __p0) {
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vminnm_f16(float16x4_t __p0, float16x4_t __p1) {
float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vrnda_f16((int8x8_t)__p0, 8);
+ __ret = (float16x4_t) __builtin_neon_vminnm_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vrnda_f16(float16x4_t __p0) {
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vminnm_f16(float16x4_t __p0, float16x4_t __p1) {
float16x4_t __ret;
float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vrnda_f16((int8x8_t)__rev0, 8);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vminnm_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vrndmq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vrndmq_f16((int8x16_t)__p0, 40);
+__ai __attribute__((target("neon"))) float32x4_t vmaxnmq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vmaxnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vrndmq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vrndmq_f16((int8x16_t)__rev0, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x4_t vmaxnmq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vmaxnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vrndm_f16(float16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vrndm_f16((int8x8_t)__p0, 8);
+__ai __attribute__((target("neon"))) float32x2_t vmaxnm_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vmaxnm_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vrndm_f16(float16x4_t __p0) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vrndm_f16((int8x8_t)__rev0, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x2_t vmaxnm_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vmaxnm_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vrndnq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vrndnq_f16((int8x16_t)__p0, 40);
+__ai __attribute__((target("neon"))) float32x4_t vminnmq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vminnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vrndnq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vrndnq_f16((int8x16_t)__rev0, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x4_t vminnmq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vminnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vrndn_f16(float16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vrndn_f16((int8x8_t)__p0, 8);
- return __ret;
-}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vrndn_f16(float16x4_t __p0) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vrndn_f16((int8x8_t)__rev0, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vrndpq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vrndpq_f16((int8x16_t)__p0, 40);
- return __ret;
-}
-#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vrndpq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vrndpq_f16((int8x16_t)__rev0, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vrndp_f16(float16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vrndp_f16((int8x8_t)__p0, 8);
- return __ret;
-}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vrndp_f16(float16x4_t __p0) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vrndp_f16((int8x8_t)__rev0, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vrndxq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vrndxq_f16((int8x16_t)__p0, 40);
- return __ret;
-}
-#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vrndxq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vrndxq_f16((int8x16_t)__rev0, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vrndx_f16(float16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vrndx_f16((int8x8_t)__p0, 8);
- return __ret;
-}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vrndx_f16(float16x4_t __p0) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vrndx_f16((int8x8_t)__rev0, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#endif
-#if __ARM_ARCH >= 8 && defined(__ARM_FEATURE_NUMERIC_MAXMIN)
-#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vmaxnmq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vmaxnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
- return __ret;
-}
-#else
-__ai float32x4_t vmaxnmq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vmaxnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vmaxnm_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vmaxnm_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
- return __ret;
-}
-#else
-__ai float32x2_t vmaxnm_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vmaxnm_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vminnmq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vminnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
- return __ret;
-}
-#else
-__ai float32x4_t vminnmq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vminnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vminnm_f32(float32x2_t __p0, float32x2_t __p1) {
+__ai __attribute__((target("neon"))) float32x2_t vminnm_f32(float32x2_t __p0, float32x2_t __p1) {
float32x2_t __ret;
__ret = (float32x2_t) __builtin_neon_vminnm_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
return __ret;
}
#else
-__ai float32x2_t vminnm_f32(float32x2_t __p0, float32x2_t __p1) {
+__ai __attribute__((target("neon"))) float32x2_t vminnm_f32(float32x2_t __p0, float32x2_t __p1) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -41216,84 +41130,16 @@ __ai float32x2_t vminnm_f32(float32x2_t __p0, float32x2_t __p1) {
}
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vmaxnmq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vmaxnmq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
- return __ret;
-}
-#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vmaxnmq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vmaxnmq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vmaxnm_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vmaxnm_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
- return __ret;
-}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vmaxnm_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vmaxnm_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vminnmq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vminnmq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
- return __ret;
-}
-#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vminnmq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vminnmq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vminnm_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vminnm_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
- return __ret;
-}
-#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vminnm_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vminnm_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
#endif
#if defined(__ARM_FEATURE_FMA)
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vfmaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+__ai __attribute__((target("neon"))) float32x4_t vfmaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
float32x4_t __ret;
__ret = (float32x4_t) __builtin_neon_vfmaq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
return __ret;
}
#else
-__ai float32x4_t vfmaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+__ai __attribute__((target("neon"))) float32x4_t vfmaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -41302,7 +41148,7 @@ __ai float32x4_t vfmaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2)
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai float32x4_t __noswap_vfmaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+__ai __attribute__((target("neon"))) float32x4_t __noswap_vfmaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
float32x4_t __ret;
__ret = (float32x4_t) __builtin_neon_vfmaq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
return __ret;
@@ -41310,13 +41156,13 @@ __ai float32x4_t __noswap_vfmaq_f32(float32x4_t __p0, float32x4_t __p1, float32x
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vfma_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+__ai __attribute__((target("neon"))) float32x2_t vfma_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
float32x2_t __ret;
__ret = (float32x2_t) __builtin_neon_vfma_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
return __ret;
}
#else
-__ai float32x2_t vfma_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+__ai __attribute__((target("neon"))) float32x2_t vfma_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -41325,7 +41171,7 @@ __ai float32x2_t vfma_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2)
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai float32x2_t __noswap_vfma_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+__ai __attribute__((target("neon"))) float32x2_t __noswap_vfma_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
float32x2_t __ret;
__ret = (float32x2_t) __builtin_neon_vfma_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
return __ret;
@@ -41333,13 +41179,13 @@ __ai float32x2_t __noswap_vfma_f32(float32x2_t __p0, float32x2_t __p1, float32x2
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vfmaq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
+__ai __attribute__((target("neon"))) float32x4_t vfmaq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
float32x4_t __ret;
__ret = vfmaq_f32(__p0, __p1, (float32x4_t) {__p2, __p2, __p2, __p2});
return __ret;
}
#else
-__ai float32x4_t vfmaq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
+__ai __attribute__((target("neon"))) float32x4_t vfmaq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -41350,13 +41196,13 @@ __ai float32x4_t vfmaq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2)
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vfma_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
+__ai __attribute__((target("neon"))) float32x2_t vfma_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
float32x2_t __ret;
__ret = vfma_f32(__p0, __p1, (float32x2_t) {__p2, __p2});
return __ret;
}
#else
-__ai float32x2_t vfma_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
+__ai __attribute__((target("neon"))) float32x2_t vfma_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -41367,13 +41213,13 @@ __ai float32x2_t vfma_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2)
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vfmsq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+__ai __attribute__((target("neon"))) float32x4_t vfmsq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
float32x4_t __ret;
__ret = vfmaq_f32(__p0, -__p1, __p2);
return __ret;
}
#else
-__ai float32x4_t vfmsq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+__ai __attribute__((target("neon"))) float32x4_t vfmsq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -41385,13 +41231,13 @@ __ai float32x4_t vfmsq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2)
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vfms_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+__ai __attribute__((target("neon"))) float32x2_t vfms_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
float32x2_t __ret;
__ret = vfma_f32(__p0, -__p1, __p2);
return __ret;
}
#else
-__ai float32x2_t vfms_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+__ai __attribute__((target("neon"))) float32x2_t vfms_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -41403,20405 +41249,20589 @@ __ai float32x2_t vfms_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2)
#endif
#endif
-#if defined(__aarch64__)
+#if defined(__aarch64__) || defined(__arm64ec__)
+__ai __attribute__((target("aes,neon"))) poly128_t vmull_p64(poly64_t __p0, poly64_t __p1) {
+ poly128_t __ret;
+ __ret = (poly128_t) __builtin_neon_vmull_p64(__p0, __p1);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vabdq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t __a64_vcvtq_low_bf16_f32(float32x4_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t) __builtin_neon___a64_vcvtq_low_bf16_f32((int8x16_t)__p0, 43);
return __ret;
}
#else
-__ai float64x2_t vabdq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t __a64_vcvtq_low_bf16_f32(float32x4_t __p0) {
+ bfloat16x8_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (bfloat16x8_t) __builtin_neon___a64_vcvtq_low_bf16_f32((int8x16_t)__rev0, 43);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-#endif
-
-__ai float64x1_t vabd_f64(float64x1_t __p0, float64x1_t __p1) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t __noswap___a64_vcvtq_low_bf16_f32(float32x4_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t) __builtin_neon___a64_vcvtq_low_bf16_f32((int8x16_t)__p0, 43);
return __ret;
}
-__ai float64_t vabdd_f64(float64_t __p0, float64_t __p1) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vabdd_f64(__p0, __p1);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_lane_bf16(__p0_230, __p1_230, __p2_230, __p3_230) __extension__ ({ \
+ bfloat16x8_t __ret_230; \
+ bfloat16x8_t __s0_230 = __p0_230; \
+ bfloat16x4_t __s2_230 = __p2_230; \
+ __ret_230 = vsetq_lane_bf16(vget_lane_bf16(__s2_230, __p3_230), __s0_230, __p1_230); \
+ __ret_230; \
+})
+#else
+#define vcopyq_lane_bf16(__p0_231, __p1_231, __p2_231, __p3_231) __extension__ ({ \
+ bfloat16x8_t __ret_231; \
+ bfloat16x8_t __s0_231 = __p0_231; \
+ bfloat16x4_t __s2_231 = __p2_231; \
+ bfloat16x8_t __rev0_231; __rev0_231 = __builtin_shufflevector(__s0_231, __s0_231, 7, 6, 5, 4, 3, 2, 1, 0); \
+ bfloat16x4_t __rev2_231; __rev2_231 = __builtin_shufflevector(__s2_231, __s2_231, 3, 2, 1, 0); \
+ __ret_231 = __noswap_vsetq_lane_bf16(__noswap_vget_lane_bf16(__rev2_231, __p3_231), __rev0_231, __p1_231); \
+ __ret_231 = __builtin_shufflevector(__ret_231, __ret_231, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_231; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_lane_bf16(__p0_232, __p1_232, __p2_232, __p3_232) __extension__ ({ \
+ bfloat16x4_t __ret_232; \
+ bfloat16x4_t __s0_232 = __p0_232; \
+ bfloat16x4_t __s2_232 = __p2_232; \
+ __ret_232 = vset_lane_bf16(vget_lane_bf16(__s2_232, __p3_232), __s0_232, __p1_232); \
+ __ret_232; \
+})
+#else
+#define vcopy_lane_bf16(__p0_233, __p1_233, __p2_233, __p3_233) __extension__ ({ \
+ bfloat16x4_t __ret_233; \
+ bfloat16x4_t __s0_233 = __p0_233; \
+ bfloat16x4_t __s2_233 = __p2_233; \
+ bfloat16x4_t __rev0_233; __rev0_233 = __builtin_shufflevector(__s0_233, __s0_233, 3, 2, 1, 0); \
+ bfloat16x4_t __rev2_233; __rev2_233 = __builtin_shufflevector(__s2_233, __s2_233, 3, 2, 1, 0); \
+ __ret_233 = __noswap_vset_lane_bf16(__noswap_vget_lane_bf16(__rev2_233, __p3_233), __rev0_233, __p1_233); \
+ __ret_233 = __builtin_shufflevector(__ret_233, __ret_233, 3, 2, 1, 0); \
+ __ret_233; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_laneq_bf16(__p0_234, __p1_234, __p2_234, __p3_234) __extension__ ({ \
+ bfloat16x8_t __ret_234; \
+ bfloat16x8_t __s0_234 = __p0_234; \
+ bfloat16x8_t __s2_234 = __p2_234; \
+ __ret_234 = vsetq_lane_bf16(vgetq_lane_bf16(__s2_234, __p3_234), __s0_234, __p1_234); \
+ __ret_234; \
+})
+#else
+#define vcopyq_laneq_bf16(__p0_235, __p1_235, __p2_235, __p3_235) __extension__ ({ \
+ bfloat16x8_t __ret_235; \
+ bfloat16x8_t __s0_235 = __p0_235; \
+ bfloat16x8_t __s2_235 = __p2_235; \
+ bfloat16x8_t __rev0_235; __rev0_235 = __builtin_shufflevector(__s0_235, __s0_235, 7, 6, 5, 4, 3, 2, 1, 0); \
+ bfloat16x8_t __rev2_235; __rev2_235 = __builtin_shufflevector(__s2_235, __s2_235, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_235 = __noswap_vsetq_lane_bf16(__noswap_vgetq_lane_bf16(__rev2_235, __p3_235), __rev0_235, __p1_235); \
+ __ret_235 = __builtin_shufflevector(__ret_235, __ret_235, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_235; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_laneq_bf16(__p0_236, __p1_236, __p2_236, __p3_236) __extension__ ({ \
+ bfloat16x4_t __ret_236; \
+ bfloat16x4_t __s0_236 = __p0_236; \
+ bfloat16x8_t __s2_236 = __p2_236; \
+ __ret_236 = vset_lane_bf16(vgetq_lane_bf16(__s2_236, __p3_236), __s0_236, __p1_236); \
+ __ret_236; \
+})
+#else
+#define vcopy_laneq_bf16(__p0_237, __p1_237, __p2_237, __p3_237) __extension__ ({ \
+ bfloat16x4_t __ret_237; \
+ bfloat16x4_t __s0_237 = __p0_237; \
+ bfloat16x8_t __s2_237 = __p2_237; \
+ bfloat16x4_t __rev0_237; __rev0_237 = __builtin_shufflevector(__s0_237, __s0_237, 3, 2, 1, 0); \
+ bfloat16x8_t __rev2_237; __rev2_237 = __builtin_shufflevector(__s2_237, __s2_237, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_237 = __noswap_vset_lane_bf16(__noswap_vgetq_lane_bf16(__rev2_237, __p3_237), __rev0_237, __p1_237); \
+ __ret_237 = __builtin_shufflevector(__ret_237, __ret_237, 3, 2, 1, 0); \
+ __ret_237; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vcvt_bf16_f32(float32x4_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = vget_low_bf16(__a64_vcvtq_low_bf16_f32(__p0));
return __ret;
}
-__ai float32_t vabds_f32(float32_t __p0, float32_t __p1) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vabds_f32(__p0, __p1);
+#else
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vcvt_bf16_f32(float32x4_t __p0) {
+ bfloat16x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __noswap_vget_low_bf16(__noswap___a64_vcvtq_low_bf16_f32(__rev0));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+#endif
+
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vabsq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vabsq_v((int8x16_t)__p0, 42);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcvtq_high_bf16_f32(bfloat16x8_t __p0, float32x4_t __p1) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t) __builtin_neon_vcvtq_high_bf16_f32((int8x16_t)__p0, (int8x16_t)__p1, 43);
return __ret;
}
#else
-__ai float64x2_t vabsq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vabsq_v((int8x16_t)__rev0, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcvtq_high_bf16_f32(bfloat16x8_t __p0, float32x4_t __p1) {
+ bfloat16x8_t __ret;
+ bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (bfloat16x8_t) __builtin_neon_vcvtq_high_bf16_f32((int8x16_t)__rev0, (int8x16_t)__rev1, 43);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vabsq_s64(int64x2_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vabsq_v((int8x16_t)__p0, 35);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcvtq_low_bf16_f32(float32x4_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = __a64_vcvtq_low_bf16_f32(__p0);
return __ret;
}
#else
-__ai int64x2_t vabsq_s64(int64x2_t __p0) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vabsq_v((int8x16_t)__rev0, 35);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcvtq_low_bf16_f32(float32x4_t __p0) {
+ bfloat16x8_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __noswap___a64_vcvtq_low_bf16_f32(__rev0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai float64x1_t vabs_f64(float64x1_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vabs_v((int8x8_t)__p0, 10);
+__ai __attribute__((target("bf16,neon"))) poly8x8_t vreinterpret_p8_bf16(bfloat16x4_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-__ai int64x1_t vabs_s64(int64x1_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t) __builtin_neon_vabs_v((int8x8_t)__p0, 3);
+__ai __attribute__((target("bf16,neon"))) poly64x1_t vreinterpret_p64_bf16(bfloat16x4_t __p0) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t)(__p0);
return __ret;
}
-__ai int64_t vabsd_s64(int64_t __p0) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vabsd_s64(__p0);
+__ai __attribute__((target("bf16,neon"))) poly16x4_t vreinterpret_p16_bf16(bfloat16x4_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vaddq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = __p0 + __p1;
+__ai __attribute__((target("bf16,neon"))) poly8x16_t vreinterpretq_p8_bf16(bfloat16x8_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
return __ret;
}
-#else
-__ai float64x2_t vaddq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 + __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("bf16,neon"))) poly128_t vreinterpretq_p128_bf16(bfloat16x8_t __p0) {
+ poly128_t __ret;
+ __ret = (poly128_t)(__p0);
return __ret;
}
-#endif
-
-__ai float64x1_t vadd_f64(float64x1_t __p0, float64x1_t __p1) {
- float64x1_t __ret;
- __ret = __p0 + __p1;
+__ai __attribute__((target("bf16,neon"))) poly64x2_t vreinterpretq_p64_bf16(bfloat16x8_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t)(__p0);
return __ret;
}
-__ai uint64_t vaddd_u64(uint64_t __p0, uint64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vaddd_u64(__p0, __p1);
+__ai __attribute__((target("bf16,neon"))) poly16x8_t vreinterpretq_p16_bf16(bfloat16x8_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
return __ret;
}
-__ai int64_t vaddd_s64(int64_t __p0, int64_t __p1) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vaddd_s64(__p0, __p1);
+__ai __attribute__((target("bf16,neon"))) uint8x16_t vreinterpretq_u8_bf16(bfloat16x8_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
return __ret;
}
-__ai poly128_t vaddq_p128(poly128_t __p0, poly128_t __p1) {
- poly128_t __ret;
- __ret = (poly128_t) __builtin_neon_vaddq_p128(__p0, __p1);
+__ai __attribute__((target("bf16,neon"))) uint32x4_t vreinterpretq_u32_bf16(bfloat16x8_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
return __ret;
}
-#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vaddhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
- uint16x8_t __ret;
- __ret = vcombine_u16(__p0, vaddhn_u32(__p1, __p2));
+__ai __attribute__((target("bf16,neon"))) uint64x2_t vreinterpretq_u64_bf16(bfloat16x8_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
return __ret;
}
-#else
-__ai uint16x8_t vaddhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("bf16,neon"))) uint16x8_t vreinterpretq_u16_bf16(bfloat16x8_t __p0) {
uint16x8_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- uint32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __noswap_vcombine_u16(__rev0, __noswap_vaddhn_u32(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vaddhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
- uint32x4_t __ret;
- __ret = vcombine_u32(__p0, vaddhn_u64(__p1, __p2));
+__ai __attribute__((target("bf16,neon"))) int8x16_t vreinterpretq_s8_bf16(bfloat16x8_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t)(__p0);
return __ret;
}
-#else
-__ai uint32x4_t vaddhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
- uint32x4_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- uint64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = __noswap_vcombine_u32(__rev0, __noswap_vaddhn_u64(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) float64x2_t vreinterpretq_f64_bf16(bfloat16x8_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vaddhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
- uint8x16_t __ret;
- __ret = vcombine_u8(__p0, vaddhn_u16(__p1, __p2));
+__ai __attribute__((target("bf16,neon"))) float32x4_t vreinterpretq_f32_bf16(bfloat16x8_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t)(__p0);
return __ret;
}
-#else
-__ai uint8x16_t vaddhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
- uint8x16_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vcombine_u8(__rev0, __noswap_vaddhn_u16(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) float16x8_t vreinterpretq_f16_bf16(bfloat16x8_t __p0) {
+ float16x8_t __ret;
+ __ret = (float16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vaddhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int16x8_t __ret;
- __ret = vcombine_s16(__p0, vaddhn_s32(__p1, __p2));
+__ai __attribute__((target("bf16,neon"))) int32x4_t vreinterpretq_s32_bf16(bfloat16x8_t __p0) {
+ int32x4_t __ret;
+ __ret = (int32x4_t)(__p0);
return __ret;
}
-#else
-__ai int16x8_t vaddhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int16x8_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __noswap_vcombine_s16(__rev0, __noswap_vaddhn_s32(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) int64x2_t vreinterpretq_s64_bf16(bfloat16x8_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vaddhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
- int32x4_t __ret;
- __ret = vcombine_s32(__p0, vaddhn_s64(__p1, __p2));
+__ai __attribute__((target("bf16,neon"))) int16x8_t vreinterpretq_s16_bf16(bfloat16x8_t __p0) {
+ int16x8_t __ret;
+ __ret = (int16x8_t)(__p0);
return __ret;
}
-#else
-__ai int32x4_t vaddhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
- int32x4_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- int64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = __noswap_vcombine_s32(__rev0, __noswap_vaddhn_s64(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) uint8x8_t vreinterpret_u8_bf16(bfloat16x4_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vaddhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int8x16_t __ret;
- __ret = vcombine_s8(__p0, vaddhn_s16(__p1, __p2));
+__ai __attribute__((target("bf16,neon"))) uint32x2_t vreinterpret_u32_bf16(bfloat16x4_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t)(__p0);
return __ret;
}
-#else
-__ai int8x16_t vaddhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int8x16_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vcombine_s8(__rev0, __noswap_vaddhn_s16(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("bf16,neon"))) uint64x1_t vreinterpret_u64_bf16(bfloat16x4_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint16_t vaddlvq_u8(uint8x16_t __p0) {
- uint16_t __ret;
- __ret = (uint16_t) __builtin_neon_vaddlvq_u8(__p0);
+__ai __attribute__((target("bf16,neon"))) uint16x4_t vreinterpret_u16_bf16(bfloat16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t)(__p0);
return __ret;
}
-#else
-__ai uint16_t vaddlvq_u8(uint8x16_t __p0) {
- uint16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16_t) __builtin_neon_vaddlvq_u8(__rev0);
+__ai __attribute__((target("bf16,neon"))) int8x8_t vreinterpret_s8_bf16(bfloat16x4_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint64_t vaddlvq_u32(uint32x4_t __p0) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vaddlvq_u32(__p0);
+__ai __attribute__((target("bf16,neon"))) float64x1_t vreinterpret_f64_bf16(bfloat16x4_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t)(__p0);
return __ret;
}
-#else
-__ai uint64_t vaddlvq_u32(uint32x4_t __p0) {
- uint64_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint64_t) __builtin_neon_vaddlvq_u32(__rev0);
+__ai __attribute__((target("bf16,neon"))) float32x2_t vreinterpret_f32_bf16(bfloat16x4_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32_t vaddlvq_u16(uint16x8_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vaddlvq_u16(__p0);
+__ai __attribute__((target("bf16,neon"))) float16x4_t vreinterpret_f16_bf16(bfloat16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
return __ret;
}
-#else
-__ai uint32_t vaddlvq_u16(uint16x8_t __p0) {
- uint32_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint32_t) __builtin_neon_vaddlvq_u16(__rev0);
+__ai __attribute__((target("bf16,neon"))) int32x2_t vreinterpret_s32_bf16(bfloat16x4_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int16_t vaddlvq_s8(int8x16_t __p0) {
- int16_t __ret;
- __ret = (int16_t) __builtin_neon_vaddlvq_s8(__p0);
+__ai __attribute__((target("bf16,neon"))) int64x1_t vreinterpret_s64_bf16(bfloat16x4_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
return __ret;
}
-#else
-__ai int16_t vaddlvq_s8(int8x16_t __p0) {
- int16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16_t) __builtin_neon_vaddlvq_s8(__rev0);
+__ai __attribute__((target("bf16,neon"))) int16x4_t vreinterpret_s16_bf16(bfloat16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int64_t vaddlvq_s32(int32x4_t __p0) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vaddlvq_s32(__p0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_p8(poly8x16_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#else
-__ai int64_t vaddlvq_s32(int32x4_t __p0) {
- int64_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int64_t) __builtin_neon_vaddlvq_s32(__rev0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_p128(poly128_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int32_t vaddlvq_s16(int16x8_t __p0) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vaddlvq_s16(__p0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_p64(poly64x2_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#else
-__ai int32_t vaddlvq_s16(int16x8_t __p0) {
- int32_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int32_t) __builtin_neon_vaddlvq_s16(__rev0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_p16(poly16x8_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint16_t vaddlv_u8(uint8x8_t __p0) {
- uint16_t __ret;
- __ret = (uint16_t) __builtin_neon_vaddlv_u8(__p0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_u8(uint8x16_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#else
-__ai uint16_t vaddlv_u8(uint8x8_t __p0) {
- uint16_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16_t) __builtin_neon_vaddlv_u8(__rev0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_u32(uint32x4_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint64_t vaddlv_u32(uint32x2_t __p0) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vaddlv_u32(__p0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_u64(uint64x2_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#else
-__ai uint64_t vaddlv_u32(uint32x2_t __p0) {
- uint64_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64_t) __builtin_neon_vaddlv_u32(__rev0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_u16(uint16x8_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32_t vaddlv_u16(uint16x4_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vaddlv_u16(__p0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_s8(int8x16_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#else
-__ai uint32_t vaddlv_u16(uint16x4_t __p0) {
- uint32_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32_t) __builtin_neon_vaddlv_u16(__rev0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_f64(float64x2_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int16_t vaddlv_s8(int8x8_t __p0) {
- int16_t __ret;
- __ret = (int16_t) __builtin_neon_vaddlv_s8(__p0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_f32(float32x4_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#else
-__ai int16_t vaddlv_s8(int8x8_t __p0) {
- int16_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16_t) __builtin_neon_vaddlv_s8(__rev0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_f16(float16x8_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int64_t vaddlv_s32(int32x2_t __p0) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vaddlv_s32(__p0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_s32(int32x4_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#else
-__ai int64_t vaddlv_s32(int32x2_t __p0) {
- int64_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int64_t) __builtin_neon_vaddlv_s32(__rev0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_s64(int64x2_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int32_t vaddlv_s16(int16x4_t __p0) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vaddlv_s16(__p0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_s16(int16x8_t __p0) {
+ bfloat16x8_t __ret;
+ __ret = (bfloat16x8_t)(__p0);
return __ret;
}
-#else
-__ai int32_t vaddlv_s16(int16x4_t __p0) {
- int32_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int32_t) __builtin_neon_vaddlv_s16(__rev0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_p8(poly8x8_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint8_t vaddvq_u8(uint8x16_t __p0) {
- uint8_t __ret;
- __ret = (uint8_t) __builtin_neon_vaddvq_u8(__p0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_p64(poly64x1_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#else
-__ai uint8_t vaddvq_u8(uint8x16_t __p0) {
- uint8_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8_t) __builtin_neon_vaddvq_u8(__rev0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_p16(poly16x4_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32_t vaddvq_u32(uint32x4_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vaddvq_u32(__p0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_u8(uint8x8_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#else
-__ai uint32_t vaddvq_u32(uint32x4_t __p0) {
- uint32_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32_t) __builtin_neon_vaddvq_u32(__rev0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_u32(uint32x2_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint64_t vaddvq_u64(uint64x2_t __p0) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vaddvq_u64(__p0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_u64(uint64x1_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#else
-__ai uint64_t vaddvq_u64(uint64x2_t __p0) {
- uint64_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64_t) __builtin_neon_vaddvq_u64(__rev0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_u16(uint16x4_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint16_t vaddvq_u16(uint16x8_t __p0) {
- uint16_t __ret;
- __ret = (uint16_t) __builtin_neon_vaddvq_u16(__p0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_s8(int8x8_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#else
-__ai uint16_t vaddvq_u16(uint16x8_t __p0) {
- uint16_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16_t) __builtin_neon_vaddvq_u16(__rev0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_f64(float64x1_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int8_t vaddvq_s8(int8x16_t __p0) {
- int8_t __ret;
- __ret = (int8_t) __builtin_neon_vaddvq_s8(__p0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_f32(float32x2_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#else
-__ai int8_t vaddvq_s8(int8x16_t __p0) {
- int8_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8_t) __builtin_neon_vaddvq_s8(__rev0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_f16(float16x4_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float64_t vaddvq_f64(float64x2_t __p0) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vaddvq_f64(__p0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_s32(int32x2_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#else
-__ai float64_t vaddvq_f64(float64x2_t __p0) {
- float64_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64_t) __builtin_neon_vaddvq_f64(__rev0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_s64(int64x1_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float32_t vaddvq_f32(float32x4_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vaddvq_f32(__p0);
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_s16(int16x4_t __p0) {
+ bfloat16x4_t __ret;
+ __ret = (bfloat16x4_t)(__p0);
return __ret;
}
+#ifdef __LITTLE_ENDIAN__
+#define vdotq_laneq_u32(__p0_238, __p1_238, __p2_238, __p3_238) __extension__ ({ \
+ uint32x4_t __ret_238; \
+ uint32x4_t __s0_238 = __p0_238; \
+ uint8x16_t __s1_238 = __p1_238; \
+ uint8x16_t __s2_238 = __p2_238; \
+uint8x16_t __reint_238 = __s2_238; \
+uint32x4_t __reint1_238 = splatq_laneq_u32(*(uint32x4_t *) &__reint_238, __p3_238); \
+ __ret_238 = vdotq_u32(__s0_238, __s1_238, *(uint8x16_t *) &__reint1_238); \
+ __ret_238; \
+})
#else
-__ai float32_t vaddvq_f32(float32x4_t __p0) {
- float32_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float32_t) __builtin_neon_vaddvq_f32(__rev0);
- return __ret;
-}
+#define vdotq_laneq_u32(__p0_239, __p1_239, __p2_239, __p3_239) __extension__ ({ \
+ uint32x4_t __ret_239; \
+ uint32x4_t __s0_239 = __p0_239; \
+ uint8x16_t __s1_239 = __p1_239; \
+ uint8x16_t __s2_239 = __p2_239; \
+ uint32x4_t __rev0_239; __rev0_239 = __builtin_shufflevector(__s0_239, __s0_239, 3, 2, 1, 0); \
+ uint8x16_t __rev1_239; __rev1_239 = __builtin_shufflevector(__s1_239, __s1_239, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x16_t __rev2_239; __rev2_239 = __builtin_shufflevector(__s2_239, __s2_239, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+uint8x16_t __reint_239 = __rev2_239; \
+uint32x4_t __reint1_239 = __noswap_splatq_laneq_u32(*(uint32x4_t *) &__reint_239, __p3_239); \
+ __ret_239 = __noswap_vdotq_u32(__rev0_239, __rev1_239, *(uint8x16_t *) &__reint1_239); \
+ __ret_239 = __builtin_shufflevector(__ret_239, __ret_239, 3, 2, 1, 0); \
+ __ret_239; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32_t vaddvq_s32(int32x4_t __p0) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vaddvq_s32(__p0);
- return __ret;
-}
+#define vdotq_laneq_s32(__p0_240, __p1_240, __p2_240, __p3_240) __extension__ ({ \
+ int32x4_t __ret_240; \
+ int32x4_t __s0_240 = __p0_240; \
+ int8x16_t __s1_240 = __p1_240; \
+ int8x16_t __s2_240 = __p2_240; \
+int8x16_t __reint_240 = __s2_240; \
+int32x4_t __reint1_240 = splatq_laneq_s32(*(int32x4_t *) &__reint_240, __p3_240); \
+ __ret_240 = vdotq_s32(__s0_240, __s1_240, *(int8x16_t *) &__reint1_240); \
+ __ret_240; \
+})
#else
-__ai int32_t vaddvq_s32(int32x4_t __p0) {
- int32_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int32_t) __builtin_neon_vaddvq_s32(__rev0);
- return __ret;
-}
+#define vdotq_laneq_s32(__p0_241, __p1_241, __p2_241, __p3_241) __extension__ ({ \
+ int32x4_t __ret_241; \
+ int32x4_t __s0_241 = __p0_241; \
+ int8x16_t __s1_241 = __p1_241; \
+ int8x16_t __s2_241 = __p2_241; \
+ int32x4_t __rev0_241; __rev0_241 = __builtin_shufflevector(__s0_241, __s0_241, 3, 2, 1, 0); \
+ int8x16_t __rev1_241; __rev1_241 = __builtin_shufflevector(__s1_241, __s1_241, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x16_t __rev2_241; __rev2_241 = __builtin_shufflevector(__s2_241, __s2_241, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+int8x16_t __reint_241 = __rev2_241; \
+int32x4_t __reint1_241 = __noswap_splatq_laneq_s32(*(int32x4_t *) &__reint_241, __p3_241); \
+ __ret_241 = __noswap_vdotq_s32(__rev0_241, __rev1_241, *(int8x16_t *) &__reint1_241); \
+ __ret_241 = __builtin_shufflevector(__ret_241, __ret_241, 3, 2, 1, 0); \
+ __ret_241; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64_t vaddvq_s64(int64x2_t __p0) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vaddvq_s64(__p0);
- return __ret;
-}
+#define vdot_laneq_u32(__p0_242, __p1_242, __p2_242, __p3_242) __extension__ ({ \
+ uint32x2_t __ret_242; \
+ uint32x2_t __s0_242 = __p0_242; \
+ uint8x8_t __s1_242 = __p1_242; \
+ uint8x16_t __s2_242 = __p2_242; \
+uint8x16_t __reint_242 = __s2_242; \
+uint32x2_t __reint1_242 = splat_laneq_u32(*(uint32x4_t *) &__reint_242, __p3_242); \
+ __ret_242 = vdot_u32(__s0_242, __s1_242, *(uint8x8_t *) &__reint1_242); \
+ __ret_242; \
+})
#else
-__ai int64_t vaddvq_s64(int64x2_t __p0) {
- int64_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int64_t) __builtin_neon_vaddvq_s64(__rev0);
- return __ret;
-}
+#define vdot_laneq_u32(__p0_243, __p1_243, __p2_243, __p3_243) __extension__ ({ \
+ uint32x2_t __ret_243; \
+ uint32x2_t __s0_243 = __p0_243; \
+ uint8x8_t __s1_243 = __p1_243; \
+ uint8x16_t __s2_243 = __p2_243; \
+ uint32x2_t __rev0_243; __rev0_243 = __builtin_shufflevector(__s0_243, __s0_243, 1, 0); \
+ uint8x8_t __rev1_243; __rev1_243 = __builtin_shufflevector(__s1_243, __s1_243, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x16_t __rev2_243; __rev2_243 = __builtin_shufflevector(__s2_243, __s2_243, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+uint8x16_t __reint_243 = __rev2_243; \
+uint32x2_t __reint1_243 = __noswap_splat_laneq_u32(*(uint32x4_t *) &__reint_243, __p3_243); \
+ __ret_243 = __noswap_vdot_u32(__rev0_243, __rev1_243, *(uint8x8_t *) &__reint1_243); \
+ __ret_243 = __builtin_shufflevector(__ret_243, __ret_243, 1, 0); \
+ __ret_243; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16_t vaddvq_s16(int16x8_t __p0) {
- int16_t __ret;
- __ret = (int16_t) __builtin_neon_vaddvq_s16(__p0);
- return __ret;
-}
+#define vdot_laneq_s32(__p0_244, __p1_244, __p2_244, __p3_244) __extension__ ({ \
+ int32x2_t __ret_244; \
+ int32x2_t __s0_244 = __p0_244; \
+ int8x8_t __s1_244 = __p1_244; \
+ int8x16_t __s2_244 = __p2_244; \
+int8x16_t __reint_244 = __s2_244; \
+int32x2_t __reint1_244 = splat_laneq_s32(*(int32x4_t *) &__reint_244, __p3_244); \
+ __ret_244 = vdot_s32(__s0_244, __s1_244, *(int8x8_t *) &__reint1_244); \
+ __ret_244; \
+})
#else
-__ai int16_t vaddvq_s16(int16x8_t __p0) {
- int16_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16_t) __builtin_neon_vaddvq_s16(__rev0);
- return __ret;
-}
+#define vdot_laneq_s32(__p0_245, __p1_245, __p2_245, __p3_245) __extension__ ({ \
+ int32x2_t __ret_245; \
+ int32x2_t __s0_245 = __p0_245; \
+ int8x8_t __s1_245 = __p1_245; \
+ int8x16_t __s2_245 = __p2_245; \
+ int32x2_t __rev0_245; __rev0_245 = __builtin_shufflevector(__s0_245, __s0_245, 1, 0); \
+ int8x8_t __rev1_245; __rev1_245 = __builtin_shufflevector(__s1_245, __s1_245, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x16_t __rev2_245; __rev2_245 = __builtin_shufflevector(__s2_245, __s2_245, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+int8x16_t __reint_245 = __rev2_245; \
+int32x2_t __reint1_245 = __noswap_splat_laneq_s32(*(int32x4_t *) &__reint_245, __p3_245); \
+ __ret_245 = __noswap_vdot_s32(__rev0_245, __rev1_245, *(int8x8_t *) &__reint1_245); \
+ __ret_245 = __builtin_shufflevector(__ret_245, __ret_245, 1, 0); \
+ __ret_245; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8_t vaddv_u8(uint8x8_t __p0) {
- uint8_t __ret;
- __ret = (uint8_t) __builtin_neon_vaddv_u8(__p0);
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t vfmlalq_high_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vfmlalq_high_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
return __ret;
}
#else
-__ai uint8_t vaddv_u8(uint8x8_t __p0) {
- uint8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8_t) __builtin_neon_vaddv_u8(__rev0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32_t vaddv_u32(uint32x2_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vaddv_u32(__p0);
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t vfmlalq_high_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vfmlalq_high_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-#else
-__ai uint32_t vaddv_u32(uint32x2_t __p0) {
- uint32_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32_t) __builtin_neon_vaddv_u32(__rev0);
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t __noswap_vfmlalq_high_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vfmlalq_high_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16_t vaddv_u16(uint16x4_t __p0) {
- uint16_t __ret;
- __ret = (uint16_t) __builtin_neon_vaddv_u16(__p0);
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t vfmlal_high_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vfmlal_high_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
return __ret;
}
#else
-__ai uint16_t vaddv_u16(uint16x4_t __p0) {
- uint16_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16_t) __builtin_neon_vaddv_u16(__rev0);
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t vfmlal_high_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vfmlal_high_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t __noswap_vfmlal_high_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vfmlal_high_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8_t vaddv_s8(int8x8_t __p0) {
- int8_t __ret;
- __ret = (int8_t) __builtin_neon_vaddv_s8(__p0);
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t vfmlalq_low_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vfmlalq_low_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
return __ret;
}
#else
-__ai int8_t vaddv_s8(int8x8_t __p0) {
- int8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8_t) __builtin_neon_vaddv_s8(__rev0);
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t vfmlalq_low_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vfmlalq_low_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t __noswap_vfmlalq_low_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vfmlalq_low_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32_t vaddv_f32(float32x2_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vaddv_f32(__p0);
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t vfmlal_low_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vfmlal_low_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
return __ret;
}
#else
-__ai float32_t vaddv_f32(float32x2_t __p0) {
- float32_t __ret;
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t vfmlal_low_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float32_t) __builtin_neon_vaddv_f32(__rev0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int32_t vaddv_s32(int32x2_t __p0) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vaddv_s32(__p0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vfmlal_low_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-#else
-__ai int32_t vaddv_s32(int32x2_t __p0) {
- int32_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int32_t) __builtin_neon_vaddv_s32(__rev0);
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t __noswap_vfmlal_low_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vfmlal_low_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16_t vaddv_s16(int16x4_t __p0) {
- int16_t __ret;
- __ret = (int16_t) __builtin_neon_vaddv_s16(__p0);
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t vfmlslq_high_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vfmlslq_high_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
return __ret;
}
#else
-__ai int16_t vaddv_s16(int16x4_t __p0) {
- int16_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int16_t) __builtin_neon_vaddv_s16(__rev0);
- return __ret;
-}
-#endif
-
-__ai poly64x1_t vbsl_p64(uint64x1_t __p0, poly64x1_t __p1, poly64x1_t __p2) {
- poly64x1_t __ret;
- __ret = (poly64x1_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 6);
- return __ret;
-}
-#ifdef __LITTLE_ENDIAN__
-__ai poly64x2_t vbslq_p64(uint64x2_t __p0, poly64x2_t __p1, poly64x2_t __p2) {
- poly64x2_t __ret;
- __ret = (poly64x2_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 38);
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t vfmlslq_high_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vfmlslq_high_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-#else
-__ai poly64x2_t vbslq_p64(uint64x2_t __p0, poly64x2_t __p1, poly64x2_t __p2) {
- poly64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- poly64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = (poly64x2_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 38);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t __noswap_vfmlslq_high_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vfmlslq_high_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vbslq_f64(uint64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t vfmlsl_high_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vfmlsl_high_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
return __ret;
}
#else
-__ai float64x2_t vbslq_f64(uint64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
- float64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- float64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 42);
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t vfmlsl_high_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vfmlsl_high_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-#endif
-
-__ai float64x1_t vbsl_f64(uint64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 10);
- return __ret;
-}
-#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcageq_f64(float64x2_t __p0, float64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vcageq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
- return __ret;
-}
-#else
-__ai uint64x2_t vcageq_f64(float64x2_t __p0, float64x2_t __p1) {
- uint64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vcageq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t __noswap_vfmlsl_high_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vfmlsl_high_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
return __ret;
}
#endif
-__ai uint64x1_t vcage_f64(float64x1_t __p0, float64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vcage_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
- return __ret;
-}
-__ai uint64_t vcaged_f64(float64_t __p0, float64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcaged_f64(__p0, __p1);
- return __ret;
-}
-__ai uint32_t vcages_f32(float32_t __p0, float32_t __p1) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vcages_f32(__p0, __p1);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcagtq_f64(float64x2_t __p0, float64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vcagtq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t vfmlslq_low_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vfmlslq_low_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
return __ret;
}
#else
-__ai uint64x2_t vcagtq_f64(float64x2_t __p0, float64x2_t __p1) {
- uint64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vcagtq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-__ai uint64x1_t vcagt_f64(float64x1_t __p0, float64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vcagt_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
- return __ret;
-}
-__ai uint64_t vcagtd_f64(float64_t __p0, float64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcagtd_f64(__p0, __p1);
- return __ret;
-}
-__ai uint32_t vcagts_f32(float32_t __p0, float32_t __p1) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vcagts_f32(__p0, __p1);
- return __ret;
-}
-#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcaleq_f64(float64x2_t __p0, float64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vcaleq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t vfmlslq_low_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vfmlslq_low_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-#else
-__ai uint64x2_t vcaleq_f64(float64x2_t __p0, float64x2_t __p1) {
- uint64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vcaleq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t __noswap_vfmlslq_low_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vfmlslq_low_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
return __ret;
}
#endif
-__ai uint64x1_t vcale_f64(float64x1_t __p0, float64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vcale_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
- return __ret;
-}
-__ai uint64_t vcaled_f64(float64_t __p0, float64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcaled_f64(__p0, __p1);
- return __ret;
-}
-__ai uint32_t vcales_f32(float32_t __p0, float32_t __p1) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vcales_f32(__p0, __p1);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcaltq_f64(float64x2_t __p0, float64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vcaltq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t vfmlsl_low_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vfmlsl_low_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
return __ret;
}
#else
-__ai uint64x2_t vcaltq_f64(float64x2_t __p0, float64x2_t __p1) {
- uint64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vcaltq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t vfmlsl_low_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vfmlsl_low_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-#endif
-
-__ai uint64x1_t vcalt_f64(float64x1_t __p0, float64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vcalt_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
- return __ret;
-}
-__ai uint64_t vcaltd_f64(float64_t __p0, float64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcaltd_f64(__p0, __p1);
- return __ret;
-}
-__ai uint32_t vcalts_f32(float32_t __p0, float32_t __p1) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vcalts_f32(__p0, __p1);
- return __ret;
-}
-__ai uint64x1_t vceq_p64(poly64x1_t __p0, poly64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0 == __p1);
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t __noswap_vfmlsl_low_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vfmlsl_low_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
return __ret;
}
+#endif
+
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vceqq_p64(poly64x2_t __p0, poly64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0 == __p1);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vdivq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = __p0 / __p1;
return __ret;
}
#else
-__ai uint64x2_t vceqq_p64(poly64x2_t __p0, poly64x2_t __p1) {
- uint64x2_t __ret;
- poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t)(__rev0 == __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vdivq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 / __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vceqq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0 == __p1);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vdiv_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = __p0 / __p1;
return __ret;
}
#else
-__ai uint64x2_t vceqq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t)(__rev0 == __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vdiv_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 / __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vceqq_f64(float64x2_t __p0, float64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0 == __p1);
- return __ret;
-}
+#define vfmah_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float16_t __ret; \
+ float16_t __s0 = __p0; \
+ float16_t __s1 = __p1; \
+ float16x4_t __s2 = __p2; \
+ __ret = (float16_t) __builtin_neon_vfmah_lane_f16(__s0, __s1, (float16x4_t)__s2, __p3); \
+ __ret; \
+})
#else
-__ai uint64x2_t vceqq_f64(float64x2_t __p0, float64x2_t __p1) {
- uint64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t)(__rev0 == __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vfmah_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float16_t __ret; \
+ float16_t __s0 = __p0; \
+ float16_t __s1 = __p1; \
+ float16x4_t __s2 = __p2; \
+ float16x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+ __ret = (float16_t) __builtin_neon_vfmah_lane_f16(__s0, __s1, (float16x4_t)__rev2, __p3); \
+ __ret; \
+})
+#define __noswap_vfmah_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float16_t __ret; \
+ float16_t __s0 = __p0; \
+ float16_t __s1 = __p1; \
+ float16x4_t __s2 = __p2; \
+ __ret = (float16_t) __builtin_neon_vfmah_lane_f16(__s0, __s1, (float16x4_t)__s2, __p3); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vceqq_s64(int64x2_t __p0, int64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0 == __p1);
- return __ret;
-}
-#else
-__ai uint64x2_t vceqq_s64(int64x2_t __p0, int64x2_t __p1) {
- uint64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t)(__rev0 == __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vfmaq_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __s1 = __p1; \
+ float16x4_t __s2 = __p2; \
+ __ret = (float16x8_t) __builtin_neon_vfmaq_lane_f16((int8x16_t)__s0, (int8x16_t)__s1, (int8x8_t)__s2, __p3, 40); \
+ __ret; \
+})
+#else
+#define vfmaq_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __s1 = __p1; \
+ float16x4_t __s2 = __p2; \
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+ __ret = (float16x8_t) __builtin_neon_vfmaq_lane_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x8_t)__rev2, __p3, 40); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vfmaq_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __s1 = __p1; \
+ float16x4_t __s2 = __p2; \
+ __ret = (float16x8_t) __builtin_neon_vfmaq_lane_f16((int8x16_t)__s0, (int8x16_t)__s1, (int8x8_t)__s2, __p3, 40); \
+ __ret; \
+})
#endif
-__ai uint64x1_t vceq_u64(uint64x1_t __p0, uint64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0 == __p1);
- return __ret;
-}
-__ai uint64x1_t vceq_f64(float64x1_t __p0, float64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0 == __p1);
- return __ret;
-}
-__ai uint64x1_t vceq_s64(int64x1_t __p0, int64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0 == __p1);
- return __ret;
-}
-__ai uint64_t vceqd_u64(uint64_t __p0, uint64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vceqd_u64(__p0, __p1);
- return __ret;
-}
-__ai uint64_t vceqd_s64(int64_t __p0, int64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vceqd_s64(__p0, __p1);
- return __ret;
-}
-__ai uint64_t vceqd_f64(float64_t __p0, float64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vceqd_f64(__p0, __p1);
- return __ret;
-}
-__ai uint32_t vceqs_f32(float32_t __p0, float32_t __p1) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vceqs_f32(__p0, __p1);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vceqz_p8(poly8x8_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 16);
- return __ret;
-}
+#define vfma_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __s1 = __p1; \
+ float16x4_t __s2 = __p2; \
+ __ret = (float16x4_t) __builtin_neon_vfma_lane_f16((int8x8_t)__s0, (int8x8_t)__s1, (int8x8_t)__s2, __p3, 8); \
+ __ret; \
+})
#else
-__ai uint8x8_t vceqz_p8(poly8x8_t __p0) {
- uint8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vfma_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __s1 = __p1; \
+ float16x4_t __s2 = __p2; \
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ float16x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+ __ret = (float16x4_t) __builtin_neon_vfma_lane_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, __p3, 8); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vfma_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __s1 = __p1; \
+ float16x4_t __s2 = __p2; \
+ __ret = (float16x4_t) __builtin_neon_vfma_lane_f16((int8x8_t)__s0, (int8x8_t)__s1, (int8x8_t)__s2, __p3, 8); \
+ __ret; \
+})
#endif
-__ai uint64x1_t vceqz_p64(poly64x1_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 19);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vceqzq_p8(poly8x16_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 48);
- return __ret;
-}
+#define vfmah_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float16_t __ret; \
+ float16_t __s0 = __p0; \
+ float16_t __s1 = __p1; \
+ float16x8_t __s2 = __p2; \
+ __ret = (float16_t) __builtin_neon_vfmah_laneq_f16(__s0, __s1, (float16x8_t)__s2, __p3); \
+ __ret; \
+})
#else
-__ai uint8x16_t vceqzq_p8(poly8x16_t __p0) {
- uint8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vfmah_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float16_t __ret; \
+ float16_t __s0 = __p0; \
+ float16_t __s1 = __p1; \
+ float16x8_t __s2 = __p2; \
+ float16x8_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (float16_t) __builtin_neon_vfmah_laneq_f16(__s0, __s1, (float16x8_t)__rev2, __p3); \
+ __ret; \
+})
+#define __noswap_vfmah_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float16_t __ret; \
+ float16_t __s0 = __p0; \
+ float16_t __s1 = __p1; \
+ float16x8_t __s2 = __p2; \
+ __ret = (float16_t) __builtin_neon_vfmah_laneq_f16(__s0, __s1, (float16x8_t)__s2, __p3); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vceqzq_p64(poly64x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 51);
- return __ret;
-}
+#define vfmaq_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __s1 = __p1; \
+ float16x8_t __s2 = __p2; \
+ __ret = (float16x8_t) __builtin_neon_vfmaq_laneq_f16((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 40); \
+ __ret; \
+})
#else
-__ai uint64x2_t vceqzq_p64(poly64x2_t __p0) {
- uint64x2_t __ret;
- poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vfmaq_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __s1 = __p1; \
+ float16x8_t __s2 = __p2; \
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (float16x8_t) __builtin_neon_vfmaq_laneq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, __p3, 40); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vfmaq_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __s1 = __p1; \
+ float16x8_t __s2 = __p2; \
+ __ret = (float16x8_t) __builtin_neon_vfmaq_laneq_f16((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 40); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vceqzq_u8(uint8x16_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 48);
- return __ret;
-}
+#define vfma_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __s1 = __p1; \
+ float16x8_t __s2 = __p2; \
+ __ret = (float16x4_t) __builtin_neon_vfma_laneq_f16((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__s2, __p3, 8); \
+ __ret; \
+})
#else
-__ai uint8x16_t vceqzq_u8(uint8x16_t __p0) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vfma_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __s1 = __p1; \
+ float16x8_t __s2 = __p2; \
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ float16x8_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (float16x4_t) __builtin_neon_vfma_laneq_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x16_t)__rev2, __p3, 8); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vfma_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __s1 = __p1; \
+ float16x8_t __s2 = __p2; \
+ __ret = (float16x4_t) __builtin_neon_vfma_laneq_f16((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__s2, __p3, 8); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vceqzq_u32(uint32x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 50);
- return __ret;
-}
+#define vfmaq_n_f16(__p0, __p1, __p2) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __s1 = __p1; \
+ float16_t __s2 = __p2; \
+ __ret = vfmaq_f16(__s0, __s1, (float16x8_t) {__s2, __s2, __s2, __s2, __s2, __s2, __s2, __s2}); \
+ __ret; \
+})
#else
-__ai uint32x4_t vceqzq_u32(uint32x4_t __p0) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vfmaq_n_f16(__p0, __p1, __p2) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __s1 = __p1; \
+ float16_t __s2 = __p2; \
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = __noswap_vfmaq_f16(__rev0, __rev1, (float16x8_t) {__s2, __s2, __s2, __s2, __s2, __s2, __s2, __s2}); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vceqzq_u64(uint64x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 51);
- return __ret;
-}
+#define vfma_n_f16(__p0, __p1, __p2) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __s1 = __p1; \
+ float16_t __s2 = __p2; \
+ __ret = vfma_f16(__s0, __s1, (float16x4_t) {__s2, __s2, __s2, __s2}); \
+ __ret; \
+})
#else
-__ai uint64x2_t vceqzq_u64(uint64x2_t __p0) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vfma_n_f16(__p0, __p1, __p2) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __s1 = __p1; \
+ float16_t __s2 = __p2; \
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = __noswap_vfma_f16(__rev0, __rev1, (float16x4_t) {__s2, __s2, __s2, __s2}); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vceqzq_u16(uint16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 49);
- return __ret;
-}
+#define vfmsh_lane_f16(__p0_246, __p1_246, __p2_246, __p3_246) __extension__ ({ \
+ float16_t __ret_246; \
+ float16_t __s0_246 = __p0_246; \
+ float16_t __s1_246 = __p1_246; \
+ float16x4_t __s2_246 = __p2_246; \
+ __ret_246 = vfmah_lane_f16(__s0_246, -__s1_246, __s2_246, __p3_246); \
+ __ret_246; \
+})
#else
-__ai uint16x8_t vceqzq_u16(uint16x8_t __p0) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vfmsh_lane_f16(__p0_247, __p1_247, __p2_247, __p3_247) __extension__ ({ \
+ float16_t __ret_247; \
+ float16_t __s0_247 = __p0_247; \
+ float16_t __s1_247 = __p1_247; \
+ float16x4_t __s2_247 = __p2_247; \
+ float16x4_t __rev2_247; __rev2_247 = __builtin_shufflevector(__s2_247, __s2_247, 3, 2, 1, 0); \
+ __ret_247 = __noswap_vfmah_lane_f16(__s0_247, -__s1_247, __rev2_247, __p3_247); \
+ __ret_247; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vceqzq_s8(int8x16_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 48);
- return __ret;
-}
+#define vfmsq_lane_f16(__p0_248, __p1_248, __p2_248, __p3_248) __extension__ ({ \
+ float16x8_t __ret_248; \
+ float16x8_t __s0_248 = __p0_248; \
+ float16x8_t __s1_248 = __p1_248; \
+ float16x4_t __s2_248 = __p2_248; \
+ __ret_248 = vfmaq_lane_f16(__s0_248, -__s1_248, __s2_248, __p3_248); \
+ __ret_248; \
+})
#else
-__ai uint8x16_t vceqzq_s8(int8x16_t __p0) {
- uint8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vfmsq_lane_f16(__p0_249, __p1_249, __p2_249, __p3_249) __extension__ ({ \
+ float16x8_t __ret_249; \
+ float16x8_t __s0_249 = __p0_249; \
+ float16x8_t __s1_249 = __p1_249; \
+ float16x4_t __s2_249 = __p2_249; \
+ float16x8_t __rev0_249; __rev0_249 = __builtin_shufflevector(__s0_249, __s0_249, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev1_249; __rev1_249 = __builtin_shufflevector(__s1_249, __s1_249, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x4_t __rev2_249; __rev2_249 = __builtin_shufflevector(__s2_249, __s2_249, 3, 2, 1, 0); \
+ __ret_249 = __noswap_vfmaq_lane_f16(__rev0_249, -__rev1_249, __rev2_249, __p3_249); \
+ __ret_249 = __builtin_shufflevector(__ret_249, __ret_249, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_249; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vceqzq_f64(float64x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 51);
- return __ret;
-}
+#define vfms_lane_f16(__p0_250, __p1_250, __p2_250, __p3_250) __extension__ ({ \
+ float16x4_t __ret_250; \
+ float16x4_t __s0_250 = __p0_250; \
+ float16x4_t __s1_250 = __p1_250; \
+ float16x4_t __s2_250 = __p2_250; \
+ __ret_250 = vfma_lane_f16(__s0_250, -__s1_250, __s2_250, __p3_250); \
+ __ret_250; \
+})
#else
-__ai uint64x2_t vceqzq_f64(float64x2_t __p0) {
- uint64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vfms_lane_f16(__p0_251, __p1_251, __p2_251, __p3_251) __extension__ ({ \
+ float16x4_t __ret_251; \
+ float16x4_t __s0_251 = __p0_251; \
+ float16x4_t __s1_251 = __p1_251; \
+ float16x4_t __s2_251 = __p2_251; \
+ float16x4_t __rev0_251; __rev0_251 = __builtin_shufflevector(__s0_251, __s0_251, 3, 2, 1, 0); \
+ float16x4_t __rev1_251; __rev1_251 = __builtin_shufflevector(__s1_251, __s1_251, 3, 2, 1, 0); \
+ float16x4_t __rev2_251; __rev2_251 = __builtin_shufflevector(__s2_251, __s2_251, 3, 2, 1, 0); \
+ __ret_251 = __noswap_vfma_lane_f16(__rev0_251, -__rev1_251, __rev2_251, __p3_251); \
+ __ret_251 = __builtin_shufflevector(__ret_251, __ret_251, 3, 2, 1, 0); \
+ __ret_251; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vceqzq_f32(float32x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 50);
- return __ret;
-}
+#define vfmsh_laneq_f16(__p0_252, __p1_252, __p2_252, __p3_252) __extension__ ({ \
+ float16_t __ret_252; \
+ float16_t __s0_252 = __p0_252; \
+ float16_t __s1_252 = __p1_252; \
+ float16x8_t __s2_252 = __p2_252; \
+ __ret_252 = vfmah_laneq_f16(__s0_252, -__s1_252, __s2_252, __p3_252); \
+ __ret_252; \
+})
#else
-__ai uint32x4_t vceqzq_f32(float32x4_t __p0) {
- uint32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vfmsh_laneq_f16(__p0_253, __p1_253, __p2_253, __p3_253) __extension__ ({ \
+ float16_t __ret_253; \
+ float16_t __s0_253 = __p0_253; \
+ float16_t __s1_253 = __p1_253; \
+ float16x8_t __s2_253 = __p2_253; \
+ float16x8_t __rev2_253; __rev2_253 = __builtin_shufflevector(__s2_253, __s2_253, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_253 = __noswap_vfmah_laneq_f16(__s0_253, -__s1_253, __rev2_253, __p3_253); \
+ __ret_253; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vceqzq_s32(int32x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 50);
- return __ret;
-}
+#define vfmsq_laneq_f16(__p0_254, __p1_254, __p2_254, __p3_254) __extension__ ({ \
+ float16x8_t __ret_254; \
+ float16x8_t __s0_254 = __p0_254; \
+ float16x8_t __s1_254 = __p1_254; \
+ float16x8_t __s2_254 = __p2_254; \
+ __ret_254 = vfmaq_laneq_f16(__s0_254, -__s1_254, __s2_254, __p3_254); \
+ __ret_254; \
+})
#else
-__ai uint32x4_t vceqzq_s32(int32x4_t __p0) {
- uint32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vfmsq_laneq_f16(__p0_255, __p1_255, __p2_255, __p3_255) __extension__ ({ \
+ float16x8_t __ret_255; \
+ float16x8_t __s0_255 = __p0_255; \
+ float16x8_t __s1_255 = __p1_255; \
+ float16x8_t __s2_255 = __p2_255; \
+ float16x8_t __rev0_255; __rev0_255 = __builtin_shufflevector(__s0_255, __s0_255, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev1_255; __rev1_255 = __builtin_shufflevector(__s1_255, __s1_255, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev2_255; __rev2_255 = __builtin_shufflevector(__s2_255, __s2_255, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_255 = __noswap_vfmaq_laneq_f16(__rev0_255, -__rev1_255, __rev2_255, __p3_255); \
+ __ret_255 = __builtin_shufflevector(__ret_255, __ret_255, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_255; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vceqzq_s64(int64x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 51);
- return __ret;
-}
+#define vfms_laneq_f16(__p0_256, __p1_256, __p2_256, __p3_256) __extension__ ({ \
+ float16x4_t __ret_256; \
+ float16x4_t __s0_256 = __p0_256; \
+ float16x4_t __s1_256 = __p1_256; \
+ float16x8_t __s2_256 = __p2_256; \
+ __ret_256 = vfma_laneq_f16(__s0_256, -__s1_256, __s2_256, __p3_256); \
+ __ret_256; \
+})
#else
-__ai uint64x2_t vceqzq_s64(int64x2_t __p0) {
- uint64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vfms_laneq_f16(__p0_257, __p1_257, __p2_257, __p3_257) __extension__ ({ \
+ float16x4_t __ret_257; \
+ float16x4_t __s0_257 = __p0_257; \
+ float16x4_t __s1_257 = __p1_257; \
+ float16x8_t __s2_257 = __p2_257; \
+ float16x4_t __rev0_257; __rev0_257 = __builtin_shufflevector(__s0_257, __s0_257, 3, 2, 1, 0); \
+ float16x4_t __rev1_257; __rev1_257 = __builtin_shufflevector(__s1_257, __s1_257, 3, 2, 1, 0); \
+ float16x8_t __rev2_257; __rev2_257 = __builtin_shufflevector(__s2_257, __s2_257, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_257 = __noswap_vfma_laneq_f16(__rev0_257, -__rev1_257, __rev2_257, __p3_257); \
+ __ret_257 = __builtin_shufflevector(__ret_257, __ret_257, 3, 2, 1, 0); \
+ __ret_257; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vceqzq_s16(int16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 49);
- return __ret;
-}
+#define vfmsq_n_f16(__p0, __p1, __p2) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __s1 = __p1; \
+ float16_t __s2 = __p2; \
+ __ret = vfmaq_f16(__s0, -__s1, (float16x8_t) {__s2, __s2, __s2, __s2, __s2, __s2, __s2, __s2}); \
+ __ret; \
+})
#else
-__ai uint16x8_t vceqzq_s16(int16x8_t __p0) {
- uint16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vfmsq_n_f16(__p0, __p1, __p2) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __s1 = __p1; \
+ float16_t __s2 = __p2; \
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = __noswap_vfmaq_f16(__rev0, -__rev1, (float16x8_t) {__s2, __s2, __s2, __s2, __s2, __s2, __s2, __s2}); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vceqz_u8(uint8x8_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 16);
- return __ret;
-}
+#define vfms_n_f16(__p0, __p1, __p2) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __s1 = __p1; \
+ float16_t __s2 = __p2; \
+ __ret = vfma_f16(__s0, -__s1, (float16x4_t) {__s2, __s2, __s2, __s2}); \
+ __ret; \
+})
#else
-__ai uint8x8_t vceqz_u8(uint8x8_t __p0) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vfms_n_f16(__p0, __p1, __p2) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __s1 = __p1; \
+ float16_t __s2 = __p2; \
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = __noswap_vfma_f16(__rev0, -__rev1, (float16x4_t) {__s2, __s2, __s2, __s2}); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vceqz_u32(uint32x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 18);
- return __ret;
-}
+#define vmaxnmvq_f16(__p0) __extension__ ({ \
+ float16_t __ret; \
+ float16x8_t __s0 = __p0; \
+ __ret = (float16_t) __builtin_neon_vmaxnmvq_f16((int8x16_t)__s0); \
+ __ret; \
+})
#else
-__ai uint32x2_t vceqz_u32(uint32x2_t __p0) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vmaxnmvq_f16(__p0) __extension__ ({ \
+ float16_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (float16_t) __builtin_neon_vmaxnmvq_f16((int8x16_t)__rev0); \
+ __ret; \
+})
#endif
-__ai uint64x1_t vceqz_u64(uint64x1_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 19);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vceqz_u16(uint16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 17);
- return __ret;
-}
+#define vmaxnmv_f16(__p0) __extension__ ({ \
+ float16_t __ret; \
+ float16x4_t __s0 = __p0; \
+ __ret = (float16_t) __builtin_neon_vmaxnmv_f16((int8x8_t)__s0); \
+ __ret; \
+})
#else
-__ai uint16x4_t vceqz_u16(uint16x4_t __p0) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vmaxnmv_f16(__p0) __extension__ ({ \
+ float16_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (float16_t) __builtin_neon_vmaxnmv_f16((int8x8_t)__rev0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vceqz_s8(int8x8_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 16);
- return __ret;
-}
+#define vmaxvq_f16(__p0) __extension__ ({ \
+ float16_t __ret; \
+ float16x8_t __s0 = __p0; \
+ __ret = (float16_t) __builtin_neon_vmaxvq_f16((int8x16_t)__s0); \
+ __ret; \
+})
#else
-__ai uint8x8_t vceqz_s8(int8x8_t __p0) {
- uint8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vmaxvq_f16(__p0) __extension__ ({ \
+ float16_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (float16_t) __builtin_neon_vmaxvq_f16((int8x16_t)__rev0); \
+ __ret; \
+})
#endif
-__ai uint64x1_t vceqz_f64(float64x1_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 19);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vceqz_f32(float32x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 18);
- return __ret;
-}
+#define vmaxv_f16(__p0) __extension__ ({ \
+ float16_t __ret; \
+ float16x4_t __s0 = __p0; \
+ __ret = (float16_t) __builtin_neon_vmaxv_f16((int8x8_t)__s0); \
+ __ret; \
+})
#else
-__ai uint32x2_t vceqz_f32(float32x2_t __p0) {
- uint32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vmaxv_f16(__p0) __extension__ ({ \
+ float16_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (float16_t) __builtin_neon_vmaxv_f16((int8x8_t)__rev0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vceqz_s32(int32x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 18);
- return __ret;
-}
+#define vminnmvq_f16(__p0) __extension__ ({ \
+ float16_t __ret; \
+ float16x8_t __s0 = __p0; \
+ __ret = (float16_t) __builtin_neon_vminnmvq_f16((int8x16_t)__s0); \
+ __ret; \
+})
#else
-__ai uint32x2_t vceqz_s32(int32x2_t __p0) {
- uint32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vminnmvq_f16(__p0) __extension__ ({ \
+ float16_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (float16_t) __builtin_neon_vminnmvq_f16((int8x16_t)__rev0); \
+ __ret; \
+})
#endif
-__ai uint64x1_t vceqz_s64(int64x1_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 19);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vceqz_s16(int16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 17);
- return __ret;
-}
+#define vminnmv_f16(__p0) __extension__ ({ \
+ float16_t __ret; \
+ float16x4_t __s0 = __p0; \
+ __ret = (float16_t) __builtin_neon_vminnmv_f16((int8x8_t)__s0); \
+ __ret; \
+})
#else
-__ai uint16x4_t vceqz_s16(int16x4_t __p0) {
- uint16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vminnmv_f16(__p0) __extension__ ({ \
+ float16_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (float16_t) __builtin_neon_vminnmv_f16((int8x8_t)__rev0); \
+ __ret; \
+})
#endif
-__ai uint64_t vceqzd_u64(uint64_t __p0) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vceqzd_u64(__p0);
- return __ret;
-}
-__ai uint64_t vceqzd_s64(int64_t __p0) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vceqzd_s64(__p0);
- return __ret;
-}
-__ai uint64_t vceqzd_f64(float64_t __p0) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vceqzd_f64(__p0);
- return __ret;
-}
-__ai uint32_t vceqzs_f32(float32_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vceqzs_f32(__p0);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcgeq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0 >= __p1);
- return __ret;
-}
+#define vminvq_f16(__p0) __extension__ ({ \
+ float16_t __ret; \
+ float16x8_t __s0 = __p0; \
+ __ret = (float16_t) __builtin_neon_vminvq_f16((int8x16_t)__s0); \
+ __ret; \
+})
#else
-__ai uint64x2_t vcgeq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t)(__rev0 >= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vminvq_f16(__p0) __extension__ ({ \
+ float16_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (float16_t) __builtin_neon_vminvq_f16((int8x16_t)__rev0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcgeq_f64(float64x2_t __p0, float64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0 >= __p1);
- return __ret;
-}
+#define vminv_f16(__p0) __extension__ ({ \
+ float16_t __ret; \
+ float16x4_t __s0 = __p0; \
+ __ret = (float16_t) __builtin_neon_vminv_f16((int8x8_t)__s0); \
+ __ret; \
+})
#else
-__ai uint64x2_t vcgeq_f64(float64x2_t __p0, float64x2_t __p1) {
- uint64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t)(__rev0 >= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vminv_f16(__p0) __extension__ ({ \
+ float16_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (float16_t) __builtin_neon_vminv_f16((int8x8_t)__rev0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcgeq_s64(int64x2_t __p0, int64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0 >= __p1);
- return __ret;
-}
+#define vmulq_laneq_f16(__p0_258, __p1_258, __p2_258) __extension__ ({ \
+ float16x8_t __ret_258; \
+ float16x8_t __s0_258 = __p0_258; \
+ float16x8_t __s1_258 = __p1_258; \
+ __ret_258 = __s0_258 * splatq_laneq_f16(__s1_258, __p2_258); \
+ __ret_258; \
+})
#else
-__ai uint64x2_t vcgeq_s64(int64x2_t __p0, int64x2_t __p1) {
- uint64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t)(__rev0 >= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vmulq_laneq_f16(__p0_259, __p1_259, __p2_259) __extension__ ({ \
+ float16x8_t __ret_259; \
+ float16x8_t __s0_259 = __p0_259; \
+ float16x8_t __s1_259 = __p1_259; \
+ float16x8_t __rev0_259; __rev0_259 = __builtin_shufflevector(__s0_259, __s0_259, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev1_259; __rev1_259 = __builtin_shufflevector(__s1_259, __s1_259, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_259 = __rev0_259 * __noswap_splatq_laneq_f16(__rev1_259, __p2_259); \
+ __ret_259 = __builtin_shufflevector(__ret_259, __ret_259, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_259; \
+})
#endif
-__ai uint64x1_t vcge_u64(uint64x1_t __p0, uint64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0 >= __p1);
- return __ret;
-}
-__ai uint64x1_t vcge_f64(float64x1_t __p0, float64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0 >= __p1);
+#ifdef __LITTLE_ENDIAN__
+#define vmul_laneq_f16(__p0_260, __p1_260, __p2_260) __extension__ ({ \
+ float16x4_t __ret_260; \
+ float16x4_t __s0_260 = __p0_260; \
+ float16x8_t __s1_260 = __p1_260; \
+ __ret_260 = __s0_260 * splat_laneq_f16(__s1_260, __p2_260); \
+ __ret_260; \
+})
+#else
+#define vmul_laneq_f16(__p0_261, __p1_261, __p2_261) __extension__ ({ \
+ float16x4_t __ret_261; \
+ float16x4_t __s0_261 = __p0_261; \
+ float16x8_t __s1_261 = __p1_261; \
+ float16x4_t __rev0_261; __rev0_261 = __builtin_shufflevector(__s0_261, __s0_261, 3, 2, 1, 0); \
+ float16x8_t __rev1_261; __rev1_261 = __builtin_shufflevector(__s1_261, __s1_261, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_261 = __rev0_261 * __noswap_splat_laneq_f16(__rev1_261, __p2_261); \
+ __ret_261 = __builtin_shufflevector(__ret_261, __ret_261, 3, 2, 1, 0); \
+ __ret_261; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vmulxq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vmulxq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
return __ret;
}
-__ai uint64x1_t vcge_s64(int64x1_t __p0, int64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0 >= __p1);
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vmulxq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vmulxq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai uint64_t vcged_s64(int64_t __p0, int64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcged_s64(__p0, __p1);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t __noswap_vmulxq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vmulxq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
return __ret;
}
-__ai uint64_t vcged_u64(uint64_t __p0, uint64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcged_u64(__p0, __p1);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmulx_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vmulx_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
return __ret;
}
-__ai uint64_t vcged_f64(float64_t __p0, float64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcged_f64(__p0, __p1);
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmulx_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vmulx_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai uint32_t vcges_f32(float32_t __p0, float32_t __p1) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vcges_f32(__p0, __p1);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t __noswap_vmulx_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vmulx_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
return __ret;
}
+#endif
+
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vcgezq_s8(int8x16_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vcgezq_v((int8x16_t)__p0, 48);
- return __ret;
-}
+#define vmulxh_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+ float16_t __ret; \
+ float16_t __s0 = __p0; \
+ float16x4_t __s1 = __p1; \
+ __ret = (float16_t) __builtin_neon_vmulxh_lane_f16(__s0, (float16x4_t)__s1, __p2); \
+ __ret; \
+})
#else
-__ai uint8x16_t vcgezq_s8(int8x16_t __p0) {
- uint8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vcgezq_v((int8x16_t)__rev0, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vmulxh_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+ float16_t __ret; \
+ float16_t __s0 = __p0; \
+ float16x4_t __s1 = __p1; \
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (float16_t) __builtin_neon_vmulxh_lane_f16(__s0, (float16x4_t)__rev1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcgezq_f64(float64x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vcgezq_v((int8x16_t)__p0, 51);
- return __ret;
-}
+#define vmulxq_lane_f16(__p0_262, __p1_262, __p2_262) __extension__ ({ \
+ float16x8_t __ret_262; \
+ float16x8_t __s0_262 = __p0_262; \
+ float16x4_t __s1_262 = __p1_262; \
+ __ret_262 = vmulxq_f16(__s0_262, splatq_lane_f16(__s1_262, __p2_262)); \
+ __ret_262; \
+})
#else
-__ai uint64x2_t vcgezq_f64(float64x2_t __p0) {
- uint64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vcgezq_v((int8x16_t)__rev0, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vmulxq_lane_f16(__p0_263, __p1_263, __p2_263) __extension__ ({ \
+ float16x8_t __ret_263; \
+ float16x8_t __s0_263 = __p0_263; \
+ float16x4_t __s1_263 = __p1_263; \
+ float16x8_t __rev0_263; __rev0_263 = __builtin_shufflevector(__s0_263, __s0_263, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x4_t __rev1_263; __rev1_263 = __builtin_shufflevector(__s1_263, __s1_263, 3, 2, 1, 0); \
+ __ret_263 = __noswap_vmulxq_f16(__rev0_263, __noswap_splatq_lane_f16(__rev1_263, __p2_263)); \
+ __ret_263 = __builtin_shufflevector(__ret_263, __ret_263, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_263; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcgezq_f32(float32x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vcgezq_v((int8x16_t)__p0, 50);
- return __ret;
-}
+#define vmulx_lane_f16(__p0_264, __p1_264, __p2_264) __extension__ ({ \
+ float16x4_t __ret_264; \
+ float16x4_t __s0_264 = __p0_264; \
+ float16x4_t __s1_264 = __p1_264; \
+ __ret_264 = vmulx_f16(__s0_264, splat_lane_f16(__s1_264, __p2_264)); \
+ __ret_264; \
+})
#else
-__ai uint32x4_t vcgezq_f32(float32x4_t __p0) {
- uint32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vcgezq_v((int8x16_t)__rev0, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vmulx_lane_f16(__p0_265, __p1_265, __p2_265) __extension__ ({ \
+ float16x4_t __ret_265; \
+ float16x4_t __s0_265 = __p0_265; \
+ float16x4_t __s1_265 = __p1_265; \
+ float16x4_t __rev0_265; __rev0_265 = __builtin_shufflevector(__s0_265, __s0_265, 3, 2, 1, 0); \
+ float16x4_t __rev1_265; __rev1_265 = __builtin_shufflevector(__s1_265, __s1_265, 3, 2, 1, 0); \
+ __ret_265 = __noswap_vmulx_f16(__rev0_265, __noswap_splat_lane_f16(__rev1_265, __p2_265)); \
+ __ret_265 = __builtin_shufflevector(__ret_265, __ret_265, 3, 2, 1, 0); \
+ __ret_265; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcgezq_s32(int32x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vcgezq_v((int8x16_t)__p0, 50);
- return __ret;
-}
+#define vmulxh_laneq_f16(__p0, __p1, __p2) __extension__ ({ \
+ float16_t __ret; \
+ float16_t __s0 = __p0; \
+ float16x8_t __s1 = __p1; \
+ __ret = (float16_t) __builtin_neon_vmulxh_laneq_f16(__s0, (float16x8_t)__s1, __p2); \
+ __ret; \
+})
#else
-__ai uint32x4_t vcgezq_s32(int32x4_t __p0) {
- uint32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vcgezq_v((int8x16_t)__rev0, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vmulxh_laneq_f16(__p0, __p1, __p2) __extension__ ({ \
+ float16_t __ret; \
+ float16_t __s0 = __p0; \
+ float16x8_t __s1 = __p1; \
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (float16_t) __builtin_neon_vmulxh_laneq_f16(__s0, (float16x8_t)__rev1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcgezq_s64(int64x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vcgezq_v((int8x16_t)__p0, 51);
- return __ret;
-}
+#define vmulxq_laneq_f16(__p0_266, __p1_266, __p2_266) __extension__ ({ \
+ float16x8_t __ret_266; \
+ float16x8_t __s0_266 = __p0_266; \
+ float16x8_t __s1_266 = __p1_266; \
+ __ret_266 = vmulxq_f16(__s0_266, splatq_laneq_f16(__s1_266, __p2_266)); \
+ __ret_266; \
+})
#else
-__ai uint64x2_t vcgezq_s64(int64x2_t __p0) {
- uint64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vcgezq_v((int8x16_t)__rev0, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vmulxq_laneq_f16(__p0_267, __p1_267, __p2_267) __extension__ ({ \
+ float16x8_t __ret_267; \
+ float16x8_t __s0_267 = __p0_267; \
+ float16x8_t __s1_267 = __p1_267; \
+ float16x8_t __rev0_267; __rev0_267 = __builtin_shufflevector(__s0_267, __s0_267, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev1_267; __rev1_267 = __builtin_shufflevector(__s1_267, __s1_267, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_267 = __noswap_vmulxq_f16(__rev0_267, __noswap_splatq_laneq_f16(__rev1_267, __p2_267)); \
+ __ret_267 = __builtin_shufflevector(__ret_267, __ret_267, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_267; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vcgezq_s16(int16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vcgezq_v((int8x16_t)__p0, 49);
- return __ret;
-}
+#define vmulx_laneq_f16(__p0_268, __p1_268, __p2_268) __extension__ ({ \
+ float16x4_t __ret_268; \
+ float16x4_t __s0_268 = __p0_268; \
+ float16x8_t __s1_268 = __p1_268; \
+ __ret_268 = vmulx_f16(__s0_268, splat_laneq_f16(__s1_268, __p2_268)); \
+ __ret_268; \
+})
#else
-__ai uint16x8_t vcgezq_s16(int16x8_t __p0) {
- uint16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vcgezq_v((int8x16_t)__rev0, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vmulx_laneq_f16(__p0_269, __p1_269, __p2_269) __extension__ ({ \
+ float16x4_t __ret_269; \
+ float16x4_t __s0_269 = __p0_269; \
+ float16x8_t __s1_269 = __p1_269; \
+ float16x4_t __rev0_269; __rev0_269 = __builtin_shufflevector(__s0_269, __s0_269, 3, 2, 1, 0); \
+ float16x8_t __rev1_269; __rev1_269 = __builtin_shufflevector(__s1_269, __s1_269, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_269 = __noswap_vmulx_f16(__rev0_269, __noswap_splat_laneq_f16(__rev1_269, __p2_269)); \
+ __ret_269 = __builtin_shufflevector(__ret_269, __ret_269, 3, 2, 1, 0); \
+ __ret_269; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vcgez_s8(int8x8_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vcgez_v((int8x8_t)__p0, 16);
+#define vmulxq_n_f16(__p0, __p1) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16_t __s1 = __p1; \
+ __ret = vmulxq_f16(__s0, (float16x8_t) {__s1, __s1, __s1, __s1, __s1, __s1, __s1, __s1}); \
+ __ret; \
+})
+#else
+#define vmulxq_n_f16(__p0, __p1) __extension__ ({ \
+ float16x8_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16_t __s1 = __p1; \
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = __noswap_vmulxq_f16(__rev0, (float16x8_t) {__s1, __s1, __s1, __s1, __s1, __s1, __s1, __s1}); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulx_n_f16(__p0, __p1) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16_t __s1 = __p1; \
+ __ret = vmulx_f16(__s0, (float16x4_t) {__s1, __s1, __s1, __s1}); \
+ __ret; \
+})
+#else
+#define vmulx_n_f16(__p0, __p1) __extension__ ({ \
+ float16x4_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16_t __s1 = __p1; \
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = __noswap_vmulx_f16(__rev0, (float16x4_t) {__s1, __s1, __s1, __s1}); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpaddq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vpaddq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
return __ret;
}
#else
-__ai uint8x8_t vcgez_s8(int8x8_t __p0) {
- uint8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vcgez_v((int8x8_t)__rev0, 16);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpaddq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vpaddq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vcgez_f64(float64x1_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vcgez_v((int8x8_t)__p0, 19);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcgez_f32(float32x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vcgez_v((int8x8_t)__p0, 18);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpmaxq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vpmaxq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
return __ret;
}
#else
-__ai uint32x2_t vcgez_f32(float32x2_t __p0) {
- uint32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vcgez_v((int8x8_t)__rev0, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpmaxq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vpmaxq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcgez_s32(int32x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vcgez_v((int8x8_t)__p0, 18);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpmaxnmq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vpmaxnmq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
return __ret;
}
#else
-__ai uint32x2_t vcgez_s32(int32x2_t __p0) {
- uint32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vcgez_v((int8x8_t)__rev0, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpmaxnmq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vpmaxnmq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vcgez_s64(int64x1_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vcgez_v((int8x8_t)__p0, 19);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vcgez_s16(int16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vcgez_v((int8x8_t)__p0, 17);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpmaxnm_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vpmaxnm_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
return __ret;
}
#else
-__ai uint16x4_t vcgez_s16(int16x4_t __p0) {
- uint16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vcgez_v((int8x8_t)__rev0, 17);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpmaxnm_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vpmaxnm_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai uint64_t vcgezd_s64(int64_t __p0) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcgezd_s64(__p0);
- return __ret;
-}
-__ai uint64_t vcgezd_f64(float64_t __p0) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcgezd_f64(__p0);
- return __ret;
-}
-__ai uint32_t vcgezs_f32(float32_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vcgezs_f32(__p0);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcgtq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0 > __p1);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpminq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vpminq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
return __ret;
}
#else
-__ai uint64x2_t vcgtq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpminq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vpminq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcgtq_f64(float64x2_t __p0, float64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0 > __p1);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpminnmq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vpminnmq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
return __ret;
}
#else
-__ai uint64x2_t vcgtq_f64(float64x2_t __p0, float64x2_t __p1) {
- uint64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpminnmq_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vpminnmq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcgtq_s64(int64x2_t __p0, int64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0 > __p1);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpminnm_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vpminnm_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
return __ret;
}
#else
-__ai uint64x2_t vcgtq_s64(int64x2_t __p0, int64x2_t __p1) {
- uint64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t)(__rev0 > __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpminnm_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vpminnm_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vcgt_u64(uint64x1_t __p0, uint64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0 > __p1);
- return __ret;
-}
-__ai uint64x1_t vcgt_f64(float64x1_t __p0, float64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0 > __p1);
- return __ret;
-}
-__ai uint64x1_t vcgt_s64(int64x1_t __p0, int64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0 > __p1);
- return __ret;
-}
-__ai uint64_t vcgtd_s64(int64_t __p0, int64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcgtd_s64(__p0, __p1);
- return __ret;
-}
-__ai uint64_t vcgtd_u64(uint64_t __p0, uint64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcgtd_u64(__p0, __p1);
- return __ret;
-}
-__ai uint64_t vcgtd_f64(float64_t __p0, float64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcgtd_f64(__p0, __p1);
- return __ret;
-}
-__ai uint32_t vcgts_f32(float32_t __p0, float32_t __p1) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vcgts_f32(__p0, __p1);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vcgtzq_s8(int8x16_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vcgtzq_v((int8x16_t)__p0, 48);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndiq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vrndiq_f16((int8x16_t)__p0, 40);
return __ret;
}
#else
-__ai uint8x16_t vcgtzq_s8(int8x16_t __p0) {
- uint8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vcgtzq_v((int8x16_t)__rev0, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndiq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vrndiq_f16((int8x16_t)__rev0, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcgtzq_f64(float64x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vcgtzq_v((int8x16_t)__p0, 51);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndi_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vrndi_f16((int8x8_t)__p0, 8);
return __ret;
}
#else
-__ai uint64x2_t vcgtzq_f64(float64x2_t __p0) {
- uint64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vcgtzq_v((int8x16_t)__rev0, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndi_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vrndi_f16((int8x8_t)__rev0, 8);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcgtzq_f32(float32x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vcgtzq_v((int8x16_t)__p0, 50);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vsqrtq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ __ret = (float16x8_t) __builtin_neon_vsqrtq_f16((int8x16_t)__p0, 40);
return __ret;
}
#else
-__ai uint32x4_t vcgtzq_f32(float32x4_t __p0) {
- uint32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vcgtzq_v((int8x16_t)__rev0, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vsqrtq_f16(float16x8_t __p0) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (float16x8_t) __builtin_neon_vsqrtq_f16((int8x16_t)__rev0, 40);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcgtzq_s32(int32x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vcgtzq_v((int8x16_t)__p0, 50);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vsqrt_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t) __builtin_neon_vsqrt_f16((int8x8_t)__p0, 8);
return __ret;
}
#else
-__ai uint32x4_t vcgtzq_s32(int32x4_t __p0) {
- uint32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vcgtzq_v((int8x16_t)__rev0, 50);
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vsqrt_f16(float16x4_t __p0) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float16x4_t) __builtin_neon_vsqrt_f16((int8x8_t)__rev0, 8);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcgtzq_s64(int64x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vcgtzq_v((int8x16_t)__p0, 51);
- return __ret;
-}
+#define vsudotq_laneq_s32(__p0_270, __p1_270, __p2_270, __p3_270) __extension__ ({ \
+ int32x4_t __ret_270; \
+ int32x4_t __s0_270 = __p0_270; \
+ int8x16_t __s1_270 = __p1_270; \
+ uint8x16_t __s2_270 = __p2_270; \
+uint8x16_t __reint_270 = __s2_270; \
+ __ret_270 = vusdotq_s32(__s0_270, (uint8x16_t)(splatq_laneq_s32(*(int32x4_t *) &__reint_270, __p3_270)), __s1_270); \
+ __ret_270; \
+})
#else
-__ai uint64x2_t vcgtzq_s64(int64x2_t __p0) {
- uint64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vcgtzq_v((int8x16_t)__rev0, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vsudotq_laneq_s32(__p0_271, __p1_271, __p2_271, __p3_271) __extension__ ({ \
+ int32x4_t __ret_271; \
+ int32x4_t __s0_271 = __p0_271; \
+ int8x16_t __s1_271 = __p1_271; \
+ uint8x16_t __s2_271 = __p2_271; \
+ int32x4_t __rev0_271; __rev0_271 = __builtin_shufflevector(__s0_271, __s0_271, 3, 2, 1, 0); \
+ int8x16_t __rev1_271; __rev1_271 = __builtin_shufflevector(__s1_271, __s1_271, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x16_t __rev2_271; __rev2_271 = __builtin_shufflevector(__s2_271, __s2_271, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+uint8x16_t __reint_271 = __rev2_271; \
+ __ret_271 = __noswap_vusdotq_s32(__rev0_271, (uint8x16_t)(__noswap_splatq_laneq_s32(*(int32x4_t *) &__reint_271, __p3_271)), __rev1_271); \
+ __ret_271 = __builtin_shufflevector(__ret_271, __ret_271, 3, 2, 1, 0); \
+ __ret_271; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vcgtzq_s16(int16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vcgtzq_v((int8x16_t)__p0, 49);
- return __ret;
-}
+#define vsudot_laneq_s32(__p0_272, __p1_272, __p2_272, __p3_272) __extension__ ({ \
+ int32x2_t __ret_272; \
+ int32x2_t __s0_272 = __p0_272; \
+ int8x8_t __s1_272 = __p1_272; \
+ uint8x16_t __s2_272 = __p2_272; \
+uint8x16_t __reint_272 = __s2_272; \
+ __ret_272 = vusdot_s32(__s0_272, (uint8x8_t)(splat_laneq_s32(*(int32x4_t *) &__reint_272, __p3_272)), __s1_272); \
+ __ret_272; \
+})
#else
-__ai uint16x8_t vcgtzq_s16(int16x8_t __p0) {
- uint16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vcgtzq_v((int8x16_t)__rev0, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vsudot_laneq_s32(__p0_273, __p1_273, __p2_273, __p3_273) __extension__ ({ \
+ int32x2_t __ret_273; \
+ int32x2_t __s0_273 = __p0_273; \
+ int8x8_t __s1_273 = __p1_273; \
+ uint8x16_t __s2_273 = __p2_273; \
+ int32x2_t __rev0_273; __rev0_273 = __builtin_shufflevector(__s0_273, __s0_273, 1, 0); \
+ int8x8_t __rev1_273; __rev1_273 = __builtin_shufflevector(__s1_273, __s1_273, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x16_t __rev2_273; __rev2_273 = __builtin_shufflevector(__s2_273, __s2_273, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+uint8x16_t __reint_273 = __rev2_273; \
+ __ret_273 = __noswap_vusdot_s32(__rev0_273, (uint8x8_t)(__noswap_splat_laneq_s32(*(int32x4_t *) &__reint_273, __p3_273)), __rev1_273); \
+ __ret_273 = __builtin_shufflevector(__ret_273, __ret_273, 1, 0); \
+ __ret_273; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vcgtz_s8(int8x8_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vcgtz_v((int8x8_t)__p0, 16);
+#define vusdotq_laneq_s32(__p0_274, __p1_274, __p2_274, __p3_274) __extension__ ({ \
+ int32x4_t __ret_274; \
+ int32x4_t __s0_274 = __p0_274; \
+ uint8x16_t __s1_274 = __p1_274; \
+ int8x16_t __s2_274 = __p2_274; \
+int8x16_t __reint_274 = __s2_274; \
+ __ret_274 = vusdotq_s32(__s0_274, __s1_274, (int8x16_t)(splatq_laneq_s32(*(int32x4_t *) &__reint_274, __p3_274))); \
+ __ret_274; \
+})
+#else
+#define vusdotq_laneq_s32(__p0_275, __p1_275, __p2_275, __p3_275) __extension__ ({ \
+ int32x4_t __ret_275; \
+ int32x4_t __s0_275 = __p0_275; \
+ uint8x16_t __s1_275 = __p1_275; \
+ int8x16_t __s2_275 = __p2_275; \
+ int32x4_t __rev0_275; __rev0_275 = __builtin_shufflevector(__s0_275, __s0_275, 3, 2, 1, 0); \
+ uint8x16_t __rev1_275; __rev1_275 = __builtin_shufflevector(__s1_275, __s1_275, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x16_t __rev2_275; __rev2_275 = __builtin_shufflevector(__s2_275, __s2_275, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+int8x16_t __reint_275 = __rev2_275; \
+ __ret_275 = __noswap_vusdotq_s32(__rev0_275, __rev1_275, (int8x16_t)(__noswap_splatq_laneq_s32(*(int32x4_t *) &__reint_275, __p3_275))); \
+ __ret_275 = __builtin_shufflevector(__ret_275, __ret_275, 3, 2, 1, 0); \
+ __ret_275; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vusdot_laneq_s32(__p0_276, __p1_276, __p2_276, __p3_276) __extension__ ({ \
+ int32x2_t __ret_276; \
+ int32x2_t __s0_276 = __p0_276; \
+ uint8x8_t __s1_276 = __p1_276; \
+ int8x16_t __s2_276 = __p2_276; \
+int8x16_t __reint_276 = __s2_276; \
+ __ret_276 = vusdot_s32(__s0_276, __s1_276, (int8x8_t)(splat_laneq_s32(*(int32x4_t *) &__reint_276, __p3_276))); \
+ __ret_276; \
+})
+#else
+#define vusdot_laneq_s32(__p0_277, __p1_277, __p2_277, __p3_277) __extension__ ({ \
+ int32x2_t __ret_277; \
+ int32x2_t __s0_277 = __p0_277; \
+ uint8x8_t __s1_277 = __p1_277; \
+ int8x16_t __s2_277 = __p2_277; \
+ int32x2_t __rev0_277; __rev0_277 = __builtin_shufflevector(__s0_277, __s0_277, 1, 0); \
+ uint8x8_t __rev1_277; __rev1_277 = __builtin_shufflevector(__s1_277, __s1_277, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x16_t __rev2_277; __rev2_277 = __builtin_shufflevector(__s2_277, __s2_277, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+int8x16_t __reint_277 = __rev2_277; \
+ __ret_277 = __noswap_vusdot_s32(__rev0_277, __rev1_277, (int8x8_t)(__noswap_splat_laneq_s32(*(int32x4_t *) &__reint_277, __p3_277))); \
+ __ret_277 = __builtin_shufflevector(__ret_277, __ret_277, 1, 0); \
+ __ret_277; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vabdq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
return __ret;
}
#else
-__ai uint8x8_t vcgtz_s8(int8x8_t __p0) {
- uint8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vcgtz_v((int8x8_t)__rev0, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float64x2_t vabdq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vcgtz_f64(float64x1_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vcgtz_v((int8x8_t)__p0, 19);
+__ai __attribute__((target("neon"))) float64x1_t vabd_f64(float64x1_t __p0, float64x1_t __p1) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float64_t vabdd_f64(float64_t __p0, float64_t __p1) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vabdd_f64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float32_t vabds_f32(float32_t __p0, float32_t __p1) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vabds_f32(__p0, __p1);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcgtz_f32(float32x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vcgtz_v((int8x8_t)__p0, 18);
+__ai __attribute__((target("neon"))) float64x2_t vabsq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vabsq_v((int8x16_t)__p0, 42);
return __ret;
}
#else
-__ai uint32x2_t vcgtz_f32(float32x2_t __p0) {
- uint32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vcgtz_v((int8x8_t)__rev0, 18);
+__ai __attribute__((target("neon"))) float64x2_t vabsq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vabsq_v((int8x16_t)__rev0, 42);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcgtz_s32(int32x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vcgtz_v((int8x8_t)__p0, 18);
+__ai __attribute__((target("neon"))) int64x2_t vabsq_s64(int64x2_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vabsq_v((int8x16_t)__p0, 35);
return __ret;
}
#else
-__ai uint32x2_t vcgtz_s32(int32x2_t __p0) {
- uint32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vcgtz_v((int8x8_t)__rev0, 18);
+__ai __attribute__((target("neon"))) int64x2_t vabsq_s64(int64x2_t __p0) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vabsq_v((int8x16_t)__rev0, 35);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vcgtz_s64(int64x1_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vcgtz_v((int8x8_t)__p0, 19);
+__ai __attribute__((target("neon"))) float64x1_t vabs_f64(float64x1_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vabs_v((int8x8_t)__p0, 10);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vabs_s64(int64x1_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t) __builtin_neon_vabs_v((int8x8_t)__p0, 3);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vabsd_s64(int64_t __p0) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vabsd_s64(__p0);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vcgtz_s16(int16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vcgtz_v((int8x8_t)__p0, 17);
+__ai __attribute__((target("neon"))) float64x2_t vaddq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = __p0 + __p1;
return __ret;
}
#else
-__ai uint16x4_t vcgtz_s16(int16x4_t __p0) {
- uint16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vcgtz_v((int8x8_t)__rev0, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float64x2_t vaddq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 + __rev1;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai uint64_t vcgtzd_s64(int64_t __p0) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcgtzd_s64(__p0);
+__ai __attribute__((target("neon"))) float64x1_t vadd_f64(float64x1_t __p0, float64x1_t __p1) {
+ float64x1_t __ret;
+ __ret = __p0 + __p1;
return __ret;
}
-__ai uint64_t vcgtzd_f64(float64_t __p0) {
+__ai __attribute__((target("neon"))) uint64_t vaddd_u64(uint64_t __p0, uint64_t __p1) {
uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcgtzd_f64(__p0);
+ __ret = (uint64_t) __builtin_neon_vaddd_u64(__p0, __p1);
return __ret;
}
-__ai uint32_t vcgtzs_f32(float32_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vcgtzs_f32(__p0);
+__ai __attribute__((target("neon"))) int64_t vaddd_s64(int64_t __p0, int64_t __p1) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vaddd_s64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vaddq_p128(poly128_t __p0, poly128_t __p1) {
+ poly128_t __ret;
+ __ret = (poly128_t) __builtin_neon_vaddq_p128(__p0, __p1);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcleq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0 <= __p1);
+__ai __attribute__((target("neon"))) uint16x8_t vaddhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+ uint16x8_t __ret;
+ __ret = vcombine_u16(__p0, vaddhn_u32(__p1, __p2));
return __ret;
}
#else
-__ai uint64x2_t vcleq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t)(__rev0 <= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint16x8_t vaddhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+ uint16x8_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ uint32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_u16(__rev0, __noswap_vaddhn_u32(__rev1, __rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcleq_f64(float64x2_t __p0, float64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0 <= __p1);
+__ai __attribute__((target("neon"))) uint32x4_t vaddhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+ uint32x4_t __ret;
+ __ret = vcombine_u32(__p0, vaddhn_u64(__p1, __p2));
return __ret;
}
#else
-__ai uint64x2_t vcleq_f64(float64x2_t __p0, float64x2_t __p1) {
- uint64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t)(__rev0 <= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint32x4_t vaddhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+ uint32x4_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ uint64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = __noswap_vcombine_u32(__rev0, __noswap_vaddhn_u64(__rev1, __rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcleq_s64(int64x2_t __p0, int64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0 <= __p1);
+__ai __attribute__((target("neon"))) uint8x16_t vaddhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+ uint8x16_t __ret;
+ __ret = vcombine_u8(__p0, vaddhn_u16(__p1, __p2));
return __ret;
}
#else
-__ai uint64x2_t vcleq_s64(int64x2_t __p0, int64x2_t __p1) {
- uint64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t)(__rev0 <= __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vaddhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+ uint8x16_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_u8(__rev0, __noswap_vaddhn_u16(__rev1, __rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vcle_u64(uint64x1_t __p0, uint64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0 <= __p1);
- return __ret;
-}
-__ai uint64x1_t vcle_f64(float64x1_t __p0, float64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0 <= __p1);
- return __ret;
-}
-__ai uint64x1_t vcle_s64(int64x1_t __p0, int64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0 <= __p1);
- return __ret;
-}
-__ai uint64_t vcled_u64(uint64_t __p0, uint64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcled_u64(__p0, __p1);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vaddhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+ int16x8_t __ret;
+ __ret = vcombine_s16(__p0, vaddhn_s32(__p1, __p2));
return __ret;
}
-__ai uint64_t vcled_s64(int64_t __p0, int64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcled_s64(__p0, __p1);
+#else
+__ai __attribute__((target("neon"))) int16x8_t vaddhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+ int16x8_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_s16(__rev0, __noswap_vaddhn_s32(__rev1, __rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai uint64_t vcled_f64(float64_t __p0, float64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcled_f64(__p0, __p1);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vaddhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+ int32x4_t __ret;
+ __ret = vcombine_s32(__p0, vaddhn_s64(__p1, __p2));
return __ret;
}
-__ai uint32_t vcles_f32(float32_t __p0, float32_t __p1) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vcles_f32(__p0, __p1);
+#else
+__ai __attribute__((target("neon"))) int32x4_t vaddhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+ int32x4_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ int64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = __noswap_vcombine_s32(__rev0, __noswap_vaddhn_s64(__rev1, __rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+#endif
+
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vclezq_s8(int8x16_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vclezq_v((int8x16_t)__p0, 48);
+__ai __attribute__((target("neon"))) int8x16_t vaddhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+ int8x16_t __ret;
+ __ret = vcombine_s8(__p0, vaddhn_s16(__p1, __p2));
return __ret;
}
#else
-__ai uint8x16_t vclezq_s8(int8x16_t __p0) {
- uint8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vclezq_v((int8x16_t)__rev0, 48);
+__ai __attribute__((target("neon"))) int8x16_t vaddhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+ int8x16_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_s8(__rev0, __noswap_vaddhn_s16(__rev1, __rev2));
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vclezq_f64(float64x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vclezq_v((int8x16_t)__p0, 51);
+__ai __attribute__((target("neon"))) uint16_t vaddlvq_u8(uint8x16_t __p0) {
+ uint16_t __ret;
+ __ret = (uint16_t) __builtin_neon_vaddlvq_u8(__p0);
return __ret;
}
#else
-__ai uint64x2_t vclezq_f64(float64x2_t __p0) {
- uint64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vclezq_v((int8x16_t)__rev0, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint16_t vaddlvq_u8(uint8x16_t __p0) {
+ uint16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16_t) __builtin_neon_vaddlvq_u8(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vclezq_f32(float32x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vclezq_v((int8x16_t)__p0, 50);
+__ai __attribute__((target("neon"))) uint64_t vaddlvq_u32(uint32x4_t __p0) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vaddlvq_u32(__p0);
return __ret;
}
#else
-__ai uint32x4_t vclezq_f32(float32x4_t __p0) {
- uint32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vclezq_v((int8x16_t)__rev0, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint64_t vaddlvq_u32(uint32x4_t __p0) {
+ uint64_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint64_t) __builtin_neon_vaddlvq_u32(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vclezq_s32(int32x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vclezq_v((int8x16_t)__p0, 50);
+__ai __attribute__((target("neon"))) uint32_t vaddlvq_u16(uint16x8_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vaddlvq_u16(__p0);
return __ret;
}
#else
-__ai uint32x4_t vclezq_s32(int32x4_t __p0) {
- uint32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vclezq_v((int8x16_t)__rev0, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32_t vaddlvq_u16(uint16x8_t __p0) {
+ uint32_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint32_t) __builtin_neon_vaddlvq_u16(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vclezq_s64(int64x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vclezq_v((int8x16_t)__p0, 51);
+__ai __attribute__((target("neon"))) int16_t vaddlvq_s8(int8x16_t __p0) {
+ int16_t __ret;
+ __ret = (int16_t) __builtin_neon_vaddlvq_s8(__p0);
return __ret;
}
#else
-__ai uint64x2_t vclezq_s64(int64x2_t __p0) {
- uint64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vclezq_v((int8x16_t)__rev0, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int16_t vaddlvq_s8(int8x16_t __p0) {
+ int16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16_t) __builtin_neon_vaddlvq_s8(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vclezq_s16(int16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vclezq_v((int8x16_t)__p0, 49);
+__ai __attribute__((target("neon"))) int64_t vaddlvq_s32(int32x4_t __p0) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vaddlvq_s32(__p0);
return __ret;
}
#else
-__ai uint16x8_t vclezq_s16(int16x8_t __p0) {
- uint16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vclezq_v((int8x16_t)__rev0, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int64_t vaddlvq_s32(int32x4_t __p0) {
+ int64_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int64_t) __builtin_neon_vaddlvq_s32(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vclez_s8(int8x8_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vclez_v((int8x8_t)__p0, 16);
+__ai __attribute__((target("neon"))) int32_t vaddlvq_s16(int16x8_t __p0) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vaddlvq_s16(__p0);
return __ret;
}
#else
-__ai uint8x8_t vclez_s8(int8x8_t __p0) {
- uint8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vclez_v((int8x8_t)__rev0, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32_t vaddlvq_s16(int16x8_t __p0) {
+ int32_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int32_t) __builtin_neon_vaddlvq_s16(__rev0);
return __ret;
}
#endif
-__ai uint64x1_t vclez_f64(float64x1_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vclez_v((int8x8_t)__p0, 19);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vclez_f32(float32x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vclez_v((int8x8_t)__p0, 18);
+__ai __attribute__((target("neon"))) uint16_t vaddlv_u8(uint8x8_t __p0) {
+ uint16_t __ret;
+ __ret = (uint16_t) __builtin_neon_vaddlv_u8(__p0);
return __ret;
}
#else
-__ai uint32x2_t vclez_f32(float32x2_t __p0) {
- uint32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vclez_v((int8x8_t)__rev0, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint16_t vaddlv_u8(uint8x8_t __p0) {
+ uint16_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16_t) __builtin_neon_vaddlv_u8(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vclez_s32(int32x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vclez_v((int8x8_t)__p0, 18);
+__ai __attribute__((target("neon"))) uint64_t vaddlv_u32(uint32x2_t __p0) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vaddlv_u32(__p0);
return __ret;
}
#else
-__ai uint32x2_t vclez_s32(int32x2_t __p0) {
- uint32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vclez_v((int8x8_t)__rev0, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint64_t vaddlv_u32(uint32x2_t __p0) {
+ uint64_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64_t) __builtin_neon_vaddlv_u32(__rev0);
return __ret;
}
#endif
-__ai uint64x1_t vclez_s64(int64x1_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vclez_v((int8x8_t)__p0, 19);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vclez_s16(int16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vclez_v((int8x8_t)__p0, 17);
+__ai __attribute__((target("neon"))) uint32_t vaddlv_u16(uint16x4_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vaddlv_u16(__p0);
return __ret;
}
#else
-__ai uint16x4_t vclez_s16(int16x4_t __p0) {
- uint16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vclez_v((int8x8_t)__rev0, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32_t vaddlv_u16(uint16x4_t __p0) {
+ uint32_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint32_t) __builtin_neon_vaddlv_u16(__rev0);
return __ret;
}
#endif
-__ai uint64_t vclezd_s64(int64_t __p0) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vclezd_s64(__p0);
- return __ret;
-}
-__ai uint64_t vclezd_f64(float64_t __p0) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vclezd_f64(__p0);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16_t vaddlv_s8(int8x8_t __p0) {
+ int16_t __ret;
+ __ret = (int16_t) __builtin_neon_vaddlv_s8(__p0);
return __ret;
}
-__ai uint32_t vclezs_f32(float32_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vclezs_f32(__p0);
+#else
+__ai __attribute__((target("neon"))) int16_t vaddlv_s8(int8x8_t __p0) {
+ int16_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16_t) __builtin_neon_vaddlv_s8(__rev0);
return __ret;
}
+#endif
+
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcltq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0 < __p1);
+__ai __attribute__((target("neon"))) int64_t vaddlv_s32(int32x2_t __p0) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vaddlv_s32(__p0);
return __ret;
}
#else
-__ai uint64x2_t vcltq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t)(__rev0 < __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int64_t vaddlv_s32(int32x2_t __p0) {
+ int64_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int64_t) __builtin_neon_vaddlv_s32(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcltq_f64(float64x2_t __p0, float64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0 < __p1);
+__ai __attribute__((target("neon"))) int32_t vaddlv_s16(int16x4_t __p0) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vaddlv_s16(__p0);
return __ret;
}
#else
-__ai uint64x2_t vcltq_f64(float64x2_t __p0, float64x2_t __p1) {
- uint64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t)(__rev0 < __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int32_t vaddlv_s16(int16x4_t __p0) {
+ int32_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int32_t) __builtin_neon_vaddlv_s16(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcltq_s64(int64x2_t __p0, int64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0 < __p1);
+__ai __attribute__((target("neon"))) uint8_t vaddvq_u8(uint8x16_t __p0) {
+ uint8_t __ret;
+ __ret = (uint8_t) __builtin_neon_vaddvq_u8(__p0);
return __ret;
}
#else
-__ai uint64x2_t vcltq_s64(int64x2_t __p0, int64x2_t __p1) {
- uint64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t)(__rev0 < __rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint8_t vaddvq_u8(uint8x16_t __p0) {
+ uint8_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8_t) __builtin_neon_vaddvq_u8(__rev0);
return __ret;
}
#endif
-__ai uint64x1_t vclt_u64(uint64x1_t __p0, uint64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0 < __p1);
- return __ret;
-}
-__ai uint64x1_t vclt_f64(float64x1_t __p0, float64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0 < __p1);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32_t vaddvq_u32(uint32x4_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vaddvq_u32(__p0);
return __ret;
}
-__ai uint64x1_t vclt_s64(int64x1_t __p0, int64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0 < __p1);
+#else
+__ai __attribute__((target("neon"))) uint32_t vaddvq_u32(uint32x4_t __p0) {
+ uint32_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint32_t) __builtin_neon_vaddvq_u32(__rev0);
return __ret;
}
-__ai uint64_t vcltd_u64(uint64_t __p0, uint64_t __p1) {
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64_t vaddvq_u64(uint64x2_t __p0) {
uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcltd_u64(__p0, __p1);
+ __ret = (uint64_t) __builtin_neon_vaddvq_u64(__p0);
return __ret;
}
-__ai uint64_t vcltd_s64(int64_t __p0, int64_t __p1) {
+#else
+__ai __attribute__((target("neon"))) uint64_t vaddvq_u64(uint64x2_t __p0) {
uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcltd_s64(__p0, __p1);
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64_t) __builtin_neon_vaddvq_u64(__rev0);
return __ret;
}
-__ai uint64_t vcltd_f64(float64_t __p0, float64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcltd_f64(__p0, __p1);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16_t vaddvq_u16(uint16x8_t __p0) {
+ uint16_t __ret;
+ __ret = (uint16_t) __builtin_neon_vaddvq_u16(__p0);
return __ret;
}
-__ai uint32_t vclts_f32(float32_t __p0, float32_t __p1) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vclts_f32(__p0, __p1);
+#else
+__ai __attribute__((target("neon"))) uint16_t vaddvq_u16(uint16x8_t __p0) {
+ uint16_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16_t) __builtin_neon_vaddvq_u16(__rev0);
return __ret;
}
+#endif
+
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vcltzq_s8(int8x16_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vcltzq_v((int8x16_t)__p0, 48);
+__ai __attribute__((target("neon"))) int8_t vaddvq_s8(int8x16_t __p0) {
+ int8_t __ret;
+ __ret = (int8_t) __builtin_neon_vaddvq_s8(__p0);
return __ret;
}
#else
-__ai uint8x16_t vcltzq_s8(int8x16_t __p0) {
- uint8x16_t __ret;
+__ai __attribute__((target("neon"))) int8_t vaddvq_s8(int8x16_t __p0) {
+ int8_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vcltzq_v((int8x16_t)__rev0, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8_t) __builtin_neon_vaddvq_s8(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcltzq_f64(float64x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vcltzq_v((int8x16_t)__p0, 51);
+__ai __attribute__((target("neon"))) float64_t vaddvq_f64(float64x2_t __p0) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vaddvq_f64(__p0);
return __ret;
}
#else
-__ai uint64x2_t vcltzq_f64(float64x2_t __p0) {
- uint64x2_t __ret;
+__ai __attribute__((target("neon"))) float64_t vaddvq_f64(float64x2_t __p0) {
+ float64_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vcltzq_v((int8x16_t)__rev0, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ __ret = (float64_t) __builtin_neon_vaddvq_f64(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcltzq_f32(float32x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vcltzq_v((int8x16_t)__p0, 50);
+__ai __attribute__((target("neon"))) float32_t vaddvq_f32(float32x4_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vaddvq_f32(__p0);
return __ret;
}
#else
-__ai uint32x4_t vcltzq_f32(float32x4_t __p0) {
- uint32x4_t __ret;
+__ai __attribute__((target("neon"))) float32_t vaddvq_f32(float32x4_t __p0) {
+ float32_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vcltzq_v((int8x16_t)__rev0, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ __ret = (float32_t) __builtin_neon_vaddvq_f32(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vcltzq_s32(int32x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vcltzq_v((int8x16_t)__p0, 50);
+__ai __attribute__((target("neon"))) int32_t vaddvq_s32(int32x4_t __p0) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vaddvq_s32(__p0);
return __ret;
}
#else
-__ai uint32x4_t vcltzq_s32(int32x4_t __p0) {
- uint32x4_t __ret;
+__ai __attribute__((target("neon"))) int32_t vaddvq_s32(int32x4_t __p0) {
+ int32_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vcltzq_v((int8x16_t)__rev0, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ __ret = (int32_t) __builtin_neon_vaddvq_s32(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcltzq_s64(int64x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vcltzq_v((int8x16_t)__p0, 51);
+__ai __attribute__((target("neon"))) int64_t vaddvq_s64(int64x2_t __p0) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vaddvq_s64(__p0);
return __ret;
}
#else
-__ai uint64x2_t vcltzq_s64(int64x2_t __p0) {
- uint64x2_t __ret;
+__ai __attribute__((target("neon"))) int64_t vaddvq_s64(int64x2_t __p0) {
+ int64_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vcltzq_v((int8x16_t)__rev0, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ __ret = (int64_t) __builtin_neon_vaddvq_s64(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vcltzq_s16(int16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vcltzq_v((int8x16_t)__p0, 49);
+__ai __attribute__((target("neon"))) int16_t vaddvq_s16(int16x8_t __p0) {
+ int16_t __ret;
+ __ret = (int16_t) __builtin_neon_vaddvq_s16(__p0);
return __ret;
}
#else
-__ai uint16x8_t vcltzq_s16(int16x8_t __p0) {
- uint16x8_t __ret;
+__ai __attribute__((target("neon"))) int16_t vaddvq_s16(int16x8_t __p0) {
+ int16_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vcltzq_v((int8x16_t)__rev0, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16_t) __builtin_neon_vaddvq_s16(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vcltz_s8(int8x8_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vcltz_v((int8x8_t)__p0, 16);
+__ai __attribute__((target("neon"))) uint8_t vaddv_u8(uint8x8_t __p0) {
+ uint8_t __ret;
+ __ret = (uint8_t) __builtin_neon_vaddv_u8(__p0);
return __ret;
}
#else
-__ai uint8x8_t vcltz_s8(int8x8_t __p0) {
- uint8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vcltz_v((int8x8_t)__rev0, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8_t vaddv_u8(uint8x8_t __p0) {
+ uint8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8_t) __builtin_neon_vaddv_u8(__rev0);
return __ret;
}
#endif
-__ai uint64x1_t vcltz_f64(float64x1_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vcltz_v((int8x8_t)__p0, 19);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcltz_f32(float32x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vcltz_v((int8x8_t)__p0, 18);
+__ai __attribute__((target("neon"))) uint32_t vaddv_u32(uint32x2_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vaddv_u32(__p0);
return __ret;
}
#else
-__ai uint32x2_t vcltz_f32(float32x2_t __p0) {
- uint32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vcltz_v((int8x8_t)__rev0, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint32_t vaddv_u32(uint32x2_t __p0) {
+ uint32_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32_t) __builtin_neon_vaddv_u32(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vcltz_s32(int32x2_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vcltz_v((int8x8_t)__p0, 18);
+__ai __attribute__((target("neon"))) uint16_t vaddv_u16(uint16x4_t __p0) {
+ uint16_t __ret;
+ __ret = (uint16_t) __builtin_neon_vaddv_u16(__p0);
return __ret;
}
#else
-__ai uint32x2_t vcltz_s32(int32x2_t __p0) {
- uint32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vcltz_v((int8x8_t)__rev0, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint16_t vaddv_u16(uint16x4_t __p0) {
+ uint16_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16_t) __builtin_neon_vaddv_u16(__rev0);
return __ret;
}
#endif
-__ai uint64x1_t vcltz_s64(int64x1_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vcltz_v((int8x8_t)__p0, 19);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8_t vaddv_s8(int8x8_t __p0) {
+ int8_t __ret;
+ __ret = (int8_t) __builtin_neon_vaddv_s8(__p0);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8_t vaddv_s8(int8x8_t __p0) {
+ int8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8_t) __builtin_neon_vaddv_s8(__rev0);
return __ret;
}
+#endif
+
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vcltz_s16(int16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vcltz_v((int8x8_t)__p0, 17);
+__ai __attribute__((target("neon"))) float32_t vaddv_f32(float32x2_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vaddv_f32(__p0);
return __ret;
}
#else
-__ai uint16x4_t vcltz_s16(int16x4_t __p0) {
- uint16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vcltz_v((int8x8_t)__rev0, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32_t vaddv_f32(float32x2_t __p0) {
+ float32_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float32_t) __builtin_neon_vaddv_f32(__rev0);
return __ret;
}
#endif
-__ai uint64_t vcltzd_s64(int64_t __p0) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcltzd_s64(__p0);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32_t vaddv_s32(int32x2_t __p0) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vaddv_s32(__p0);
return __ret;
}
-__ai uint64_t vcltzd_f64(float64_t __p0) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcltzd_f64(__p0);
+#else
+__ai __attribute__((target("neon"))) int32_t vaddv_s32(int32x2_t __p0) {
+ int32_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int32_t) __builtin_neon_vaddv_s32(__rev0);
return __ret;
}
-__ai uint32_t vcltzs_f32(float32_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vcltzs_f32(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16_t vaddv_s16(int16x4_t __p0) {
+ int16_t __ret;
+ __ret = (int16_t) __builtin_neon_vaddv_s16(__p0);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16_t vaddv_s16(int16x4_t __p0) {
+ int16_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int16_t) __builtin_neon_vaddv_s16(__rev0);
+ return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) poly64x1_t vbsl_p64(uint64x1_t __p0, poly64x1_t __p1, poly64x1_t __p2) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 6);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai poly64x2_t vcombine_p64(poly64x1_t __p0, poly64x1_t __p1) {
+__ai __attribute__((target("neon"))) poly64x2_t vbslq_p64(uint64x2_t __p0, poly64x2_t __p1, poly64x2_t __p2) {
poly64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+ __ret = (poly64x2_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 38);
return __ret;
}
#else
-__ai poly64x2_t vcombine_p64(poly64x1_t __p0, poly64x1_t __p1) {
+__ai __attribute__((target("neon"))) poly64x2_t vbslq_p64(uint64x2_t __p0, poly64x2_t __p1, poly64x2_t __p2) {
poly64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ poly64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = (poly64x2_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 38);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vcombine_f64(float64x1_t __p0, float64x1_t __p1) {
+__ai __attribute__((target("neon"))) float64x2_t vbslq_f64(uint64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
float64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+ __ret = (float64x2_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
return __ret;
}
#else
-__ai float64x2_t vcombine_f64(float64x1_t __p0, float64x1_t __p1) {
+__ai __attribute__((target("neon"))) float64x2_t vbslq_f64(uint64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
float64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ float64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 42);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
+__ai __attribute__((target("neon"))) float64x1_t vbsl_f64(uint64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 10);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_lane_p8(__p0_257, __p1_257, __p2_257, __p3_257) __extension__ ({ \
- poly8x16_t __ret_257; \
- poly8x16_t __s0_257 = __p0_257; \
- poly8x8_t __s2_257 = __p2_257; \
- __ret_257 = vsetq_lane_p8(vget_lane_p8(__s2_257, __p3_257), __s0_257, __p1_257); \
- __ret_257; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcageq_f64(float64x2_t __p0, float64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vcageq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+ return __ret;
+}
#else
-#define vcopyq_lane_p8(__p0_258, __p1_258, __p2_258, __p3_258) __extension__ ({ \
- poly8x16_t __ret_258; \
- poly8x16_t __s0_258 = __p0_258; \
- poly8x8_t __s2_258 = __p2_258; \
- poly8x16_t __rev0_258; __rev0_258 = __builtin_shufflevector(__s0_258, __s0_258, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- poly8x8_t __rev2_258; __rev2_258 = __builtin_shufflevector(__s2_258, __s2_258, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_258 = __noswap_vsetq_lane_p8(__noswap_vget_lane_p8(__rev2_258, __p3_258), __rev0_258, __p1_258); \
- __ret_258 = __builtin_shufflevector(__ret_258, __ret_258, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_258; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcageq_f64(float64x2_t __p0, float64x2_t __p1) {
+ uint64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vcageq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vcage_f64(float64x1_t __p0, float64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vcage_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcaged_f64(float64_t __p0, float64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcaged_f64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcages_f32(float32_t __p0, float32_t __p1) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vcages_f32(__p0, __p1);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_lane_p16(__p0_259, __p1_259, __p2_259, __p3_259) __extension__ ({ \
- poly16x8_t __ret_259; \
- poly16x8_t __s0_259 = __p0_259; \
- poly16x4_t __s2_259 = __p2_259; \
- __ret_259 = vsetq_lane_p16(vget_lane_p16(__s2_259, __p3_259), __s0_259, __p1_259); \
- __ret_259; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcagtq_f64(float64x2_t __p0, float64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vcagtq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+ return __ret;
+}
#else
-#define vcopyq_lane_p16(__p0_260, __p1_260, __p2_260, __p3_260) __extension__ ({ \
- poly16x8_t __ret_260; \
- poly16x8_t __s0_260 = __p0_260; \
- poly16x4_t __s2_260 = __p2_260; \
- poly16x8_t __rev0_260; __rev0_260 = __builtin_shufflevector(__s0_260, __s0_260, 7, 6, 5, 4, 3, 2, 1, 0); \
- poly16x4_t __rev2_260; __rev2_260 = __builtin_shufflevector(__s2_260, __s2_260, 3, 2, 1, 0); \
- __ret_260 = __noswap_vsetq_lane_p16(__noswap_vget_lane_p16(__rev2_260, __p3_260), __rev0_260, __p1_260); \
- __ret_260 = __builtin_shufflevector(__ret_260, __ret_260, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_260; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcagtq_f64(float64x2_t __p0, float64x2_t __p1) {
+ uint64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vcagtq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vcagt_f64(float64x1_t __p0, float64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vcagt_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcagtd_f64(float64_t __p0, float64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcagtd_f64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcagts_f32(float32_t __p0, float32_t __p1) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vcagts_f32(__p0, __p1);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_lane_u8(__p0_261, __p1_261, __p2_261, __p3_261) __extension__ ({ \
- uint8x16_t __ret_261; \
- uint8x16_t __s0_261 = __p0_261; \
- uint8x8_t __s2_261 = __p2_261; \
- __ret_261 = vsetq_lane_u8(vget_lane_u8(__s2_261, __p3_261), __s0_261, __p1_261); \
- __ret_261; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcaleq_f64(float64x2_t __p0, float64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vcaleq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+ return __ret;
+}
#else
-#define vcopyq_lane_u8(__p0_262, __p1_262, __p2_262, __p3_262) __extension__ ({ \
- uint8x16_t __ret_262; \
- uint8x16_t __s0_262 = __p0_262; \
- uint8x8_t __s2_262 = __p2_262; \
- uint8x16_t __rev0_262; __rev0_262 = __builtin_shufflevector(__s0_262, __s0_262, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint8x8_t __rev2_262; __rev2_262 = __builtin_shufflevector(__s2_262, __s2_262, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_262 = __noswap_vsetq_lane_u8(__noswap_vget_lane_u8(__rev2_262, __p3_262), __rev0_262, __p1_262); \
- __ret_262 = __builtin_shufflevector(__ret_262, __ret_262, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_262; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcaleq_f64(float64x2_t __p0, float64x2_t __p1) {
+ uint64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vcaleq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vcale_f64(float64x1_t __p0, float64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vcale_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcaled_f64(float64_t __p0, float64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcaled_f64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcales_f32(float32_t __p0, float32_t __p1) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vcales_f32(__p0, __p1);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_lane_u32(__p0_263, __p1_263, __p2_263, __p3_263) __extension__ ({ \
- uint32x4_t __ret_263; \
- uint32x4_t __s0_263 = __p0_263; \
- uint32x2_t __s2_263 = __p2_263; \
- __ret_263 = vsetq_lane_u32(vget_lane_u32(__s2_263, __p3_263), __s0_263, __p1_263); \
- __ret_263; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcaltq_f64(float64x2_t __p0, float64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vcaltq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+ return __ret;
+}
#else
-#define vcopyq_lane_u32(__p0_264, __p1_264, __p2_264, __p3_264) __extension__ ({ \
- uint32x4_t __ret_264; \
- uint32x4_t __s0_264 = __p0_264; \
- uint32x2_t __s2_264 = __p2_264; \
- uint32x4_t __rev0_264; __rev0_264 = __builtin_shufflevector(__s0_264, __s0_264, 3, 2, 1, 0); \
- uint32x2_t __rev2_264; __rev2_264 = __builtin_shufflevector(__s2_264, __s2_264, 1, 0); \
- __ret_264 = __noswap_vsetq_lane_u32(__noswap_vget_lane_u32(__rev2_264, __p3_264), __rev0_264, __p1_264); \
- __ret_264 = __builtin_shufflevector(__ret_264, __ret_264, 3, 2, 1, 0); \
- __ret_264; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcaltq_f64(float64x2_t __p0, float64x2_t __p1) {
+ uint64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vcaltq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vcalt_f64(float64x1_t __p0, float64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vcalt_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcaltd_f64(float64_t __p0, float64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcaltd_f64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcalts_f32(float32_t __p0, float32_t __p1) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vcalts_f32(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vceq_p64(poly64x1_t __p0, poly64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0 == __p1);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_lane_u64(__p0_265, __p1_265, __p2_265, __p3_265) __extension__ ({ \
- uint64x2_t __ret_265; \
- uint64x2_t __s0_265 = __p0_265; \
- uint64x1_t __s2_265 = __p2_265; \
- __ret_265 = vsetq_lane_u64(vget_lane_u64(__s2_265, __p3_265), __s0_265, __p1_265); \
- __ret_265; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vceqq_p64(poly64x2_t __p0, poly64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0 == __p1);
+ return __ret;
+}
#else
-#define vcopyq_lane_u64(__p0_266, __p1_266, __p2_266, __p3_266) __extension__ ({ \
- uint64x2_t __ret_266; \
- uint64x2_t __s0_266 = __p0_266; \
- uint64x1_t __s2_266 = __p2_266; \
- uint64x2_t __rev0_266; __rev0_266 = __builtin_shufflevector(__s0_266, __s0_266, 1, 0); \
- __ret_266 = __noswap_vsetq_lane_u64(vget_lane_u64(__s2_266, __p3_266), __rev0_266, __p1_266); \
- __ret_266 = __builtin_shufflevector(__ret_266, __ret_266, 1, 0); \
- __ret_266; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vceqq_p64(poly64x2_t __p0, poly64x2_t __p1) {
+ uint64x2_t __ret;
+ poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t)(__rev0 == __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_lane_u16(__p0_267, __p1_267, __p2_267, __p3_267) __extension__ ({ \
- uint16x8_t __ret_267; \
- uint16x8_t __s0_267 = __p0_267; \
- uint16x4_t __s2_267 = __p2_267; \
- __ret_267 = vsetq_lane_u16(vget_lane_u16(__s2_267, __p3_267), __s0_267, __p1_267); \
- __ret_267; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vceqq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0 == __p1);
+ return __ret;
+}
#else
-#define vcopyq_lane_u16(__p0_268, __p1_268, __p2_268, __p3_268) __extension__ ({ \
- uint16x8_t __ret_268; \
- uint16x8_t __s0_268 = __p0_268; \
- uint16x4_t __s2_268 = __p2_268; \
- uint16x8_t __rev0_268; __rev0_268 = __builtin_shufflevector(__s0_268, __s0_268, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x4_t __rev2_268; __rev2_268 = __builtin_shufflevector(__s2_268, __s2_268, 3, 2, 1, 0); \
- __ret_268 = __noswap_vsetq_lane_u16(__noswap_vget_lane_u16(__rev2_268, __p3_268), __rev0_268, __p1_268); \
- __ret_268 = __builtin_shufflevector(__ret_268, __ret_268, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_268; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vceqq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t)(__rev0 == __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_lane_s8(__p0_269, __p1_269, __p2_269, __p3_269) __extension__ ({ \
- int8x16_t __ret_269; \
- int8x16_t __s0_269 = __p0_269; \
- int8x8_t __s2_269 = __p2_269; \
- __ret_269 = vsetq_lane_s8(vget_lane_s8(__s2_269, __p3_269), __s0_269, __p1_269); \
- __ret_269; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vceqq_f64(float64x2_t __p0, float64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0 == __p1);
+ return __ret;
+}
#else
-#define vcopyq_lane_s8(__p0_270, __p1_270, __p2_270, __p3_270) __extension__ ({ \
- int8x16_t __ret_270; \
- int8x16_t __s0_270 = __p0_270; \
- int8x8_t __s2_270 = __p2_270; \
- int8x16_t __rev0_270; __rev0_270 = __builtin_shufflevector(__s0_270, __s0_270, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- int8x8_t __rev2_270; __rev2_270 = __builtin_shufflevector(__s2_270, __s2_270, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_270 = __noswap_vsetq_lane_s8(__noswap_vget_lane_s8(__rev2_270, __p3_270), __rev0_270, __p1_270); \
- __ret_270 = __builtin_shufflevector(__ret_270, __ret_270, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_270; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vceqq_f64(float64x2_t __p0, float64x2_t __p1) {
+ uint64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t)(__rev0 == __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_lane_f32(__p0_271, __p1_271, __p2_271, __p3_271) __extension__ ({ \
- float32x4_t __ret_271; \
- float32x4_t __s0_271 = __p0_271; \
- float32x2_t __s2_271 = __p2_271; \
- __ret_271 = vsetq_lane_f32(vget_lane_f32(__s2_271, __p3_271), __s0_271, __p1_271); \
- __ret_271; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vceqq_s64(int64x2_t __p0, int64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0 == __p1);
+ return __ret;
+}
#else
-#define vcopyq_lane_f32(__p0_272, __p1_272, __p2_272, __p3_272) __extension__ ({ \
- float32x4_t __ret_272; \
- float32x4_t __s0_272 = __p0_272; \
- float32x2_t __s2_272 = __p2_272; \
- float32x4_t __rev0_272; __rev0_272 = __builtin_shufflevector(__s0_272, __s0_272, 3, 2, 1, 0); \
- float32x2_t __rev2_272; __rev2_272 = __builtin_shufflevector(__s2_272, __s2_272, 1, 0); \
- __ret_272 = __noswap_vsetq_lane_f32(__noswap_vget_lane_f32(__rev2_272, __p3_272), __rev0_272, __p1_272); \
- __ret_272 = __builtin_shufflevector(__ret_272, __ret_272, 3, 2, 1, 0); \
- __ret_272; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vceqq_s64(int64x2_t __p0, int64x2_t __p1) {
+ uint64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t)(__rev0 == __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vceq_u64(uint64x1_t __p0, uint64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0 == __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vceq_f64(float64x1_t __p0, float64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0 == __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vceq_s64(int64x1_t __p0, int64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0 == __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vceqd_u64(uint64_t __p0, uint64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vceqd_u64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vceqd_s64(int64_t __p0, int64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vceqd_s64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vceqd_f64(float64_t __p0, float64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vceqd_f64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vceqs_f32(float32_t __p0, float32_t __p1) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vceqs_f32(__p0, __p1);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_lane_s32(__p0_273, __p1_273, __p2_273, __p3_273) __extension__ ({ \
- int32x4_t __ret_273; \
- int32x4_t __s0_273 = __p0_273; \
- int32x2_t __s2_273 = __p2_273; \
- __ret_273 = vsetq_lane_s32(vget_lane_s32(__s2_273, __p3_273), __s0_273, __p1_273); \
- __ret_273; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vceqz_p8(poly8x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 16);
+ return __ret;
+}
#else
-#define vcopyq_lane_s32(__p0_274, __p1_274, __p2_274, __p3_274) __extension__ ({ \
- int32x4_t __ret_274; \
- int32x4_t __s0_274 = __p0_274; \
- int32x2_t __s2_274 = __p2_274; \
- int32x4_t __rev0_274; __rev0_274 = __builtin_shufflevector(__s0_274, __s0_274, 3, 2, 1, 0); \
- int32x2_t __rev2_274; __rev2_274 = __builtin_shufflevector(__s2_274, __s2_274, 1, 0); \
- __ret_274 = __noswap_vsetq_lane_s32(__noswap_vget_lane_s32(__rev2_274, __p3_274), __rev0_274, __p1_274); \
- __ret_274 = __builtin_shufflevector(__ret_274, __ret_274, 3, 2, 1, 0); \
- __ret_274; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vceqz_p8(poly8x8_t __p0) {
+ uint8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vceqz_p64(poly64x1_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 19);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_lane_s64(__p0_275, __p1_275, __p2_275, __p3_275) __extension__ ({ \
- int64x2_t __ret_275; \
- int64x2_t __s0_275 = __p0_275; \
- int64x1_t __s2_275 = __p2_275; \
- __ret_275 = vsetq_lane_s64(vget_lane_s64(__s2_275, __p3_275), __s0_275, __p1_275); \
- __ret_275; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vceqzq_p8(poly8x16_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 48);
+ return __ret;
+}
#else
-#define vcopyq_lane_s64(__p0_276, __p1_276, __p2_276, __p3_276) __extension__ ({ \
- int64x2_t __ret_276; \
- int64x2_t __s0_276 = __p0_276; \
- int64x1_t __s2_276 = __p2_276; \
- int64x2_t __rev0_276; __rev0_276 = __builtin_shufflevector(__s0_276, __s0_276, 1, 0); \
- __ret_276 = __noswap_vsetq_lane_s64(vget_lane_s64(__s2_276, __p3_276), __rev0_276, __p1_276); \
- __ret_276 = __builtin_shufflevector(__ret_276, __ret_276, 1, 0); \
- __ret_276; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vceqzq_p8(poly8x16_t __p0) {
+ uint8x16_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_lane_s16(__p0_277, __p1_277, __p2_277, __p3_277) __extension__ ({ \
- int16x8_t __ret_277; \
- int16x8_t __s0_277 = __p0_277; \
- int16x4_t __s2_277 = __p2_277; \
- __ret_277 = vsetq_lane_s16(vget_lane_s16(__s2_277, __p3_277), __s0_277, __p1_277); \
- __ret_277; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vceqzq_p64(poly64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 51);
+ return __ret;
+}
#else
-#define vcopyq_lane_s16(__p0_278, __p1_278, __p2_278, __p3_278) __extension__ ({ \
- int16x8_t __ret_278; \
- int16x8_t __s0_278 = __p0_278; \
- int16x4_t __s2_278 = __p2_278; \
- int16x8_t __rev0_278; __rev0_278 = __builtin_shufflevector(__s0_278, __s0_278, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x4_t __rev2_278; __rev2_278 = __builtin_shufflevector(__s2_278, __s2_278, 3, 2, 1, 0); \
- __ret_278 = __noswap_vsetq_lane_s16(__noswap_vget_lane_s16(__rev2_278, __p3_278), __rev0_278, __p1_278); \
- __ret_278 = __builtin_shufflevector(__ret_278, __ret_278, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_278; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vceqzq_p64(poly64x2_t __p0) {
+ uint64x2_t __ret;
+ poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopy_lane_p8(__p0_279, __p1_279, __p2_279, __p3_279) __extension__ ({ \
- poly8x8_t __ret_279; \
- poly8x8_t __s0_279 = __p0_279; \
- poly8x8_t __s2_279 = __p2_279; \
- __ret_279 = vset_lane_p8(vget_lane_p8(__s2_279, __p3_279), __s0_279, __p1_279); \
- __ret_279; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vceqzq_u8(uint8x16_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 48);
+ return __ret;
+}
#else
-#define vcopy_lane_p8(__p0_280, __p1_280, __p2_280, __p3_280) __extension__ ({ \
- poly8x8_t __ret_280; \
- poly8x8_t __s0_280 = __p0_280; \
- poly8x8_t __s2_280 = __p2_280; \
- poly8x8_t __rev0_280; __rev0_280 = __builtin_shufflevector(__s0_280, __s0_280, 7, 6, 5, 4, 3, 2, 1, 0); \
- poly8x8_t __rev2_280; __rev2_280 = __builtin_shufflevector(__s2_280, __s2_280, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_280 = __noswap_vset_lane_p8(__noswap_vget_lane_p8(__rev2_280, __p3_280), __rev0_280, __p1_280); \
- __ret_280 = __builtin_shufflevector(__ret_280, __ret_280, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_280; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vceqzq_u8(uint8x16_t __p0) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopy_lane_p16(__p0_281, __p1_281, __p2_281, __p3_281) __extension__ ({ \
- poly16x4_t __ret_281; \
- poly16x4_t __s0_281 = __p0_281; \
- poly16x4_t __s2_281 = __p2_281; \
- __ret_281 = vset_lane_p16(vget_lane_p16(__s2_281, __p3_281), __s0_281, __p1_281); \
- __ret_281; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vceqzq_u32(uint32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 50);
+ return __ret;
+}
#else
-#define vcopy_lane_p16(__p0_282, __p1_282, __p2_282, __p3_282) __extension__ ({ \
- poly16x4_t __ret_282; \
- poly16x4_t __s0_282 = __p0_282; \
- poly16x4_t __s2_282 = __p2_282; \
- poly16x4_t __rev0_282; __rev0_282 = __builtin_shufflevector(__s0_282, __s0_282, 3, 2, 1, 0); \
- poly16x4_t __rev2_282; __rev2_282 = __builtin_shufflevector(__s2_282, __s2_282, 3, 2, 1, 0); \
- __ret_282 = __noswap_vset_lane_p16(__noswap_vget_lane_p16(__rev2_282, __p3_282), __rev0_282, __p1_282); \
- __ret_282 = __builtin_shufflevector(__ret_282, __ret_282, 3, 2, 1, 0); \
- __ret_282; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vceqzq_u32(uint32x4_t __p0) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopy_lane_u8(__p0_283, __p1_283, __p2_283, __p3_283) __extension__ ({ \
- uint8x8_t __ret_283; \
- uint8x8_t __s0_283 = __p0_283; \
- uint8x8_t __s2_283 = __p2_283; \
- __ret_283 = vset_lane_u8(vget_lane_u8(__s2_283, __p3_283), __s0_283, __p1_283); \
- __ret_283; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vceqzq_u64(uint64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 51);
+ return __ret;
+}
#else
-#define vcopy_lane_u8(__p0_284, __p1_284, __p2_284, __p3_284) __extension__ ({ \
- uint8x8_t __ret_284; \
- uint8x8_t __s0_284 = __p0_284; \
- uint8x8_t __s2_284 = __p2_284; \
- uint8x8_t __rev0_284; __rev0_284 = __builtin_shufflevector(__s0_284, __s0_284, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint8x8_t __rev2_284; __rev2_284 = __builtin_shufflevector(__s2_284, __s2_284, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_284 = __noswap_vset_lane_u8(__noswap_vget_lane_u8(__rev2_284, __p3_284), __rev0_284, __p1_284); \
- __ret_284 = __builtin_shufflevector(__ret_284, __ret_284, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_284; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vceqzq_u64(uint64x2_t __p0) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopy_lane_u32(__p0_285, __p1_285, __p2_285, __p3_285) __extension__ ({ \
- uint32x2_t __ret_285; \
- uint32x2_t __s0_285 = __p0_285; \
- uint32x2_t __s2_285 = __p2_285; \
- __ret_285 = vset_lane_u32(vget_lane_u32(__s2_285, __p3_285), __s0_285, __p1_285); \
- __ret_285; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vceqzq_u16(uint16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 49);
+ return __ret;
+}
#else
-#define vcopy_lane_u32(__p0_286, __p1_286, __p2_286, __p3_286) __extension__ ({ \
- uint32x2_t __ret_286; \
- uint32x2_t __s0_286 = __p0_286; \
- uint32x2_t __s2_286 = __p2_286; \
- uint32x2_t __rev0_286; __rev0_286 = __builtin_shufflevector(__s0_286, __s0_286, 1, 0); \
- uint32x2_t __rev2_286; __rev2_286 = __builtin_shufflevector(__s2_286, __s2_286, 1, 0); \
- __ret_286 = __noswap_vset_lane_u32(__noswap_vget_lane_u32(__rev2_286, __p3_286), __rev0_286, __p1_286); \
- __ret_286 = __builtin_shufflevector(__ret_286, __ret_286, 1, 0); \
- __ret_286; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vceqzq_u16(uint16x8_t __p0) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vcopy_lane_u64(__p0_287, __p1_287, __p2_287, __p3_287) __extension__ ({ \
- uint64x1_t __ret_287; \
- uint64x1_t __s0_287 = __p0_287; \
- uint64x1_t __s2_287 = __p2_287; \
- __ret_287 = vset_lane_u64(vget_lane_u64(__s2_287, __p3_287), __s0_287, __p1_287); \
- __ret_287; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vcopy_lane_u16(__p0_288, __p1_288, __p2_288, __p3_288) __extension__ ({ \
- uint16x4_t __ret_288; \
- uint16x4_t __s0_288 = __p0_288; \
- uint16x4_t __s2_288 = __p2_288; \
- __ret_288 = vset_lane_u16(vget_lane_u16(__s2_288, __p3_288), __s0_288, __p1_288); \
- __ret_288; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vceqzq_s8(int8x16_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 48);
+ return __ret;
+}
#else
-#define vcopy_lane_u16(__p0_289, __p1_289, __p2_289, __p3_289) __extension__ ({ \
- uint16x4_t __ret_289; \
- uint16x4_t __s0_289 = __p0_289; \
- uint16x4_t __s2_289 = __p2_289; \
- uint16x4_t __rev0_289; __rev0_289 = __builtin_shufflevector(__s0_289, __s0_289, 3, 2, 1, 0); \
- uint16x4_t __rev2_289; __rev2_289 = __builtin_shufflevector(__s2_289, __s2_289, 3, 2, 1, 0); \
- __ret_289 = __noswap_vset_lane_u16(__noswap_vget_lane_u16(__rev2_289, __p3_289), __rev0_289, __p1_289); \
- __ret_289 = __builtin_shufflevector(__ret_289, __ret_289, 3, 2, 1, 0); \
- __ret_289; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vceqzq_s8(int8x16_t __p0) {
+ uint8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopy_lane_s8(__p0_290, __p1_290, __p2_290, __p3_290) __extension__ ({ \
- int8x8_t __ret_290; \
- int8x8_t __s0_290 = __p0_290; \
- int8x8_t __s2_290 = __p2_290; \
- __ret_290 = vset_lane_s8(vget_lane_s8(__s2_290, __p3_290), __s0_290, __p1_290); \
- __ret_290; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vceqzq_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 51);
+ return __ret;
+}
#else
-#define vcopy_lane_s8(__p0_291, __p1_291, __p2_291, __p3_291) __extension__ ({ \
- int8x8_t __ret_291; \
- int8x8_t __s0_291 = __p0_291; \
- int8x8_t __s2_291 = __p2_291; \
- int8x8_t __rev0_291; __rev0_291 = __builtin_shufflevector(__s0_291, __s0_291, 7, 6, 5, 4, 3, 2, 1, 0); \
- int8x8_t __rev2_291; __rev2_291 = __builtin_shufflevector(__s2_291, __s2_291, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_291 = __noswap_vset_lane_s8(__noswap_vget_lane_s8(__rev2_291, __p3_291), __rev0_291, __p1_291); \
- __ret_291 = __builtin_shufflevector(__ret_291, __ret_291, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_291; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vceqzq_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopy_lane_f32(__p0_292, __p1_292, __p2_292, __p3_292) __extension__ ({ \
- float32x2_t __ret_292; \
- float32x2_t __s0_292 = __p0_292; \
- float32x2_t __s2_292 = __p2_292; \
- __ret_292 = vset_lane_f32(vget_lane_f32(__s2_292, __p3_292), __s0_292, __p1_292); \
- __ret_292; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vceqzq_f32(float32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 50);
+ return __ret;
+}
#else
-#define vcopy_lane_f32(__p0_293, __p1_293, __p2_293, __p3_293) __extension__ ({ \
- float32x2_t __ret_293; \
- float32x2_t __s0_293 = __p0_293; \
- float32x2_t __s2_293 = __p2_293; \
- float32x2_t __rev0_293; __rev0_293 = __builtin_shufflevector(__s0_293, __s0_293, 1, 0); \
- float32x2_t __rev2_293; __rev2_293 = __builtin_shufflevector(__s2_293, __s2_293, 1, 0); \
- __ret_293 = __noswap_vset_lane_f32(__noswap_vget_lane_f32(__rev2_293, __p3_293), __rev0_293, __p1_293); \
- __ret_293 = __builtin_shufflevector(__ret_293, __ret_293, 1, 0); \
- __ret_293; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vceqzq_f32(float32x4_t __p0) {
+ uint32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopy_lane_s32(__p0_294, __p1_294, __p2_294, __p3_294) __extension__ ({ \
- int32x2_t __ret_294; \
- int32x2_t __s0_294 = __p0_294; \
- int32x2_t __s2_294 = __p2_294; \
- __ret_294 = vset_lane_s32(vget_lane_s32(__s2_294, __p3_294), __s0_294, __p1_294); \
- __ret_294; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vceqzq_s32(int32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 50);
+ return __ret;
+}
#else
-#define vcopy_lane_s32(__p0_295, __p1_295, __p2_295, __p3_295) __extension__ ({ \
- int32x2_t __ret_295; \
- int32x2_t __s0_295 = __p0_295; \
- int32x2_t __s2_295 = __p2_295; \
- int32x2_t __rev0_295; __rev0_295 = __builtin_shufflevector(__s0_295, __s0_295, 1, 0); \
- int32x2_t __rev2_295; __rev2_295 = __builtin_shufflevector(__s2_295, __s2_295, 1, 0); \
- __ret_295 = __noswap_vset_lane_s32(__noswap_vget_lane_s32(__rev2_295, __p3_295), __rev0_295, __p1_295); \
- __ret_295 = __builtin_shufflevector(__ret_295, __ret_295, 1, 0); \
- __ret_295; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vceqzq_s32(int32x4_t __p0) {
+ uint32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vcopy_lane_s64(__p0_296, __p1_296, __p2_296, __p3_296) __extension__ ({ \
- int64x1_t __ret_296; \
- int64x1_t __s0_296 = __p0_296; \
- int64x1_t __s2_296 = __p2_296; \
- __ret_296 = vset_lane_s64(vget_lane_s64(__s2_296, __p3_296), __s0_296, __p1_296); \
- __ret_296; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vcopy_lane_s16(__p0_297, __p1_297, __p2_297, __p3_297) __extension__ ({ \
- int16x4_t __ret_297; \
- int16x4_t __s0_297 = __p0_297; \
- int16x4_t __s2_297 = __p2_297; \
- __ret_297 = vset_lane_s16(vget_lane_s16(__s2_297, __p3_297), __s0_297, __p1_297); \
- __ret_297; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vceqzq_s64(int64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 51);
+ return __ret;
+}
#else
-#define vcopy_lane_s16(__p0_298, __p1_298, __p2_298, __p3_298) __extension__ ({ \
- int16x4_t __ret_298; \
- int16x4_t __s0_298 = __p0_298; \
- int16x4_t __s2_298 = __p2_298; \
- int16x4_t __rev0_298; __rev0_298 = __builtin_shufflevector(__s0_298, __s0_298, 3, 2, 1, 0); \
- int16x4_t __rev2_298; __rev2_298 = __builtin_shufflevector(__s2_298, __s2_298, 3, 2, 1, 0); \
- __ret_298 = __noswap_vset_lane_s16(__noswap_vget_lane_s16(__rev2_298, __p3_298), __rev0_298, __p1_298); \
- __ret_298 = __builtin_shufflevector(__ret_298, __ret_298, 3, 2, 1, 0); \
- __ret_298; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vceqzq_s64(int64x2_t __p0) {
+ uint64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_laneq_p8(__p0_299, __p1_299, __p2_299, __p3_299) __extension__ ({ \
- poly8x16_t __ret_299; \
- poly8x16_t __s0_299 = __p0_299; \
- poly8x16_t __s2_299 = __p2_299; \
- __ret_299 = vsetq_lane_p8(vgetq_lane_p8(__s2_299, __p3_299), __s0_299, __p1_299); \
- __ret_299; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vceqzq_s16(int16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 49);
+ return __ret;
+}
#else
-#define vcopyq_laneq_p8(__p0_300, __p1_300, __p2_300, __p3_300) __extension__ ({ \
- poly8x16_t __ret_300; \
- poly8x16_t __s0_300 = __p0_300; \
- poly8x16_t __s2_300 = __p2_300; \
- poly8x16_t __rev0_300; __rev0_300 = __builtin_shufflevector(__s0_300, __s0_300, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- poly8x16_t __rev2_300; __rev2_300 = __builtin_shufflevector(__s2_300, __s2_300, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_300 = __noswap_vsetq_lane_p8(__noswap_vgetq_lane_p8(__rev2_300, __p3_300), __rev0_300, __p1_300); \
- __ret_300 = __builtin_shufflevector(__ret_300, __ret_300, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_300; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vceqzq_s16(int16x8_t __p0) {
+ uint16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_laneq_p16(__p0_301, __p1_301, __p2_301, __p3_301) __extension__ ({ \
- poly16x8_t __ret_301; \
- poly16x8_t __s0_301 = __p0_301; \
- poly16x8_t __s2_301 = __p2_301; \
- __ret_301 = vsetq_lane_p16(vgetq_lane_p16(__s2_301, __p3_301), __s0_301, __p1_301); \
- __ret_301; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vceqz_u8(uint8x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 16);
+ return __ret;
+}
#else
-#define vcopyq_laneq_p16(__p0_302, __p1_302, __p2_302, __p3_302) __extension__ ({ \
- poly16x8_t __ret_302; \
- poly16x8_t __s0_302 = __p0_302; \
- poly16x8_t __s2_302 = __p2_302; \
- poly16x8_t __rev0_302; __rev0_302 = __builtin_shufflevector(__s0_302, __s0_302, 7, 6, 5, 4, 3, 2, 1, 0); \
- poly16x8_t __rev2_302; __rev2_302 = __builtin_shufflevector(__s2_302, __s2_302, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_302 = __noswap_vsetq_lane_p16(__noswap_vgetq_lane_p16(__rev2_302, __p3_302), __rev0_302, __p1_302); \
- __ret_302 = __builtin_shufflevector(__ret_302, __ret_302, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_302; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vceqz_u8(uint8x8_t __p0) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_laneq_u8(__p0_303, __p1_303, __p2_303, __p3_303) __extension__ ({ \
- uint8x16_t __ret_303; \
- uint8x16_t __s0_303 = __p0_303; \
- uint8x16_t __s2_303 = __p2_303; \
- __ret_303 = vsetq_lane_u8(vgetq_lane_u8(__s2_303, __p3_303), __s0_303, __p1_303); \
- __ret_303; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vceqz_u32(uint32x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 18);
+ return __ret;
+}
#else
-#define vcopyq_laneq_u8(__p0_304, __p1_304, __p2_304, __p3_304) __extension__ ({ \
- uint8x16_t __ret_304; \
- uint8x16_t __s0_304 = __p0_304; \
- uint8x16_t __s2_304 = __p2_304; \
- uint8x16_t __rev0_304; __rev0_304 = __builtin_shufflevector(__s0_304, __s0_304, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint8x16_t __rev2_304; __rev2_304 = __builtin_shufflevector(__s2_304, __s2_304, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_304 = __noswap_vsetq_lane_u8(__noswap_vgetq_lane_u8(__rev2_304, __p3_304), __rev0_304, __p1_304); \
- __ret_304 = __builtin_shufflevector(__ret_304, __ret_304, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_304; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcopyq_laneq_u32(__p0_305, __p1_305, __p2_305, __p3_305) __extension__ ({ \
- uint32x4_t __ret_305; \
- uint32x4_t __s0_305 = __p0_305; \
- uint32x4_t __s2_305 = __p2_305; \
- __ret_305 = vsetq_lane_u32(vgetq_lane_u32(__s2_305, __p3_305), __s0_305, __p1_305); \
- __ret_305; \
-})
-#else
-#define vcopyq_laneq_u32(__p0_306, __p1_306, __p2_306, __p3_306) __extension__ ({ \
- uint32x4_t __ret_306; \
- uint32x4_t __s0_306 = __p0_306; \
- uint32x4_t __s2_306 = __p2_306; \
- uint32x4_t __rev0_306; __rev0_306 = __builtin_shufflevector(__s0_306, __s0_306, 3, 2, 1, 0); \
- uint32x4_t __rev2_306; __rev2_306 = __builtin_shufflevector(__s2_306, __s2_306, 3, 2, 1, 0); \
- __ret_306 = __noswap_vsetq_lane_u32(__noswap_vgetq_lane_u32(__rev2_306, __p3_306), __rev0_306, __p1_306); \
- __ret_306 = __builtin_shufflevector(__ret_306, __ret_306, 3, 2, 1, 0); \
- __ret_306; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vceqz_u32(uint32x2_t __p0) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vceqz_u64(uint64x1_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 19);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_laneq_u64(__p0_307, __p1_307, __p2_307, __p3_307) __extension__ ({ \
- uint64x2_t __ret_307; \
- uint64x2_t __s0_307 = __p0_307; \
- uint64x2_t __s2_307 = __p2_307; \
- __ret_307 = vsetq_lane_u64(vgetq_lane_u64(__s2_307, __p3_307), __s0_307, __p1_307); \
- __ret_307; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vceqz_u16(uint16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 17);
+ return __ret;
+}
#else
-#define vcopyq_laneq_u64(__p0_308, __p1_308, __p2_308, __p3_308) __extension__ ({ \
- uint64x2_t __ret_308; \
- uint64x2_t __s0_308 = __p0_308; \
- uint64x2_t __s2_308 = __p2_308; \
- uint64x2_t __rev0_308; __rev0_308 = __builtin_shufflevector(__s0_308, __s0_308, 1, 0); \
- uint64x2_t __rev2_308; __rev2_308 = __builtin_shufflevector(__s2_308, __s2_308, 1, 0); \
- __ret_308 = __noswap_vsetq_lane_u64(__noswap_vgetq_lane_u64(__rev2_308, __p3_308), __rev0_308, __p1_308); \
- __ret_308 = __builtin_shufflevector(__ret_308, __ret_308, 1, 0); \
- __ret_308; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vceqz_u16(uint16x4_t __p0) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_laneq_u16(__p0_309, __p1_309, __p2_309, __p3_309) __extension__ ({ \
- uint16x8_t __ret_309; \
- uint16x8_t __s0_309 = __p0_309; \
- uint16x8_t __s2_309 = __p2_309; \
- __ret_309 = vsetq_lane_u16(vgetq_lane_u16(__s2_309, __p3_309), __s0_309, __p1_309); \
- __ret_309; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vceqz_s8(int8x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 16);
+ return __ret;
+}
#else
-#define vcopyq_laneq_u16(__p0_310, __p1_310, __p2_310, __p3_310) __extension__ ({ \
- uint16x8_t __ret_310; \
- uint16x8_t __s0_310 = __p0_310; \
- uint16x8_t __s2_310 = __p2_310; \
- uint16x8_t __rev0_310; __rev0_310 = __builtin_shufflevector(__s0_310, __s0_310, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x8_t __rev2_310; __rev2_310 = __builtin_shufflevector(__s2_310, __s2_310, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_310 = __noswap_vsetq_lane_u16(__noswap_vgetq_lane_u16(__rev2_310, __p3_310), __rev0_310, __p1_310); \
- __ret_310 = __builtin_shufflevector(__ret_310, __ret_310, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_310; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vceqz_s8(int8x8_t __p0) {
+ uint8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vceqz_f64(float64x1_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 19);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_laneq_s8(__p0_311, __p1_311, __p2_311, __p3_311) __extension__ ({ \
- int8x16_t __ret_311; \
- int8x16_t __s0_311 = __p0_311; \
- int8x16_t __s2_311 = __p2_311; \
- __ret_311 = vsetq_lane_s8(vgetq_lane_s8(__s2_311, __p3_311), __s0_311, __p1_311); \
- __ret_311; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vceqz_f32(float32x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 18);
+ return __ret;
+}
#else
-#define vcopyq_laneq_s8(__p0_312, __p1_312, __p2_312, __p3_312) __extension__ ({ \
- int8x16_t __ret_312; \
- int8x16_t __s0_312 = __p0_312; \
- int8x16_t __s2_312 = __p2_312; \
- int8x16_t __rev0_312; __rev0_312 = __builtin_shufflevector(__s0_312, __s0_312, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- int8x16_t __rev2_312; __rev2_312 = __builtin_shufflevector(__s2_312, __s2_312, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_312 = __noswap_vsetq_lane_s8(__noswap_vgetq_lane_s8(__rev2_312, __p3_312), __rev0_312, __p1_312); \
- __ret_312 = __builtin_shufflevector(__ret_312, __ret_312, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_312; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vceqz_f32(float32x2_t __p0) {
+ uint32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_laneq_f32(__p0_313, __p1_313, __p2_313, __p3_313) __extension__ ({ \
- float32x4_t __ret_313; \
- float32x4_t __s0_313 = __p0_313; \
- float32x4_t __s2_313 = __p2_313; \
- __ret_313 = vsetq_lane_f32(vgetq_lane_f32(__s2_313, __p3_313), __s0_313, __p1_313); \
- __ret_313; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vceqz_s32(int32x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 18);
+ return __ret;
+}
#else
-#define vcopyq_laneq_f32(__p0_314, __p1_314, __p2_314, __p3_314) __extension__ ({ \
- float32x4_t __ret_314; \
- float32x4_t __s0_314 = __p0_314; \
- float32x4_t __s2_314 = __p2_314; \
- float32x4_t __rev0_314; __rev0_314 = __builtin_shufflevector(__s0_314, __s0_314, 3, 2, 1, 0); \
- float32x4_t __rev2_314; __rev2_314 = __builtin_shufflevector(__s2_314, __s2_314, 3, 2, 1, 0); \
- __ret_314 = __noswap_vsetq_lane_f32(__noswap_vgetq_lane_f32(__rev2_314, __p3_314), __rev0_314, __p1_314); \
- __ret_314 = __builtin_shufflevector(__ret_314, __ret_314, 3, 2, 1, 0); \
- __ret_314; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vceqz_s32(int32x2_t __p0) {
+ uint32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vceqz_s64(int64x1_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 19);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_laneq_s32(__p0_315, __p1_315, __p2_315, __p3_315) __extension__ ({ \
- int32x4_t __ret_315; \
- int32x4_t __s0_315 = __p0_315; \
- int32x4_t __s2_315 = __p2_315; \
- __ret_315 = vsetq_lane_s32(vgetq_lane_s32(__s2_315, __p3_315), __s0_315, __p1_315); \
- __ret_315; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vceqz_s16(int16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 17);
+ return __ret;
+}
#else
-#define vcopyq_laneq_s32(__p0_316, __p1_316, __p2_316, __p3_316) __extension__ ({ \
- int32x4_t __ret_316; \
- int32x4_t __s0_316 = __p0_316; \
- int32x4_t __s2_316 = __p2_316; \
- int32x4_t __rev0_316; __rev0_316 = __builtin_shufflevector(__s0_316, __s0_316, 3, 2, 1, 0); \
- int32x4_t __rev2_316; __rev2_316 = __builtin_shufflevector(__s2_316, __s2_316, 3, 2, 1, 0); \
- __ret_316 = __noswap_vsetq_lane_s32(__noswap_vgetq_lane_s32(__rev2_316, __p3_316), __rev0_316, __p1_316); \
- __ret_316 = __builtin_shufflevector(__ret_316, __ret_316, 3, 2, 1, 0); \
- __ret_316; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vceqz_s16(int16x4_t __p0) {
+ uint16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64_t vceqzd_u64(uint64_t __p0) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vceqzd_u64(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vceqzd_s64(int64_t __p0) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vceqzd_s64(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vceqzd_f64(float64_t __p0) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vceqzd_f64(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vceqzs_f32(float32_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vceqzs_f32(__p0);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_laneq_s64(__p0_317, __p1_317, __p2_317, __p3_317) __extension__ ({ \
- int64x2_t __ret_317; \
- int64x2_t __s0_317 = __p0_317; \
- int64x2_t __s2_317 = __p2_317; \
- __ret_317 = vsetq_lane_s64(vgetq_lane_s64(__s2_317, __p3_317), __s0_317, __p1_317); \
- __ret_317; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcgeq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0 >= __p1);
+ return __ret;
+}
#else
-#define vcopyq_laneq_s64(__p0_318, __p1_318, __p2_318, __p3_318) __extension__ ({ \
- int64x2_t __ret_318; \
- int64x2_t __s0_318 = __p0_318; \
- int64x2_t __s2_318 = __p2_318; \
- int64x2_t __rev0_318; __rev0_318 = __builtin_shufflevector(__s0_318, __s0_318, 1, 0); \
- int64x2_t __rev2_318; __rev2_318 = __builtin_shufflevector(__s2_318, __s2_318, 1, 0); \
- __ret_318 = __noswap_vsetq_lane_s64(__noswap_vgetq_lane_s64(__rev2_318, __p3_318), __rev0_318, __p1_318); \
- __ret_318 = __builtin_shufflevector(__ret_318, __ret_318, 1, 0); \
- __ret_318; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcgeq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_laneq_s16(__p0_319, __p1_319, __p2_319, __p3_319) __extension__ ({ \
- int16x8_t __ret_319; \
- int16x8_t __s0_319 = __p0_319; \
- int16x8_t __s2_319 = __p2_319; \
- __ret_319 = vsetq_lane_s16(vgetq_lane_s16(__s2_319, __p3_319), __s0_319, __p1_319); \
- __ret_319; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcgeq_f64(float64x2_t __p0, float64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0 >= __p1);
+ return __ret;
+}
#else
-#define vcopyq_laneq_s16(__p0_320, __p1_320, __p2_320, __p3_320) __extension__ ({ \
- int16x8_t __ret_320; \
- int16x8_t __s0_320 = __p0_320; \
- int16x8_t __s2_320 = __p2_320; \
- int16x8_t __rev0_320; __rev0_320 = __builtin_shufflevector(__s0_320, __s0_320, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev2_320; __rev2_320 = __builtin_shufflevector(__s2_320, __s2_320, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_320 = __noswap_vsetq_lane_s16(__noswap_vgetq_lane_s16(__rev2_320, __p3_320), __rev0_320, __p1_320); \
- __ret_320 = __builtin_shufflevector(__ret_320, __ret_320, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_320; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcgeq_f64(float64x2_t __p0, float64x2_t __p1) {
+ uint64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopy_laneq_p8(__p0_321, __p1_321, __p2_321, __p3_321) __extension__ ({ \
- poly8x8_t __ret_321; \
- poly8x8_t __s0_321 = __p0_321; \
- poly8x16_t __s2_321 = __p2_321; \
- __ret_321 = vset_lane_p8(vgetq_lane_p8(__s2_321, __p3_321), __s0_321, __p1_321); \
- __ret_321; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcgeq_s64(int64x2_t __p0, int64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0 >= __p1);
+ return __ret;
+}
#else
-#define vcopy_laneq_p8(__p0_322, __p1_322, __p2_322, __p3_322) __extension__ ({ \
- poly8x8_t __ret_322; \
- poly8x8_t __s0_322 = __p0_322; \
- poly8x16_t __s2_322 = __p2_322; \
- poly8x8_t __rev0_322; __rev0_322 = __builtin_shufflevector(__s0_322, __s0_322, 7, 6, 5, 4, 3, 2, 1, 0); \
- poly8x16_t __rev2_322; __rev2_322 = __builtin_shufflevector(__s2_322, __s2_322, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_322 = __noswap_vset_lane_p8(__noswap_vgetq_lane_p8(__rev2_322, __p3_322), __rev0_322, __p1_322); \
- __ret_322 = __builtin_shufflevector(__ret_322, __ret_322, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_322; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcgeq_s64(int64x2_t __p0, int64x2_t __p1) {
+ uint64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t)(__rev0 >= __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vcge_u64(uint64x1_t __p0, uint64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0 >= __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vcge_f64(float64x1_t __p0, float64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0 >= __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vcge_s64(int64x1_t __p0, int64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0 >= __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcged_s64(int64_t __p0, int64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcged_s64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcged_u64(uint64_t __p0, uint64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcged_u64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcged_f64(float64_t __p0, float64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcged_f64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcges_f32(float32_t __p0, float32_t __p1) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vcges_f32(__p0, __p1);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vcopy_laneq_p16(__p0_323, __p1_323, __p2_323, __p3_323) __extension__ ({ \
- poly16x4_t __ret_323; \
- poly16x4_t __s0_323 = __p0_323; \
- poly16x8_t __s2_323 = __p2_323; \
- __ret_323 = vset_lane_p16(vgetq_lane_p16(__s2_323, __p3_323), __s0_323, __p1_323); \
- __ret_323; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vcgezq_s8(int8x16_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vcgezq_v((int8x16_t)__p0, 48);
+ return __ret;
+}
#else
-#define vcopy_laneq_p16(__p0_324, __p1_324, __p2_324, __p3_324) __extension__ ({ \
- poly16x4_t __ret_324; \
- poly16x4_t __s0_324 = __p0_324; \
- poly16x8_t __s2_324 = __p2_324; \
- poly16x4_t __rev0_324; __rev0_324 = __builtin_shufflevector(__s0_324, __s0_324, 3, 2, 1, 0); \
- poly16x8_t __rev2_324; __rev2_324 = __builtin_shufflevector(__s2_324, __s2_324, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_324 = __noswap_vset_lane_p16(__noswap_vgetq_lane_p16(__rev2_324, __p3_324), __rev0_324, __p1_324); \
- __ret_324 = __builtin_shufflevector(__ret_324, __ret_324, 3, 2, 1, 0); \
- __ret_324; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vcgezq_s8(int8x16_t __p0) {
+ uint8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vcgezq_v((int8x16_t)__rev0, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopy_laneq_u8(__p0_325, __p1_325, __p2_325, __p3_325) __extension__ ({ \
- uint8x8_t __ret_325; \
- uint8x8_t __s0_325 = __p0_325; \
- uint8x16_t __s2_325 = __p2_325; \
- __ret_325 = vset_lane_u8(vgetq_lane_u8(__s2_325, __p3_325), __s0_325, __p1_325); \
- __ret_325; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcgezq_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vcgezq_v((int8x16_t)__p0, 51);
+ return __ret;
+}
#else
-#define vcopy_laneq_u8(__p0_326, __p1_326, __p2_326, __p3_326) __extension__ ({ \
- uint8x8_t __ret_326; \
- uint8x8_t __s0_326 = __p0_326; \
- uint8x16_t __s2_326 = __p2_326; \
- uint8x8_t __rev0_326; __rev0_326 = __builtin_shufflevector(__s0_326, __s0_326, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint8x16_t __rev2_326; __rev2_326 = __builtin_shufflevector(__s2_326, __s2_326, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_326 = __noswap_vset_lane_u8(__noswap_vgetq_lane_u8(__rev2_326, __p3_326), __rev0_326, __p1_326); \
- __ret_326 = __builtin_shufflevector(__ret_326, __ret_326, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_326; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcgezq_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vcgezq_v((int8x16_t)__rev0, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopy_laneq_u32(__p0_327, __p1_327, __p2_327, __p3_327) __extension__ ({ \
- uint32x2_t __ret_327; \
- uint32x2_t __s0_327 = __p0_327; \
- uint32x4_t __s2_327 = __p2_327; \
- __ret_327 = vset_lane_u32(vgetq_lane_u32(__s2_327, __p3_327), __s0_327, __p1_327); \
- __ret_327; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcgezq_f32(float32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vcgezq_v((int8x16_t)__p0, 50);
+ return __ret;
+}
#else
-#define vcopy_laneq_u32(__p0_328, __p1_328, __p2_328, __p3_328) __extension__ ({ \
- uint32x2_t __ret_328; \
- uint32x2_t __s0_328 = __p0_328; \
- uint32x4_t __s2_328 = __p2_328; \
- uint32x2_t __rev0_328; __rev0_328 = __builtin_shufflevector(__s0_328, __s0_328, 1, 0); \
- uint32x4_t __rev2_328; __rev2_328 = __builtin_shufflevector(__s2_328, __s2_328, 3, 2, 1, 0); \
- __ret_328 = __noswap_vset_lane_u32(__noswap_vgetq_lane_u32(__rev2_328, __p3_328), __rev0_328, __p1_328); \
- __ret_328 = __builtin_shufflevector(__ret_328, __ret_328, 1, 0); \
- __ret_328; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcgezq_f32(float32x4_t __p0) {
+ uint32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vcgezq_v((int8x16_t)__rev0, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopy_laneq_u64(__p0_329, __p1_329, __p2_329, __p3_329) __extension__ ({ \
- uint64x1_t __ret_329; \
- uint64x1_t __s0_329 = __p0_329; \
- uint64x2_t __s2_329 = __p2_329; \
- __ret_329 = vset_lane_u64(vgetq_lane_u64(__s2_329, __p3_329), __s0_329, __p1_329); \
- __ret_329; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcgezq_s32(int32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vcgezq_v((int8x16_t)__p0, 50);
+ return __ret;
+}
#else
-#define vcopy_laneq_u64(__p0_330, __p1_330, __p2_330, __p3_330) __extension__ ({ \
- uint64x1_t __ret_330; \
- uint64x1_t __s0_330 = __p0_330; \
- uint64x2_t __s2_330 = __p2_330; \
- uint64x2_t __rev2_330; __rev2_330 = __builtin_shufflevector(__s2_330, __s2_330, 1, 0); \
- __ret_330 = vset_lane_u64(__noswap_vgetq_lane_u64(__rev2_330, __p3_330), __s0_330, __p1_330); \
- __ret_330; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vcgezq_s32(int32x4_t __p0) {
+ uint32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vcgezq_v((int8x16_t)__rev0, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopy_laneq_u16(__p0_331, __p1_331, __p2_331, __p3_331) __extension__ ({ \
- uint16x4_t __ret_331; \
- uint16x4_t __s0_331 = __p0_331; \
- uint16x8_t __s2_331 = __p2_331; \
- __ret_331 = vset_lane_u16(vgetq_lane_u16(__s2_331, __p3_331), __s0_331, __p1_331); \
- __ret_331; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcgezq_s64(int64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vcgezq_v((int8x16_t)__p0, 51);
+ return __ret;
+}
#else
-#define vcopy_laneq_u16(__p0_332, __p1_332, __p2_332, __p3_332) __extension__ ({ \
- uint16x4_t __ret_332; \
- uint16x4_t __s0_332 = __p0_332; \
- uint16x8_t __s2_332 = __p2_332; \
- uint16x4_t __rev0_332; __rev0_332 = __builtin_shufflevector(__s0_332, __s0_332, 3, 2, 1, 0); \
- uint16x8_t __rev2_332; __rev2_332 = __builtin_shufflevector(__s2_332, __s2_332, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_332 = __noswap_vset_lane_u16(__noswap_vgetq_lane_u16(__rev2_332, __p3_332), __rev0_332, __p1_332); \
- __ret_332 = __builtin_shufflevector(__ret_332, __ret_332, 3, 2, 1, 0); \
- __ret_332; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcgezq_s64(int64x2_t __p0) {
+ uint64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vcgezq_v((int8x16_t)__rev0, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopy_laneq_s8(__p0_333, __p1_333, __p2_333, __p3_333) __extension__ ({ \
- int8x8_t __ret_333; \
- int8x8_t __s0_333 = __p0_333; \
- int8x16_t __s2_333 = __p2_333; \
- __ret_333 = vset_lane_s8(vgetq_lane_s8(__s2_333, __p3_333), __s0_333, __p1_333); \
- __ret_333; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vcgezq_s16(int16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vcgezq_v((int8x16_t)__p0, 49);
+ return __ret;
+}
#else
-#define vcopy_laneq_s8(__p0_334, __p1_334, __p2_334, __p3_334) __extension__ ({ \
- int8x8_t __ret_334; \
- int8x8_t __s0_334 = __p0_334; \
- int8x16_t __s2_334 = __p2_334; \
- int8x8_t __rev0_334; __rev0_334 = __builtin_shufflevector(__s0_334, __s0_334, 7, 6, 5, 4, 3, 2, 1, 0); \
- int8x16_t __rev2_334; __rev2_334 = __builtin_shufflevector(__s2_334, __s2_334, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_334 = __noswap_vset_lane_s8(__noswap_vgetq_lane_s8(__rev2_334, __p3_334), __rev0_334, __p1_334); \
- __ret_334 = __builtin_shufflevector(__ret_334, __ret_334, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_334; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vcgezq_s16(int16x8_t __p0) {
+ uint16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vcgezq_v((int8x16_t)__rev0, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopy_laneq_f32(__p0_335, __p1_335, __p2_335, __p3_335) __extension__ ({ \
- float32x2_t __ret_335; \
- float32x2_t __s0_335 = __p0_335; \
- float32x4_t __s2_335 = __p2_335; \
- __ret_335 = vset_lane_f32(vgetq_lane_f32(__s2_335, __p3_335), __s0_335, __p1_335); \
- __ret_335; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vcgez_s8(int8x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vcgez_v((int8x8_t)__p0, 16);
+ return __ret;
+}
#else
-#define vcopy_laneq_f32(__p0_336, __p1_336, __p2_336, __p3_336) __extension__ ({ \
- float32x2_t __ret_336; \
- float32x2_t __s0_336 = __p0_336; \
- float32x4_t __s2_336 = __p2_336; \
- float32x2_t __rev0_336; __rev0_336 = __builtin_shufflevector(__s0_336, __s0_336, 1, 0); \
- float32x4_t __rev2_336; __rev2_336 = __builtin_shufflevector(__s2_336, __s2_336, 3, 2, 1, 0); \
- __ret_336 = __noswap_vset_lane_f32(__noswap_vgetq_lane_f32(__rev2_336, __p3_336), __rev0_336, __p1_336); \
- __ret_336 = __builtin_shufflevector(__ret_336, __ret_336, 1, 0); \
- __ret_336; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vcgez_s8(int8x8_t __p0) {
+ uint8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vcgez_v((int8x8_t)__rev0, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vcgez_f64(float64x1_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vcgez_v((int8x8_t)__p0, 19);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vcopy_laneq_s32(__p0_337, __p1_337, __p2_337, __p3_337) __extension__ ({ \
- int32x2_t __ret_337; \
- int32x2_t __s0_337 = __p0_337; \
- int32x4_t __s2_337 = __p2_337; \
- __ret_337 = vset_lane_s32(vgetq_lane_s32(__s2_337, __p3_337), __s0_337, __p1_337); \
- __ret_337; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcgez_f32(float32x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vcgez_v((int8x8_t)__p0, 18);
+ return __ret;
+}
#else
-#define vcopy_laneq_s32(__p0_338, __p1_338, __p2_338, __p3_338) __extension__ ({ \
- int32x2_t __ret_338; \
- int32x2_t __s0_338 = __p0_338; \
- int32x4_t __s2_338 = __p2_338; \
- int32x2_t __rev0_338; __rev0_338 = __builtin_shufflevector(__s0_338, __s0_338, 1, 0); \
- int32x4_t __rev2_338; __rev2_338 = __builtin_shufflevector(__s2_338, __s2_338, 3, 2, 1, 0); \
- __ret_338 = __noswap_vset_lane_s32(__noswap_vgetq_lane_s32(__rev2_338, __p3_338), __rev0_338, __p1_338); \
- __ret_338 = __builtin_shufflevector(__ret_338, __ret_338, 1, 0); \
- __ret_338; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcgez_f32(float32x2_t __p0) {
+ uint32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vcgez_v((int8x8_t)__rev0, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopy_laneq_s64(__p0_339, __p1_339, __p2_339, __p3_339) __extension__ ({ \
- int64x1_t __ret_339; \
- int64x1_t __s0_339 = __p0_339; \
- int64x2_t __s2_339 = __p2_339; \
- __ret_339 = vset_lane_s64(vgetq_lane_s64(__s2_339, __p3_339), __s0_339, __p1_339); \
- __ret_339; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcgez_s32(int32x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vcgez_v((int8x8_t)__p0, 18);
+ return __ret;
+}
#else
-#define vcopy_laneq_s64(__p0_340, __p1_340, __p2_340, __p3_340) __extension__ ({ \
- int64x1_t __ret_340; \
- int64x1_t __s0_340 = __p0_340; \
- int64x2_t __s2_340 = __p2_340; \
- int64x2_t __rev2_340; __rev2_340 = __builtin_shufflevector(__s2_340, __s2_340, 1, 0); \
- __ret_340 = vset_lane_s64(__noswap_vgetq_lane_s64(__rev2_340, __p3_340), __s0_340, __p1_340); \
- __ret_340; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcgez_s32(int32x2_t __p0) {
+ uint32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vcgez_v((int8x8_t)__rev0, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vcgez_s64(int64x1_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vcgez_v((int8x8_t)__p0, 19);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vcopy_laneq_s16(__p0_341, __p1_341, __p2_341, __p3_341) __extension__ ({ \
- int16x4_t __ret_341; \
- int16x4_t __s0_341 = __p0_341; \
- int16x8_t __s2_341 = __p2_341; \
- __ret_341 = vset_lane_s16(vgetq_lane_s16(__s2_341, __p3_341), __s0_341, __p1_341); \
- __ret_341; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vcgez_s16(int16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vcgez_v((int8x8_t)__p0, 17);
+ return __ret;
+}
#else
-#define vcopy_laneq_s16(__p0_342, __p1_342, __p2_342, __p3_342) __extension__ ({ \
- int16x4_t __ret_342; \
- int16x4_t __s0_342 = __p0_342; \
- int16x8_t __s2_342 = __p2_342; \
- int16x4_t __rev0_342; __rev0_342 = __builtin_shufflevector(__s0_342, __s0_342, 3, 2, 1, 0); \
- int16x8_t __rev2_342; __rev2_342 = __builtin_shufflevector(__s2_342, __s2_342, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_342 = __noswap_vset_lane_s16(__noswap_vgetq_lane_s16(__rev2_342, __p3_342), __rev0_342, __p1_342); \
- __ret_342 = __builtin_shufflevector(__ret_342, __ret_342, 3, 2, 1, 0); \
- __ret_342; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vcgez_s16(int16x4_t __p0) {
+ uint16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vcgez_v((int8x8_t)__rev0, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vcreate_p64(__p0) __extension__ ({ \
- poly64x1_t __ret; \
- uint64_t __promote = __p0; \
- __ret = (poly64x1_t)(__promote); \
- __ret; \
-})
-#define vcreate_f64(__p0) __extension__ ({ \
- float64x1_t __ret; \
- uint64_t __promote = __p0; \
- __ret = (float64x1_t)(__promote); \
- __ret; \
-})
-__ai float32_t vcvts_f32_s32(int32_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vcvts_f32_s32(__p0);
+__ai __attribute__((target("neon"))) uint64_t vcgezd_s64(int64_t __p0) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcgezd_s64(__p0);
return __ret;
}
-__ai float32_t vcvts_f32_u32(uint32_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vcvts_f32_u32(__p0);
+__ai __attribute__((target("neon"))) uint64_t vcgezd_f64(float64_t __p0) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcgezd_f64(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcgezs_f32(float32_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vcgezs_f32(__p0);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vcvt_f32_f64(float64x2_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vcvt_f32_f64((int8x16_t)__p0, 9);
+__ai __attribute__((target("neon"))) uint64x2_t vcgtq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0 > __p1);
return __ret;
}
#else
-__ai float32x2_t vcvt_f32_f64(float64x2_t __p0) {
- float32x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vcvt_f32_f64((int8x16_t)__rev0, 9);
+__ai __attribute__((target("neon"))) uint64x2_t vcgtq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t)(__rev0 > __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai float32x2_t __noswap_vcvt_f32_f64(float64x2_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vcvt_f32_f64((int8x16_t)__p0, 9);
- return __ret;
-}
#endif
-__ai float64_t vcvtd_f64_s64(int64_t __p0) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vcvtd_f64_s64(__p0);
- return __ret;
-}
-__ai float64_t vcvtd_f64_u64(uint64_t __p0) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vcvtd_f64_u64(__p0);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vcvtq_f64_u64(uint64x2_t __p0) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vcvtq_f64_v((int8x16_t)__p0, 51);
+__ai __attribute__((target("neon"))) uint64x2_t vcgtq_f64(float64x2_t __p0, float64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0 > __p1);
return __ret;
}
#else
-__ai float64x2_t vcvtq_f64_u64(uint64x2_t __p0) {
- float64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vcvtq_f64_v((int8x16_t)__rev0, 51);
+__ai __attribute__((target("neon"))) uint64x2_t vcgtq_f64(float64x2_t __p0, float64x2_t __p1) {
+ uint64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t)(__rev0 > __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vcvtq_f64_s64(int64x2_t __p0) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vcvtq_f64_v((int8x16_t)__p0, 35);
+__ai __attribute__((target("neon"))) uint64x2_t vcgtq_s64(int64x2_t __p0, int64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0 > __p1);
return __ret;
}
#else
-__ai float64x2_t vcvtq_f64_s64(int64x2_t __p0) {
- float64x2_t __ret;
+__ai __attribute__((target("neon"))) uint64x2_t vcgtq_s64(int64x2_t __p0, int64x2_t __p1) {
+ uint64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vcvtq_f64_v((int8x16_t)__rev0, 35);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t)(__rev0 > __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai float64x1_t vcvt_f64_u64(uint64x1_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vcvt_f64_v((int8x8_t)__p0, 19);
+__ai __attribute__((target("neon"))) uint64x1_t vcgt_u64(uint64x1_t __p0, uint64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0 > __p1);
return __ret;
}
-__ai float64x1_t vcvt_f64_s64(int64x1_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vcvt_f64_v((int8x8_t)__p0, 3);
+__ai __attribute__((target("neon"))) uint64x1_t vcgt_f64(float64x1_t __p0, float64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0 > __p1);
return __ret;
}
-#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vcvt_f64_f32(float32x2_t __p0) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vcvt_f64_f32((int8x8_t)__p0, 42);
+__ai __attribute__((target("neon"))) uint64x1_t vcgt_s64(int64x1_t __p0, int64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0 > __p1);
return __ret;
}
-#else
-__ai float64x2_t vcvt_f64_f32(float32x2_t __p0) {
- float64x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vcvt_f64_f32((int8x8_t)__rev0, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint64_t vcgtd_s64(int64_t __p0, int64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcgtd_s64(__p0, __p1);
return __ret;
}
-__ai float64x2_t __noswap_vcvt_f64_f32(float32x2_t __p0) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vcvt_f64_f32((int8x8_t)__p0, 42);
+__ai __attribute__((target("neon"))) uint64_t vcgtd_u64(uint64_t __p0, uint64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcgtd_u64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcgtd_f64(float64_t __p0, float64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcgtd_f64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcgts_f32(float32_t __p0, float32_t __p1) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vcgts_f32(__p0, __p1);
+ return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vcgtzq_s8(int8x16_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vcgtzq_v((int8x16_t)__p0, 48);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vcgtzq_s8(int8x16_t __p0) {
+ uint8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vcgtzq_v((int8x16_t)__rev0, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float16x8_t vcvt_high_f16_f32(float16x4_t __p0, float32x4_t __p1) {
- float16x8_t __ret;
- __ret = vcombine_f16(__p0, vcvt_f16_f32(__p1));
+__ai __attribute__((target("neon"))) uint64x2_t vcgtzq_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vcgtzq_v((int8x16_t)__p0, 51);
return __ret;
}
#else
-__ai float16x8_t vcvt_high_f16_f32(float16x4_t __p0, float32x4_t __p1) {
- float16x8_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vcombine_f16(__rev0, __noswap_vcvt_f16_f32(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint64x2_t vcgtzq_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vcgtzq_v((int8x16_t)__rev0, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vcvt_high_f32_f16(float16x8_t __p0) {
- float32x4_t __ret;
- __ret = vcvt_f32_f16(vget_high_f16(__p0));
+__ai __attribute__((target("neon"))) uint32x4_t vcgtzq_f32(float32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vcgtzq_v((int8x16_t)__p0, 50);
return __ret;
}
#else
-__ai float32x4_t vcvt_high_f32_f16(float16x8_t __p0) {
- float32x4_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vcvt_f32_f16(__noswap_vget_high_f16(__rev0));
+__ai __attribute__((target("neon"))) uint32x4_t vcgtzq_f32(float32x4_t __p0) {
+ uint32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vcgtzq_v((int8x16_t)__rev0, 50);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vcvt_high_f32_f64(float32x2_t __p0, float64x2_t __p1) {
- float32x4_t __ret;
- __ret = vcombine_f32(__p0, vcvt_f32_f64(__p1));
+__ai __attribute__((target("neon"))) uint32x4_t vcgtzq_s32(int32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vcgtzq_v((int8x16_t)__p0, 50);
return __ret;
}
#else
-__ai float32x4_t vcvt_high_f32_f64(float32x2_t __p0, float64x2_t __p1) {
- float32x4_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __noswap_vcombine_f32(__rev0, __noswap_vcvt_f32_f64(__rev1));
+__ai __attribute__((target("neon"))) uint32x4_t vcgtzq_s32(int32x4_t __p0) {
+ uint32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vcgtzq_v((int8x16_t)__rev0, 50);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vcvt_high_f64_f32(float32x4_t __p0) {
- float64x2_t __ret;
- __ret = vcvt_f64_f32(vget_high_f32(__p0));
+__ai __attribute__((target("neon"))) uint64x2_t vcgtzq_s64(int64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vcgtzq_v((int8x16_t)__p0, 51);
return __ret;
}
#else
-__ai float64x2_t vcvt_high_f64_f32(float32x4_t __p0) {
- float64x2_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __noswap_vcvt_f64_f32(__noswap_vget_high_f32(__rev0));
+__ai __attribute__((target("neon"))) uint64x2_t vcgtzq_s64(int64x2_t __p0) {
+ uint64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vcgtzq_v((int8x16_t)__rev0, 51);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-#define vcvts_n_f32_u32(__p0, __p1) __extension__ ({ \
- float32_t __ret; \
- uint32_t __s0 = __p0; \
- __ret = (float32_t) __builtin_neon_vcvts_n_f32_u32(__s0, __p1); \
- __ret; \
-})
-#define vcvts_n_f32_s32(__p0, __p1) __extension__ ({ \
- float32_t __ret; \
- int32_t __s0 = __p0; \
- __ret = (float32_t) __builtin_neon_vcvts_n_f32_s32(__s0, __p1); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vcvtq_n_f64_u64(__p0, __p1) __extension__ ({ \
- float64x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- __ret = (float64x2_t) __builtin_neon_vcvtq_n_f64_v((int8x16_t)__s0, __p1, 51); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vcgtzq_s16(int16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vcgtzq_v((int8x16_t)__p0, 49);
+ return __ret;
+}
#else
-#define vcvtq_n_f64_u64(__p0, __p1) __extension__ ({ \
- float64x2_t __ret; \
- uint64x2_t __s0 = __p0; \
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (float64x2_t) __builtin_neon_vcvtq_n_f64_v((int8x16_t)__rev0, __p1, 51); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vcgtzq_s16(int16x8_t __p0) {
+ uint16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vcgtzq_v((int8x16_t)__rev0, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcvtq_n_f64_s64(__p0, __p1) __extension__ ({ \
- float64x2_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (float64x2_t) __builtin_neon_vcvtq_n_f64_v((int8x16_t)__s0, __p1, 35); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vcgtz_s8(int8x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vcgtz_v((int8x8_t)__p0, 16);
+ return __ret;
+}
#else
-#define vcvtq_n_f64_s64(__p0, __p1) __extension__ ({ \
- float64x2_t __ret; \
- int64x2_t __s0 = __p0; \
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (float64x2_t) __builtin_neon_vcvtq_n_f64_v((int8x16_t)__rev0, __p1, 35); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vcgtz_s8(int8x8_t __p0) {
+ uint8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vcgtz_v((int8x8_t)__rev0, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vcvt_n_f64_u64(__p0, __p1) __extension__ ({ \
- float64x1_t __ret; \
- uint64x1_t __s0 = __p0; \
- __ret = (float64x1_t) __builtin_neon_vcvt_n_f64_v((int8x8_t)__s0, __p1, 19); \
- __ret; \
-})
-#define vcvt_n_f64_s64(__p0, __p1) __extension__ ({ \
- float64x1_t __ret; \
- int64x1_t __s0 = __p0; \
- __ret = (float64x1_t) __builtin_neon_vcvt_n_f64_v((int8x8_t)__s0, __p1, 3); \
- __ret; \
-})
-#define vcvtd_n_f64_u64(__p0, __p1) __extension__ ({ \
- float64_t __ret; \
- uint64_t __s0 = __p0; \
- __ret = (float64_t) __builtin_neon_vcvtd_n_f64_u64(__s0, __p1); \
- __ret; \
-})
-#define vcvtd_n_f64_s64(__p0, __p1) __extension__ ({ \
- float64_t __ret; \
- int64_t __s0 = __p0; \
- __ret = (float64_t) __builtin_neon_vcvtd_n_f64_s64(__s0, __p1); \
- __ret; \
-})
-#define vcvts_n_s32_f32(__p0, __p1) __extension__ ({ \
- int32_t __ret; \
- float32_t __s0 = __p0; \
- __ret = (int32_t) __builtin_neon_vcvts_n_s32_f32(__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x1_t vcgtz_f64(float64x1_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vcgtz_v((int8x8_t)__p0, 19);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vcvtq_n_s64_f64(__p0, __p1) __extension__ ({ \
- int64x2_t __ret; \
- float64x2_t __s0 = __p0; \
- __ret = (int64x2_t) __builtin_neon_vcvtq_n_s64_v((int8x16_t)__s0, __p1, 35); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcgtz_f32(float32x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vcgtz_v((int8x8_t)__p0, 18);
+ return __ret;
+}
#else
-#define vcvtq_n_s64_f64(__p0, __p1) __extension__ ({ \
- int64x2_t __ret; \
- float64x2_t __s0 = __p0; \
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int64x2_t) __builtin_neon_vcvtq_n_s64_v((int8x16_t)__rev0, __p1, 35); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcgtz_f32(float32x2_t __p0) {
+ uint32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vcgtz_v((int8x8_t)__rev0, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
-#define vcvt_n_s64_f64(__p0, __p1) __extension__ ({ \
- int64x1_t __ret; \
- float64x1_t __s0 = __p0; \
- __ret = (int64x1_t) __builtin_neon_vcvt_n_s64_v((int8x8_t)__s0, __p1, 3); \
- __ret; \
-})
-#define vcvtd_n_s64_f64(__p0, __p1) __extension__ ({ \
- int64_t __ret; \
- float64_t __s0 = __p0; \
- __ret = (int64_t) __builtin_neon_vcvtd_n_s64_f64(__s0, __p1); \
- __ret; \
-})
-#define vcvts_n_u32_f32(__p0, __p1) __extension__ ({ \
- uint32_t __ret; \
- float32_t __s0 = __p0; \
- __ret = (uint32_t) __builtin_neon_vcvts_n_u32_f32(__s0, __p1); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vcvtq_n_u64_f64(__p0, __p1) __extension__ ({ \
- uint64x2_t __ret; \
- float64x2_t __s0 = __p0; \
- __ret = (uint64x2_t) __builtin_neon_vcvtq_n_u64_v((int8x16_t)__s0, __p1, 51); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcgtz_s32(int32x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vcgtz_v((int8x8_t)__p0, 18);
+ return __ret;
+}
#else
-#define vcvtq_n_u64_f64(__p0, __p1) __extension__ ({ \
- uint64x2_t __ret; \
- float64x2_t __s0 = __p0; \
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint64x2_t) __builtin_neon_vcvtq_n_u64_v((int8x16_t)__rev0, __p1, 51); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#endif
-
-#define vcvt_n_u64_f64(__p0, __p1) __extension__ ({ \
- uint64x1_t __ret; \
- float64x1_t __s0 = __p0; \
- __ret = (uint64x1_t) __builtin_neon_vcvt_n_u64_v((int8x8_t)__s0, __p1, 19); \
- __ret; \
-})
-#define vcvtd_n_u64_f64(__p0, __p1) __extension__ ({ \
- uint64_t __ret; \
- float64_t __s0 = __p0; \
- __ret = (uint64_t) __builtin_neon_vcvtd_n_u64_f64(__s0, __p1); \
- __ret; \
-})
-__ai int32_t vcvts_s32_f32(float32_t __p0) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vcvts_s32_f32(__p0);
+__ai __attribute__((target("neon"))) uint32x2_t vcgtz_s32(int32x2_t __p0) {
+ uint32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vcgtz_v((int8x8_t)__rev0, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai int64_t vcvtd_s64_f64(float64_t __p0) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vcvtd_s64_f64(__p0);
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcgtz_s64(int64x1_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vcgtz_v((int8x8_t)__p0, 19);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vcvtq_s64_f64(float64x2_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vcvtq_s64_v((int8x16_t)__p0, 35);
+__ai __attribute__((target("neon"))) uint16x4_t vcgtz_s16(int16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vcgtz_v((int8x8_t)__p0, 17);
return __ret;
}
#else
-__ai int64x2_t vcvtq_s64_f64(float64x2_t __p0) {
- int64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vcvtq_s64_v((int8x16_t)__rev0, 35);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint16x4_t vcgtz_s16(int16x4_t __p0) {
+ uint16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vcgtz_v((int8x8_t)__rev0, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai int64x1_t vcvt_s64_f64(float64x1_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t) __builtin_neon_vcvt_s64_v((int8x8_t)__p0, 3);
+__ai __attribute__((target("neon"))) uint64_t vcgtzd_s64(int64_t __p0) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcgtzd_s64(__p0);
return __ret;
}
-__ai uint32_t vcvts_u32_f32(float32_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vcvts_u32_f32(__p0);
+__ai __attribute__((target("neon"))) uint64_t vcgtzd_f64(float64_t __p0) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcgtzd_f64(__p0);
return __ret;
}
-__ai uint64_t vcvtd_u64_f64(float64_t __p0) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcvtd_u64_f64(__p0);
+__ai __attribute__((target("neon"))) uint32_t vcgtzs_f32(float32_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vcgtzs_f32(__p0);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcvtq_u64_f64(float64x2_t __p0) {
+__ai __attribute__((target("neon"))) uint64x2_t vcleq_u64(uint64x2_t __p0, uint64x2_t __p1) {
uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vcvtq_u64_v((int8x16_t)__p0, 51);
+ __ret = (uint64x2_t)(__p0 <= __p1);
return __ret;
}
#else
-__ai uint64x2_t vcvtq_u64_f64(float64x2_t __p0) {
+__ai __attribute__((target("neon"))) uint64x2_t vcleq_u64(uint64x2_t __p0, uint64x2_t __p1) {
uint64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vcvtq_u64_v((int8x16_t)__rev0, 51);
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t)(__rev0 <= __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vcvt_u64_f64(float64x1_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vcvt_u64_v((int8x8_t)__p0, 19);
- return __ret;
-}
-__ai int32_t vcvtas_s32_f32(float32_t __p0) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vcvtas_s32_f32(__p0);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vcvtaq_s64_f64(float64x2_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vcvtaq_s64_v((int8x16_t)__p0, 35);
+__ai __attribute__((target("neon"))) uint64x2_t vcleq_f64(float64x2_t __p0, float64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0 <= __p1);
return __ret;
}
#else
-__ai int64x2_t vcvtaq_s64_f64(float64x2_t __p0) {
- int64x2_t __ret;
+__ai __attribute__((target("neon"))) uint64x2_t vcleq_f64(float64x2_t __p0, float64x2_t __p1) {
+ uint64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vcvtaq_s64_v((int8x16_t)__rev0, 35);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t)(__rev0 <= __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai int64x1_t vcvta_s64_f64(float64x1_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t) __builtin_neon_vcvta_s64_v((int8x8_t)__p0, 3);
- return __ret;
-}
-__ai int64_t vcvtad_s64_f64(float64_t __p0) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vcvtad_s64_f64(__p0);
- return __ret;
-}
-__ai uint32_t vcvtas_u32_f32(float32_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vcvtas_u32_f32(__p0);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcvtaq_u64_f64(float64x2_t __p0) {
+__ai __attribute__((target("neon"))) uint64x2_t vcleq_s64(int64x2_t __p0, int64x2_t __p1) {
uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vcvtaq_u64_v((int8x16_t)__p0, 51);
+ __ret = (uint64x2_t)(__p0 <= __p1);
return __ret;
}
#else
-__ai uint64x2_t vcvtaq_u64_f64(float64x2_t __p0) {
+__ai __attribute__((target("neon"))) uint64x2_t vcleq_s64(int64x2_t __p0, int64x2_t __p1) {
uint64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vcvtaq_u64_v((int8x16_t)__rev0, 51);
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t)(__rev0 <= __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vcvta_u64_f64(float64x1_t __p0) {
+__ai __attribute__((target("neon"))) uint64x1_t vcle_u64(uint64x1_t __p0, uint64x1_t __p1) {
uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vcvta_u64_v((int8x8_t)__p0, 19);
+ __ret = (uint64x1_t)(__p0 <= __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vcle_f64(float64x1_t __p0, float64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0 <= __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vcle_s64(int64x1_t __p0, int64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0 <= __p1);
return __ret;
}
-__ai uint64_t vcvtad_u64_f64(float64_t __p0) {
+__ai __attribute__((target("neon"))) uint64_t vcled_u64(uint64_t __p0, uint64_t __p1) {
uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcvtad_u64_f64(__p0);
+ __ret = (uint64_t) __builtin_neon_vcled_u64(__p0, __p1);
return __ret;
}
-__ai int32_t vcvtms_s32_f32(float32_t __p0) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vcvtms_s32_f32(__p0);
+__ai __attribute__((target("neon"))) uint64_t vcled_s64(int64_t __p0, int64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcled_s64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcled_f64(float64_t __p0, float64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcled_f64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcles_f32(float32_t __p0, float32_t __p1) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vcles_f32(__p0, __p1);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vcvtmq_s64_f64(float64x2_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vcvtmq_s64_v((int8x16_t)__p0, 35);
+__ai __attribute__((target("neon"))) uint8x16_t vclezq_s8(int8x16_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vclezq_v((int8x16_t)__p0, 48);
return __ret;
}
#else
-__ai int64x2_t vcvtmq_s64_f64(float64x2_t __p0) {
- int64x2_t __ret;
+__ai __attribute__((target("neon"))) uint8x16_t vclezq_s8(int8x16_t __p0) {
+ uint8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vclezq_v((int8x16_t)__rev0, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vclezq_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vclezq_v((int8x16_t)__p0, 51);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vclezq_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vcvtmq_s64_v((int8x16_t)__rev0, 35);
+ __ret = (uint64x2_t) __builtin_neon_vclezq_v((int8x16_t)__rev0, 51);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai int64x1_t vcvtm_s64_f64(float64x1_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t) __builtin_neon_vcvtm_s64_v((int8x8_t)__p0, 3);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vclezq_f32(float32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vclezq_v((int8x16_t)__p0, 50);
return __ret;
}
-__ai int64_t vcvtmd_s64_f64(float64_t __p0) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vcvtmd_s64_f64(__p0);
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vclezq_f32(float32x4_t __p0) {
+ uint32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vclezq_v((int8x16_t)__rev0, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai uint32_t vcvtms_u32_f32(float32_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vcvtms_u32_f32(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vclezq_s32(int32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vclezq_v((int8x16_t)__p0, 50);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vclezq_s32(int32x4_t __p0) {
+ uint32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vclezq_v((int8x16_t)__rev0, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+#endif
+
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcvtmq_u64_f64(float64x2_t __p0) {
+__ai __attribute__((target("neon"))) uint64x2_t vclezq_s64(int64x2_t __p0) {
uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vcvtmq_u64_v((int8x16_t)__p0, 51);
+ __ret = (uint64x2_t) __builtin_neon_vclezq_v((int8x16_t)__p0, 51);
return __ret;
}
#else
-__ai uint64x2_t vcvtmq_u64_f64(float64x2_t __p0) {
+__ai __attribute__((target("neon"))) uint64x2_t vclezq_s64(int64x2_t __p0) {
uint64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vcvtmq_u64_v((int8x16_t)__rev0, 51);
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vclezq_v((int8x16_t)__rev0, 51);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vcvtm_u64_f64(float64x1_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vcvtm_u64_v((int8x8_t)__p0, 19);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vclezq_s16(int16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vclezq_v((int8x16_t)__p0, 49);
return __ret;
}
-__ai uint64_t vcvtmd_u64_f64(float64_t __p0) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcvtmd_u64_f64(__p0);
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vclezq_s16(int16x8_t __p0) {
+ uint16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vclezq_v((int8x16_t)__rev0, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai int32_t vcvtns_s32_f32(float32_t __p0) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vcvtns_s32_f32(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vclez_s8(int8x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vclez_v((int8x8_t)__p0, 16);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vclez_s8(int8x8_t __p0) {
+ uint8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vclez_v((int8x8_t)__rev0, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vclez_f64(float64x1_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vclez_v((int8x8_t)__p0, 19);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vcvtnq_s64_f64(float64x2_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vcvtnq_s64_v((int8x16_t)__p0, 35);
+__ai __attribute__((target("neon"))) uint32x2_t vclez_f32(float32x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vclez_v((int8x8_t)__p0, 18);
return __ret;
}
#else
-__ai int64x2_t vcvtnq_s64_f64(float64x2_t __p0) {
- int64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vcvtnq_s64_v((int8x16_t)__rev0, 35);
+__ai __attribute__((target("neon"))) uint32x2_t vclez_f32(float32x2_t __p0) {
+ uint32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vclez_v((int8x8_t)__rev0, 18);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai int64x1_t vcvtn_s64_f64(float64x1_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t) __builtin_neon_vcvtn_s64_v((int8x8_t)__p0, 3);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vclez_s32(int32x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vclez_v((int8x8_t)__p0, 18);
return __ret;
}
-__ai int64_t vcvtnd_s64_f64(float64_t __p0) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vcvtnd_s64_f64(__p0);
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vclez_s32(int32x2_t __p0) {
+ uint32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vclez_v((int8x8_t)__rev0, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai uint32_t vcvtns_u32_f32(float32_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vcvtns_u32_f32(__p0);
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vclez_s64(int64x1_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vclez_v((int8x8_t)__p0, 19);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcvtnq_u64_f64(float64x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vcvtnq_u64_v((int8x16_t)__p0, 51);
+__ai __attribute__((target("neon"))) uint16x4_t vclez_s16(int16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vclez_v((int8x8_t)__p0, 17);
return __ret;
}
#else
-__ai uint64x2_t vcvtnq_u64_f64(float64x2_t __p0) {
- uint64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vcvtnq_u64_v((int8x16_t)__rev0, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint16x4_t vclez_s16(int16x4_t __p0) {
+ uint16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vclez_v((int8x8_t)__rev0, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vcvtn_u64_f64(float64x1_t __p0) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vcvtn_u64_v((int8x8_t)__p0, 19);
+__ai __attribute__((target("neon"))) uint64_t vclezd_s64(int64_t __p0) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vclezd_s64(__p0);
return __ret;
}
-__ai uint64_t vcvtnd_u64_f64(float64_t __p0) {
+__ai __attribute__((target("neon"))) uint64_t vclezd_f64(float64_t __p0) {
uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcvtnd_u64_f64(__p0);
+ __ret = (uint64_t) __builtin_neon_vclezd_f64(__p0);
return __ret;
}
-__ai int32_t vcvtps_s32_f32(float32_t __p0) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vcvtps_s32_f32(__p0);
+__ai __attribute__((target("neon"))) uint32_t vclezs_f32(float32_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vclezs_f32(__p0);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vcvtpq_s64_f64(float64x2_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vcvtpq_s64_v((int8x16_t)__p0, 35);
+__ai __attribute__((target("neon"))) uint64x2_t vcltq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0 < __p1);
return __ret;
}
#else
-__ai int64x2_t vcvtpq_s64_f64(float64x2_t __p0) {
- int64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vcvtpq_s64_v((int8x16_t)__rev0, 35);
+__ai __attribute__((target("neon"))) uint64x2_t vcltq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t)(__rev0 < __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai int64x1_t vcvtp_s64_f64(float64x1_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t) __builtin_neon_vcvtp_s64_v((int8x8_t)__p0, 3);
- return __ret;
-}
-__ai int64_t vcvtpd_s64_f64(float64_t __p0) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vcvtpd_s64_f64(__p0);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcltq_f64(float64x2_t __p0, float64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0 < __p1);
return __ret;
}
-__ai uint32_t vcvtps_u32_f32(float32_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vcvtps_u32_f32(__p0);
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcltq_f64(float64x2_t __p0, float64x2_t __p1) {
+ uint64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t)(__rev0 < __rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
+#endif
+
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vcvtpq_u64_f64(float64x2_t __p0) {
+__ai __attribute__((target("neon"))) uint64x2_t vcltq_s64(int64x2_t __p0, int64x2_t __p1) {
uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vcvtpq_u64_v((int8x16_t)__p0, 51);
+ __ret = (uint64x2_t)(__p0 < __p1);
return __ret;
}
#else
-__ai uint64x2_t vcvtpq_u64_f64(float64x2_t __p0) {
+__ai __attribute__((target("neon"))) uint64x2_t vcltq_s64(int64x2_t __p0, int64x2_t __p1) {
uint64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vcvtpq_u64_v((int8x16_t)__rev0, 51);
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t)(__rev0 < __rev1);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai uint64x1_t vcvtp_u64_f64(float64x1_t __p0) {
+__ai __attribute__((target("neon"))) uint64x1_t vclt_u64(uint64x1_t __p0, uint64x1_t __p1) {
uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vcvtp_u64_v((int8x8_t)__p0, 19);
+ __ret = (uint64x1_t)(__p0 < __p1);
return __ret;
}
-__ai uint64_t vcvtpd_u64_f64(float64_t __p0) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vcvtpd_u64_f64(__p0);
+__ai __attribute__((target("neon"))) uint64x1_t vclt_f64(float64x1_t __p0, float64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0 < __p1);
return __ret;
}
-__ai float32_t vcvtxd_f32_f64(float64_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vcvtxd_f32_f64(__p0);
+__ai __attribute__((target("neon"))) uint64x1_t vclt_s64(int64x1_t __p0, int64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t)(__p0 < __p1);
return __ret;
}
-#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vcvtx_f32_f64(float64x2_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vcvtx_f32_v((int8x16_t)__p0, 42);
+__ai __attribute__((target("neon"))) uint64_t vcltd_u64(uint64_t __p0, uint64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcltd_u64(__p0, __p1);
return __ret;
}
-#else
-__ai float32x2_t vcvtx_f32_f64(float64x2_t __p0) {
- float32x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vcvtx_f32_v((int8x16_t)__rev0, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint64_t vcltd_s64(int64_t __p0, int64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcltd_s64(__p0, __p1);
return __ret;
}
-__ai float32x2_t __noswap_vcvtx_f32_f64(float64x2_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vcvtx_f32_v((int8x16_t)__p0, 42);
+__ai __attribute__((target("neon"))) uint64_t vcltd_f64(float64_t __p0, float64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcltd_f64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vclts_f32(float32_t __p0, float32_t __p1) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vclts_f32(__p0, __p1);
return __ret;
}
-#endif
-
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vcvtx_high_f32_f64(float32x2_t __p0, float64x2_t __p1) {
- float32x4_t __ret;
- __ret = vcombine_f32(__p0, vcvtx_f32_f64(__p1));
+__ai __attribute__((target("neon"))) uint8x16_t vcltzq_s8(int8x16_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vcltzq_v((int8x16_t)__p0, 48);
return __ret;
}
#else
-__ai float32x4_t vcvtx_high_f32_f64(float32x2_t __p0, float64x2_t __p1) {
- float32x4_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __noswap_vcombine_f32(__rev0, __noswap_vcvtx_f32_f64(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vcltzq_s8(int8x16_t __p0) {
+ uint8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vcltzq_v((int8x16_t)__rev0, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vdivq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = __p0 / __p1;
+__ai __attribute__((target("neon"))) uint64x2_t vcltzq_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vcltzq_v((int8x16_t)__p0, 51);
return __ret;
}
#else
-__ai float64x2_t vdivq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
+__ai __attribute__((target("neon"))) uint64x2_t vcltzq_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 / __rev1;
+ __ret = (uint64x2_t) __builtin_neon_vcltzq_v((int8x16_t)__rev0, 51);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vdivq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = __p0 / __p1;
+__ai __attribute__((target("neon"))) uint32x4_t vcltzq_f32(float32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vcltzq_v((int8x16_t)__p0, 50);
return __ret;
}
#else
-__ai float32x4_t vdivq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
+__ai __attribute__((target("neon"))) uint32x4_t vcltzq_f32(float32x4_t __p0) {
+ uint32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 / __rev1;
+ __ret = (uint32x4_t) __builtin_neon_vcltzq_v((int8x16_t)__rev0, 50);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai float64x1_t vdiv_f64(float64x1_t __p0, float64x1_t __p1) {
- float64x1_t __ret;
- __ret = __p0 / __p1;
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vdiv_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = __p0 / __p1;
+__ai __attribute__((target("neon"))) uint32x4_t vcltzq_s32(int32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vcltzq_v((int8x16_t)__p0, 50);
return __ret;
}
#else
-__ai float32x2_t vdiv_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 / __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint32x4_t vcltzq_s32(int32x4_t __p0) {
+ uint32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vcltzq_v((int8x16_t)__rev0, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupb_lane_p8(__p0, __p1) __extension__ ({ \
- poly8_t __ret; \
- poly8x8_t __s0 = __p0; \
- __ret = (poly8_t) __builtin_neon_vdupb_lane_i8((poly8x8_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcltzq_s64(int64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vcltzq_v((int8x16_t)__p0, 51);
+ return __ret;
+}
#else
-#define vdupb_lane_p8(__p0, __p1) __extension__ ({ \
- poly8_t __ret; \
- poly8x8_t __s0 = __p0; \
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly8_t) __builtin_neon_vdupb_lane_i8((poly8x8_t)__rev0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcltzq_s64(int64x2_t __p0) {
+ uint64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vcltzq_v((int8x16_t)__rev0, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vduph_lane_p16(__p0, __p1) __extension__ ({ \
- poly16_t __ret; \
- poly16x4_t __s0 = __p0; \
- __ret = (poly16_t) __builtin_neon_vduph_lane_i16((poly16x4_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vcltzq_s16(int16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vcltzq_v((int8x16_t)__p0, 49);
+ return __ret;
+}
#else
-#define vduph_lane_p16(__p0, __p1) __extension__ ({ \
- poly16_t __ret; \
- poly16x4_t __s0 = __p0; \
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (poly16_t) __builtin_neon_vduph_lane_i16((poly16x4_t)__rev0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vcltzq_s16(int16x8_t __p0) {
+ uint16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vcltzq_v((int8x16_t)__rev0, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupb_lane_u8(__p0, __p1) __extension__ ({ \
- uint8_t __ret; \
- uint8x8_t __s0 = __p0; \
- __ret = (uint8_t) __builtin_neon_vdupb_lane_i8((int8x8_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vcltz_s8(int8x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vcltz_v((int8x8_t)__p0, 16);
+ return __ret;
+}
#else
-#define vdupb_lane_u8(__p0, __p1) __extension__ ({ \
- uint8_t __ret; \
- uint8x8_t __s0 = __p0; \
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8_t) __builtin_neon_vdupb_lane_i8((int8x8_t)__rev0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x8_t vcltz_s8(int8x8_t __p0) {
+ uint8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vcltz_v((int8x8_t)__rev0, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vcltz_f64(float64x1_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vcltz_v((int8x8_t)__p0, 19);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vdups_lane_u32(__p0, __p1) __extension__ ({ \
- uint32_t __ret; \
- uint32x2_t __s0 = __p0; \
- __ret = (uint32_t) __builtin_neon_vdups_lane_i32((int32x2_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcltz_f32(float32x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vcltz_v((int8x8_t)__p0, 18);
+ return __ret;
+}
#else
-#define vdups_lane_u32(__p0, __p1) __extension__ ({ \
- uint32_t __ret; \
- uint32x2_t __s0 = __p0; \
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint32_t) __builtin_neon_vdups_lane_i32((int32x2_t)__rev0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcltz_f32(float32x2_t __p0) {
+ uint32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vcltz_v((int8x8_t)__rev0, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
-#define vdupd_lane_u64(__p0, __p1) __extension__ ({ \
- uint64_t __ret; \
- uint64x1_t __s0 = __p0; \
- __ret = (uint64_t) __builtin_neon_vdupd_lane_i64((int64x1_t)__s0, __p1); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vduph_lane_u16(__p0, __p1) __extension__ ({ \
- uint16_t __ret; \
- uint16x4_t __s0 = __p0; \
- __ret = (uint16_t) __builtin_neon_vduph_lane_i16((int16x4_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcltz_s32(int32x2_t __p0) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vcltz_v((int8x8_t)__p0, 18);
+ return __ret;
+}
#else
-#define vduph_lane_u16(__p0, __p1) __extension__ ({ \
- uint16_t __ret; \
- uint16x4_t __s0 = __p0; \
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint16_t) __builtin_neon_vduph_lane_i16((int16x4_t)__rev0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vcltz_s32(int32x2_t __p0) {
+ uint32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vcltz_v((int8x8_t)__rev0, 18);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vcltz_s64(int64x1_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vcltz_v((int8x8_t)__p0, 19);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vdupb_lane_s8(__p0, __p1) __extension__ ({ \
- int8_t __ret; \
- int8x8_t __s0 = __p0; \
- __ret = (int8_t) __builtin_neon_vdupb_lane_i8((int8x8_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vcltz_s16(int16x4_t __p0) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vcltz_v((int8x8_t)__p0, 17);
+ return __ret;
+}
#else
-#define vdupb_lane_s8(__p0, __p1) __extension__ ({ \
- int8_t __ret; \
- int8x8_t __s0 = __p0; \
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8_t) __builtin_neon_vdupb_lane_i8((int8x8_t)__rev0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vcltz_s16(int16x4_t __p0) {
+ uint16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vcltz_v((int8x8_t)__rev0, 17);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vdupd_lane_f64(__p0, __p1) __extension__ ({ \
- float64_t __ret; \
- float64x1_t __s0 = __p0; \
- __ret = (float64_t) __builtin_neon_vdupd_lane_f64((float64x1_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64_t vcltzd_s64(int64_t __p0) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcltzd_s64(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcltzd_f64(float64_t __p0) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcltzd_f64(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcltzs_f32(float32_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vcltzs_f32(__p0);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vdups_lane_f32(__p0, __p1) __extension__ ({ \
- float32_t __ret; \
- float32x2_t __s0 = __p0; \
- __ret = (float32_t) __builtin_neon_vdups_lane_f32((float32x2_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly64x2_t vcombine_p64(poly64x1_t __p0, poly64x1_t __p1) {
+ poly64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+ return __ret;
+}
#else
-#define vdups_lane_f32(__p0, __p1) __extension__ ({ \
- float32_t __ret; \
- float32x2_t __s0 = __p0; \
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (float32_t) __builtin_neon_vdups_lane_f32((float32x2_t)__rev0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly64x2_t vcombine_p64(poly64x1_t __p0, poly64x1_t __p1) {
+ poly64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdups_lane_s32(__p0, __p1) __extension__ ({ \
- int32_t __ret; \
- int32x2_t __s0 = __p0; \
- __ret = (int32_t) __builtin_neon_vdups_lane_i32((int32x2_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vcombine_f64(float64x1_t __p0, float64x1_t __p1) {
+ float64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+ return __ret;
+}
#else
-#define vdups_lane_s32(__p0, __p1) __extension__ ({ \
- int32_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int32_t) __builtin_neon_vdups_lane_i32((int32x2_t)__rev0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vcombine_f64(float64x1_t __p0, float64x1_t __p1) {
+ float64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
-#define vdupd_lane_s64(__p0, __p1) __extension__ ({ \
- int64_t __ret; \
- int64x1_t __s0 = __p0; \
- __ret = (int64_t) __builtin_neon_vdupd_lane_i64((int64x1_t)__s0, __p1); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vduph_lane_s16(__p0, __p1) __extension__ ({ \
- int16_t __ret; \
- int16x4_t __s0 = __p0; \
- __ret = (int16_t) __builtin_neon_vduph_lane_i16((int16x4_t)__s0, __p1); \
- __ret; \
+#define vcopyq_lane_p8(__p0_278, __p1_278, __p2_278, __p3_278) __extension__ ({ \
+ poly8x16_t __ret_278; \
+ poly8x16_t __s0_278 = __p0_278; \
+ poly8x8_t __s2_278 = __p2_278; \
+ __ret_278 = vsetq_lane_p8(vget_lane_p8(__s2_278, __p3_278), __s0_278, __p1_278); \
+ __ret_278; \
})
#else
-#define vduph_lane_s16(__p0, __p1) __extension__ ({ \
- int16_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int16_t) __builtin_neon_vduph_lane_i16((int16x4_t)__rev0, __p1); \
- __ret; \
+#define vcopyq_lane_p8(__p0_279, __p1_279, __p2_279, __p3_279) __extension__ ({ \
+ poly8x16_t __ret_279; \
+ poly8x16_t __s0_279 = __p0_279; \
+ poly8x8_t __s2_279 = __p2_279; \
+ poly8x16_t __rev0_279; __rev0_279 = __builtin_shufflevector(__s0_279, __s0_279, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ poly8x8_t __rev2_279; __rev2_279 = __builtin_shufflevector(__s2_279, __s2_279, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_279 = __noswap_vsetq_lane_p8(__noswap_vget_lane_p8(__rev2_279, __p3_279), __rev0_279, __p1_279); \
+ __ret_279 = __builtin_shufflevector(__ret_279, __ret_279, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_279; \
})
#endif
-#define vdup_lane_p64(__p0_343, __p1_343) __extension__ ({ \
- poly64x1_t __ret_343; \
- poly64x1_t __s0_343 = __p0_343; \
- __ret_343 = splat_lane_p64(__s0_343, __p1_343); \
- __ret_343; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vdupq_lane_p64(__p0_344, __p1_344) __extension__ ({ \
- poly64x2_t __ret_344; \
- poly64x1_t __s0_344 = __p0_344; \
- __ret_344 = splatq_lane_p64(__s0_344, __p1_344); \
- __ret_344; \
+#define vcopyq_lane_p16(__p0_280, __p1_280, __p2_280, __p3_280) __extension__ ({ \
+ poly16x8_t __ret_280; \
+ poly16x8_t __s0_280 = __p0_280; \
+ poly16x4_t __s2_280 = __p2_280; \
+ __ret_280 = vsetq_lane_p16(vget_lane_p16(__s2_280, __p3_280), __s0_280, __p1_280); \
+ __ret_280; \
})
#else
-#define vdupq_lane_p64(__p0_345, __p1_345) __extension__ ({ \
- poly64x2_t __ret_345; \
- poly64x1_t __s0_345 = __p0_345; \
- __ret_345 = __noswap_splatq_lane_p64(__s0_345, __p1_345); \
- __ret_345 = __builtin_shufflevector(__ret_345, __ret_345, 1, 0); \
- __ret_345; \
+#define vcopyq_lane_p16(__p0_281, __p1_281, __p2_281, __p3_281) __extension__ ({ \
+ poly16x8_t __ret_281; \
+ poly16x8_t __s0_281 = __p0_281; \
+ poly16x4_t __s2_281 = __p2_281; \
+ poly16x8_t __rev0_281; __rev0_281 = __builtin_shufflevector(__s0_281, __s0_281, 7, 6, 5, 4, 3, 2, 1, 0); \
+ poly16x4_t __rev2_281; __rev2_281 = __builtin_shufflevector(__s2_281, __s2_281, 3, 2, 1, 0); \
+ __ret_281 = __noswap_vsetq_lane_p16(__noswap_vget_lane_p16(__rev2_281, __p3_281), __rev0_281, __p1_281); \
+ __ret_281 = __builtin_shufflevector(__ret_281, __ret_281, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_281; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupq_lane_f64(__p0_346, __p1_346) __extension__ ({ \
- float64x2_t __ret_346; \
- float64x1_t __s0_346 = __p0_346; \
- __ret_346 = splatq_lane_f64(__s0_346, __p1_346); \
- __ret_346; \
+#define vcopyq_lane_u8(__p0_282, __p1_282, __p2_282, __p3_282) __extension__ ({ \
+ uint8x16_t __ret_282; \
+ uint8x16_t __s0_282 = __p0_282; \
+ uint8x8_t __s2_282 = __p2_282; \
+ __ret_282 = vsetq_lane_u8(vget_lane_u8(__s2_282, __p3_282), __s0_282, __p1_282); \
+ __ret_282; \
})
#else
-#define vdupq_lane_f64(__p0_347, __p1_347) __extension__ ({ \
- float64x2_t __ret_347; \
- float64x1_t __s0_347 = __p0_347; \
- __ret_347 = __noswap_splatq_lane_f64(__s0_347, __p1_347); \
- __ret_347 = __builtin_shufflevector(__ret_347, __ret_347, 1, 0); \
- __ret_347; \
+#define vcopyq_lane_u8(__p0_283, __p1_283, __p2_283, __p3_283) __extension__ ({ \
+ uint8x16_t __ret_283; \
+ uint8x16_t __s0_283 = __p0_283; \
+ uint8x8_t __s2_283 = __p2_283; \
+ uint8x16_t __rev0_283; __rev0_283 = __builtin_shufflevector(__s0_283, __s0_283, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x8_t __rev2_283; __rev2_283 = __builtin_shufflevector(__s2_283, __s2_283, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_283 = __noswap_vsetq_lane_u8(__noswap_vget_lane_u8(__rev2_283, __p3_283), __rev0_283, __p1_283); \
+ __ret_283 = __builtin_shufflevector(__ret_283, __ret_283, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_283; \
})
#endif
-#define vdup_lane_f64(__p0_348, __p1_348) __extension__ ({ \
- float64x1_t __ret_348; \
- float64x1_t __s0_348 = __p0_348; \
- __ret_348 = splat_lane_f64(__s0_348, __p1_348); \
- __ret_348; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vdupb_laneq_p8(__p0, __p1) __extension__ ({ \
- poly8_t __ret; \
- poly8x16_t __s0 = __p0; \
- __ret = (poly8_t) __builtin_neon_vdupb_laneq_i8((poly8x16_t)__s0, __p1); \
- __ret; \
+#define vcopyq_lane_u32(__p0_284, __p1_284, __p2_284, __p3_284) __extension__ ({ \
+ uint32x4_t __ret_284; \
+ uint32x4_t __s0_284 = __p0_284; \
+ uint32x2_t __s2_284 = __p2_284; \
+ __ret_284 = vsetq_lane_u32(vget_lane_u32(__s2_284, __p3_284), __s0_284, __p1_284); \
+ __ret_284; \
})
#else
-#define vdupb_laneq_p8(__p0, __p1) __extension__ ({ \
- poly8_t __ret; \
- poly8x16_t __s0 = __p0; \
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly8_t) __builtin_neon_vdupb_laneq_i8((poly8x16_t)__rev0, __p1); \
- __ret; \
+#define vcopyq_lane_u32(__p0_285, __p1_285, __p2_285, __p3_285) __extension__ ({ \
+ uint32x4_t __ret_285; \
+ uint32x4_t __s0_285 = __p0_285; \
+ uint32x2_t __s2_285 = __p2_285; \
+ uint32x4_t __rev0_285; __rev0_285 = __builtin_shufflevector(__s0_285, __s0_285, 3, 2, 1, 0); \
+ uint32x2_t __rev2_285; __rev2_285 = __builtin_shufflevector(__s2_285, __s2_285, 1, 0); \
+ __ret_285 = __noswap_vsetq_lane_u32(__noswap_vget_lane_u32(__rev2_285, __p3_285), __rev0_285, __p1_285); \
+ __ret_285 = __builtin_shufflevector(__ret_285, __ret_285, 3, 2, 1, 0); \
+ __ret_285; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vduph_laneq_p16(__p0, __p1) __extension__ ({ \
- poly16_t __ret; \
- poly16x8_t __s0 = __p0; \
- __ret = (poly16_t) __builtin_neon_vduph_laneq_i16((poly16x8_t)__s0, __p1); \
- __ret; \
+#define vcopyq_lane_u64(__p0_286, __p1_286, __p2_286, __p3_286) __extension__ ({ \
+ uint64x2_t __ret_286; \
+ uint64x2_t __s0_286 = __p0_286; \
+ uint64x1_t __s2_286 = __p2_286; \
+ __ret_286 = vsetq_lane_u64(vget_lane_u64(__s2_286, __p3_286), __s0_286, __p1_286); \
+ __ret_286; \
})
#else
-#define vduph_laneq_p16(__p0, __p1) __extension__ ({ \
- poly16_t __ret; \
- poly16x8_t __s0 = __p0; \
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (poly16_t) __builtin_neon_vduph_laneq_i16((poly16x8_t)__rev0, __p1); \
- __ret; \
+#define vcopyq_lane_u64(__p0_287, __p1_287, __p2_287, __p3_287) __extension__ ({ \
+ uint64x2_t __ret_287; \
+ uint64x2_t __s0_287 = __p0_287; \
+ uint64x1_t __s2_287 = __p2_287; \
+ uint64x2_t __rev0_287; __rev0_287 = __builtin_shufflevector(__s0_287, __s0_287, 1, 0); \
+ __ret_287 = __noswap_vsetq_lane_u64(vget_lane_u64(__s2_287, __p3_287), __rev0_287, __p1_287); \
+ __ret_287 = __builtin_shufflevector(__ret_287, __ret_287, 1, 0); \
+ __ret_287; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupb_laneq_u8(__p0, __p1) __extension__ ({ \
- uint8_t __ret; \
- uint8x16_t __s0 = __p0; \
- __ret = (uint8_t) __builtin_neon_vdupb_laneq_i8((int8x16_t)__s0, __p1); \
- __ret; \
+#define vcopyq_lane_u16(__p0_288, __p1_288, __p2_288, __p3_288) __extension__ ({ \
+ uint16x8_t __ret_288; \
+ uint16x8_t __s0_288 = __p0_288; \
+ uint16x4_t __s2_288 = __p2_288; \
+ __ret_288 = vsetq_lane_u16(vget_lane_u16(__s2_288, __p3_288), __s0_288, __p1_288); \
+ __ret_288; \
})
#else
-#define vdupb_laneq_u8(__p0, __p1) __extension__ ({ \
- uint8_t __ret; \
- uint8x16_t __s0 = __p0; \
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint8_t) __builtin_neon_vdupb_laneq_i8((int8x16_t)__rev0, __p1); \
- __ret; \
+#define vcopyq_lane_u16(__p0_289, __p1_289, __p2_289, __p3_289) __extension__ ({ \
+ uint16x8_t __ret_289; \
+ uint16x8_t __s0_289 = __p0_289; \
+ uint16x4_t __s2_289 = __p2_289; \
+ uint16x8_t __rev0_289; __rev0_289 = __builtin_shufflevector(__s0_289, __s0_289, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x4_t __rev2_289; __rev2_289 = __builtin_shufflevector(__s2_289, __s2_289, 3, 2, 1, 0); \
+ __ret_289 = __noswap_vsetq_lane_u16(__noswap_vget_lane_u16(__rev2_289, __p3_289), __rev0_289, __p1_289); \
+ __ret_289 = __builtin_shufflevector(__ret_289, __ret_289, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_289; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdups_laneq_u32(__p0, __p1) __extension__ ({ \
- uint32_t __ret; \
- uint32x4_t __s0 = __p0; \
- __ret = (uint32_t) __builtin_neon_vdups_laneq_i32((int32x4_t)__s0, __p1); \
- __ret; \
+#define vcopyq_lane_s8(__p0_290, __p1_290, __p2_290, __p3_290) __extension__ ({ \
+ int8x16_t __ret_290; \
+ int8x16_t __s0_290 = __p0_290; \
+ int8x8_t __s2_290 = __p2_290; \
+ __ret_290 = vsetq_lane_s8(vget_lane_s8(__s2_290, __p3_290), __s0_290, __p1_290); \
+ __ret_290; \
})
#else
-#define vdups_laneq_u32(__p0, __p1) __extension__ ({ \
- uint32_t __ret; \
- uint32x4_t __s0 = __p0; \
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (uint32_t) __builtin_neon_vdups_laneq_i32((int32x4_t)__rev0, __p1); \
- __ret; \
+#define vcopyq_lane_s8(__p0_291, __p1_291, __p2_291, __p3_291) __extension__ ({ \
+ int8x16_t __ret_291; \
+ int8x16_t __s0_291 = __p0_291; \
+ int8x8_t __s2_291 = __p2_291; \
+ int8x16_t __rev0_291; __rev0_291 = __builtin_shufflevector(__s0_291, __s0_291, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x8_t __rev2_291; __rev2_291 = __builtin_shufflevector(__s2_291, __s2_291, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_291 = __noswap_vsetq_lane_s8(__noswap_vget_lane_s8(__rev2_291, __p3_291), __rev0_291, __p1_291); \
+ __ret_291 = __builtin_shufflevector(__ret_291, __ret_291, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_291; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupd_laneq_u64(__p0, __p1) __extension__ ({ \
- uint64_t __ret; \
- uint64x2_t __s0 = __p0; \
- __ret = (uint64_t) __builtin_neon_vdupd_laneq_i64((int64x2_t)__s0, __p1); \
- __ret; \
+#define vcopyq_lane_f32(__p0_292, __p1_292, __p2_292, __p3_292) __extension__ ({ \
+ float32x4_t __ret_292; \
+ float32x4_t __s0_292 = __p0_292; \
+ float32x2_t __s2_292 = __p2_292; \
+ __ret_292 = vsetq_lane_f32(vget_lane_f32(__s2_292, __p3_292), __s0_292, __p1_292); \
+ __ret_292; \
})
#else
-#define vdupd_laneq_u64(__p0, __p1) __extension__ ({ \
- uint64_t __ret; \
- uint64x2_t __s0 = __p0; \
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (uint64_t) __builtin_neon_vdupd_laneq_i64((int64x2_t)__rev0, __p1); \
- __ret; \
+#define vcopyq_lane_f32(__p0_293, __p1_293, __p2_293, __p3_293) __extension__ ({ \
+ float32x4_t __ret_293; \
+ float32x4_t __s0_293 = __p0_293; \
+ float32x2_t __s2_293 = __p2_293; \
+ float32x4_t __rev0_293; __rev0_293 = __builtin_shufflevector(__s0_293, __s0_293, 3, 2, 1, 0); \
+ float32x2_t __rev2_293; __rev2_293 = __builtin_shufflevector(__s2_293, __s2_293, 1, 0); \
+ __ret_293 = __noswap_vsetq_lane_f32(__noswap_vget_lane_f32(__rev2_293, __p3_293), __rev0_293, __p1_293); \
+ __ret_293 = __builtin_shufflevector(__ret_293, __ret_293, 3, 2, 1, 0); \
+ __ret_293; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vduph_laneq_u16(__p0, __p1) __extension__ ({ \
- uint16_t __ret; \
- uint16x8_t __s0 = __p0; \
- __ret = (uint16_t) __builtin_neon_vduph_laneq_i16((int16x8_t)__s0, __p1); \
- __ret; \
+#define vcopyq_lane_s32(__p0_294, __p1_294, __p2_294, __p3_294) __extension__ ({ \
+ int32x4_t __ret_294; \
+ int32x4_t __s0_294 = __p0_294; \
+ int32x2_t __s2_294 = __p2_294; \
+ __ret_294 = vsetq_lane_s32(vget_lane_s32(__s2_294, __p3_294), __s0_294, __p1_294); \
+ __ret_294; \
})
#else
-#define vduph_laneq_u16(__p0, __p1) __extension__ ({ \
- uint16_t __ret; \
- uint16x8_t __s0 = __p0; \
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (uint16_t) __builtin_neon_vduph_laneq_i16((int16x8_t)__rev0, __p1); \
- __ret; \
+#define vcopyq_lane_s32(__p0_295, __p1_295, __p2_295, __p3_295) __extension__ ({ \
+ int32x4_t __ret_295; \
+ int32x4_t __s0_295 = __p0_295; \
+ int32x2_t __s2_295 = __p2_295; \
+ int32x4_t __rev0_295; __rev0_295 = __builtin_shufflevector(__s0_295, __s0_295, 3, 2, 1, 0); \
+ int32x2_t __rev2_295; __rev2_295 = __builtin_shufflevector(__s2_295, __s2_295, 1, 0); \
+ __ret_295 = __noswap_vsetq_lane_s32(__noswap_vget_lane_s32(__rev2_295, __p3_295), __rev0_295, __p1_295); \
+ __ret_295 = __builtin_shufflevector(__ret_295, __ret_295, 3, 2, 1, 0); \
+ __ret_295; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupb_laneq_s8(__p0, __p1) __extension__ ({ \
- int8_t __ret; \
- int8x16_t __s0 = __p0; \
- __ret = (int8_t) __builtin_neon_vdupb_laneq_i8((int8x16_t)__s0, __p1); \
- __ret; \
+#define vcopyq_lane_s64(__p0_296, __p1_296, __p2_296, __p3_296) __extension__ ({ \
+ int64x2_t __ret_296; \
+ int64x2_t __s0_296 = __p0_296; \
+ int64x1_t __s2_296 = __p2_296; \
+ __ret_296 = vsetq_lane_s64(vget_lane_s64(__s2_296, __p3_296), __s0_296, __p1_296); \
+ __ret_296; \
})
#else
-#define vdupb_laneq_s8(__p0, __p1) __extension__ ({ \
- int8_t __ret; \
- int8x16_t __s0 = __p0; \
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int8_t) __builtin_neon_vdupb_laneq_i8((int8x16_t)__rev0, __p1); \
- __ret; \
+#define vcopyq_lane_s64(__p0_297, __p1_297, __p2_297, __p3_297) __extension__ ({ \
+ int64x2_t __ret_297; \
+ int64x2_t __s0_297 = __p0_297; \
+ int64x1_t __s2_297 = __p2_297; \
+ int64x2_t __rev0_297; __rev0_297 = __builtin_shufflevector(__s0_297, __s0_297, 1, 0); \
+ __ret_297 = __noswap_vsetq_lane_s64(vget_lane_s64(__s2_297, __p3_297), __rev0_297, __p1_297); \
+ __ret_297 = __builtin_shufflevector(__ret_297, __ret_297, 1, 0); \
+ __ret_297; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupd_laneq_f64(__p0, __p1) __extension__ ({ \
- float64_t __ret; \
- float64x2_t __s0 = __p0; \
- __ret = (float64_t) __builtin_neon_vdupd_laneq_f64((float64x2_t)__s0, __p1); \
- __ret; \
+#define vcopyq_lane_s16(__p0_298, __p1_298, __p2_298, __p3_298) __extension__ ({ \
+ int16x8_t __ret_298; \
+ int16x8_t __s0_298 = __p0_298; \
+ int16x4_t __s2_298 = __p2_298; \
+ __ret_298 = vsetq_lane_s16(vget_lane_s16(__s2_298, __p3_298), __s0_298, __p1_298); \
+ __ret_298; \
})
#else
-#define vdupd_laneq_f64(__p0, __p1) __extension__ ({ \
- float64_t __ret; \
- float64x2_t __s0 = __p0; \
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (float64_t) __builtin_neon_vdupd_laneq_f64((float64x2_t)__rev0, __p1); \
- __ret; \
+#define vcopyq_lane_s16(__p0_299, __p1_299, __p2_299, __p3_299) __extension__ ({ \
+ int16x8_t __ret_299; \
+ int16x8_t __s0_299 = __p0_299; \
+ int16x4_t __s2_299 = __p2_299; \
+ int16x8_t __rev0_299; __rev0_299 = __builtin_shufflevector(__s0_299, __s0_299, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x4_t __rev2_299; __rev2_299 = __builtin_shufflevector(__s2_299, __s2_299, 3, 2, 1, 0); \
+ __ret_299 = __noswap_vsetq_lane_s16(__noswap_vget_lane_s16(__rev2_299, __p3_299), __rev0_299, __p1_299); \
+ __ret_299 = __builtin_shufflevector(__ret_299, __ret_299, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_299; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdups_laneq_f32(__p0, __p1) __extension__ ({ \
- float32_t __ret; \
- float32x4_t __s0 = __p0; \
- __ret = (float32_t) __builtin_neon_vdups_laneq_f32((float32x4_t)__s0, __p1); \
- __ret; \
+#define vcopy_lane_p8(__p0_300, __p1_300, __p2_300, __p3_300) __extension__ ({ \
+ poly8x8_t __ret_300; \
+ poly8x8_t __s0_300 = __p0_300; \
+ poly8x8_t __s2_300 = __p2_300; \
+ __ret_300 = vset_lane_p8(vget_lane_p8(__s2_300, __p3_300), __s0_300, __p1_300); \
+ __ret_300; \
})
#else
-#define vdups_laneq_f32(__p0, __p1) __extension__ ({ \
- float32_t __ret; \
- float32x4_t __s0 = __p0; \
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (float32_t) __builtin_neon_vdups_laneq_f32((float32x4_t)__rev0, __p1); \
- __ret; \
+#define vcopy_lane_p8(__p0_301, __p1_301, __p2_301, __p3_301) __extension__ ({ \
+ poly8x8_t __ret_301; \
+ poly8x8_t __s0_301 = __p0_301; \
+ poly8x8_t __s2_301 = __p2_301; \
+ poly8x8_t __rev0_301; __rev0_301 = __builtin_shufflevector(__s0_301, __s0_301, 7, 6, 5, 4, 3, 2, 1, 0); \
+ poly8x8_t __rev2_301; __rev2_301 = __builtin_shufflevector(__s2_301, __s2_301, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_301 = __noswap_vset_lane_p8(__noswap_vget_lane_p8(__rev2_301, __p3_301), __rev0_301, __p1_301); \
+ __ret_301 = __builtin_shufflevector(__ret_301, __ret_301, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_301; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdups_laneq_s32(__p0, __p1) __extension__ ({ \
- int32_t __ret; \
- int32x4_t __s0 = __p0; \
- __ret = (int32_t) __builtin_neon_vdups_laneq_i32((int32x4_t)__s0, __p1); \
- __ret; \
+#define vcopy_lane_p16(__p0_302, __p1_302, __p2_302, __p3_302) __extension__ ({ \
+ poly16x4_t __ret_302; \
+ poly16x4_t __s0_302 = __p0_302; \
+ poly16x4_t __s2_302 = __p2_302; \
+ __ret_302 = vset_lane_p16(vget_lane_p16(__s2_302, __p3_302), __s0_302, __p1_302); \
+ __ret_302; \
})
#else
-#define vdups_laneq_s32(__p0, __p1) __extension__ ({ \
- int32_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (int32_t) __builtin_neon_vdups_laneq_i32((int32x4_t)__rev0, __p1); \
- __ret; \
+#define vcopy_lane_p16(__p0_303, __p1_303, __p2_303, __p3_303) __extension__ ({ \
+ poly16x4_t __ret_303; \
+ poly16x4_t __s0_303 = __p0_303; \
+ poly16x4_t __s2_303 = __p2_303; \
+ poly16x4_t __rev0_303; __rev0_303 = __builtin_shufflevector(__s0_303, __s0_303, 3, 2, 1, 0); \
+ poly16x4_t __rev2_303; __rev2_303 = __builtin_shufflevector(__s2_303, __s2_303, 3, 2, 1, 0); \
+ __ret_303 = __noswap_vset_lane_p16(__noswap_vget_lane_p16(__rev2_303, __p3_303), __rev0_303, __p1_303); \
+ __ret_303 = __builtin_shufflevector(__ret_303, __ret_303, 3, 2, 1, 0); \
+ __ret_303; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupd_laneq_s64(__p0, __p1) __extension__ ({ \
- int64_t __ret; \
- int64x2_t __s0 = __p0; \
- __ret = (int64_t) __builtin_neon_vdupd_laneq_i64((int64x2_t)__s0, __p1); \
- __ret; \
+#define vcopy_lane_u8(__p0_304, __p1_304, __p2_304, __p3_304) __extension__ ({ \
+ uint8x8_t __ret_304; \
+ uint8x8_t __s0_304 = __p0_304; \
+ uint8x8_t __s2_304 = __p2_304; \
+ __ret_304 = vset_lane_u8(vget_lane_u8(__s2_304, __p3_304), __s0_304, __p1_304); \
+ __ret_304; \
})
#else
-#define vdupd_laneq_s64(__p0, __p1) __extension__ ({ \
- int64_t __ret; \
- int64x2_t __s0 = __p0; \
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (int64_t) __builtin_neon_vdupd_laneq_i64((int64x2_t)__rev0, __p1); \
- __ret; \
+#define vcopy_lane_u8(__p0_305, __p1_305, __p2_305, __p3_305) __extension__ ({ \
+ uint8x8_t __ret_305; \
+ uint8x8_t __s0_305 = __p0_305; \
+ uint8x8_t __s2_305 = __p2_305; \
+ uint8x8_t __rev0_305; __rev0_305 = __builtin_shufflevector(__s0_305, __s0_305, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x8_t __rev2_305; __rev2_305 = __builtin_shufflevector(__s2_305, __s2_305, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_305 = __noswap_vset_lane_u8(__noswap_vget_lane_u8(__rev2_305, __p3_305), __rev0_305, __p1_305); \
+ __ret_305 = __builtin_shufflevector(__ret_305, __ret_305, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_305; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vduph_laneq_s16(__p0, __p1) __extension__ ({ \
- int16_t __ret; \
- int16x8_t __s0 = __p0; \
- __ret = (int16_t) __builtin_neon_vduph_laneq_i16((int16x8_t)__s0, __p1); \
- __ret; \
+#define vcopy_lane_u32(__p0_306, __p1_306, __p2_306, __p3_306) __extension__ ({ \
+ uint32x2_t __ret_306; \
+ uint32x2_t __s0_306 = __p0_306; \
+ uint32x2_t __s2_306 = __p2_306; \
+ __ret_306 = vset_lane_u32(vget_lane_u32(__s2_306, __p3_306), __s0_306, __p1_306); \
+ __ret_306; \
})
#else
-#define vduph_laneq_s16(__p0, __p1) __extension__ ({ \
- int16_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16_t) __builtin_neon_vduph_laneq_i16((int16x8_t)__rev0, __p1); \
- __ret; \
+#define vcopy_lane_u32(__p0_307, __p1_307, __p2_307, __p3_307) __extension__ ({ \
+ uint32x2_t __ret_307; \
+ uint32x2_t __s0_307 = __p0_307; \
+ uint32x2_t __s2_307 = __p2_307; \
+ uint32x2_t __rev0_307; __rev0_307 = __builtin_shufflevector(__s0_307, __s0_307, 1, 0); \
+ uint32x2_t __rev2_307; __rev2_307 = __builtin_shufflevector(__s2_307, __s2_307, 1, 0); \
+ __ret_307 = __noswap_vset_lane_u32(__noswap_vget_lane_u32(__rev2_307, __p3_307), __rev0_307, __p1_307); \
+ __ret_307 = __builtin_shufflevector(__ret_307, __ret_307, 1, 0); \
+ __ret_307; \
})
#endif
+#define vcopy_lane_u64(__p0_308, __p1_308, __p2_308, __p3_308) __extension__ ({ \
+ uint64x1_t __ret_308; \
+ uint64x1_t __s0_308 = __p0_308; \
+ uint64x1_t __s2_308 = __p2_308; \
+ __ret_308 = vset_lane_u64(vget_lane_u64(__s2_308, __p3_308), __s0_308, __p1_308); \
+ __ret_308; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vdup_laneq_p8(__p0_349, __p1_349) __extension__ ({ \
- poly8x8_t __ret_349; \
- poly8x16_t __s0_349 = __p0_349; \
- __ret_349 = splat_laneq_p8(__s0_349, __p1_349); \
- __ret_349; \
+#define vcopy_lane_u16(__p0_309, __p1_309, __p2_309, __p3_309) __extension__ ({ \
+ uint16x4_t __ret_309; \
+ uint16x4_t __s0_309 = __p0_309; \
+ uint16x4_t __s2_309 = __p2_309; \
+ __ret_309 = vset_lane_u16(vget_lane_u16(__s2_309, __p3_309), __s0_309, __p1_309); \
+ __ret_309; \
})
#else
-#define vdup_laneq_p8(__p0_350, __p1_350) __extension__ ({ \
- poly8x8_t __ret_350; \
- poly8x16_t __s0_350 = __p0_350; \
- poly8x16_t __rev0_350; __rev0_350 = __builtin_shufflevector(__s0_350, __s0_350, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_350 = __noswap_splat_laneq_p8(__rev0_350, __p1_350); \
- __ret_350 = __builtin_shufflevector(__ret_350, __ret_350, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_350; \
+#define vcopy_lane_u16(__p0_310, __p1_310, __p2_310, __p3_310) __extension__ ({ \
+ uint16x4_t __ret_310; \
+ uint16x4_t __s0_310 = __p0_310; \
+ uint16x4_t __s2_310 = __p2_310; \
+ uint16x4_t __rev0_310; __rev0_310 = __builtin_shufflevector(__s0_310, __s0_310, 3, 2, 1, 0); \
+ uint16x4_t __rev2_310; __rev2_310 = __builtin_shufflevector(__s2_310, __s2_310, 3, 2, 1, 0); \
+ __ret_310 = __noswap_vset_lane_u16(__noswap_vget_lane_u16(__rev2_310, __p3_310), __rev0_310, __p1_310); \
+ __ret_310 = __builtin_shufflevector(__ret_310, __ret_310, 3, 2, 1, 0); \
+ __ret_310; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdup_laneq_p64(__p0_351, __p1_351) __extension__ ({ \
- poly64x1_t __ret_351; \
- poly64x2_t __s0_351 = __p0_351; \
- __ret_351 = splat_laneq_p64(__s0_351, __p1_351); \
- __ret_351; \
+#define vcopy_lane_s8(__p0_311, __p1_311, __p2_311, __p3_311) __extension__ ({ \
+ int8x8_t __ret_311; \
+ int8x8_t __s0_311 = __p0_311; \
+ int8x8_t __s2_311 = __p2_311; \
+ __ret_311 = vset_lane_s8(vget_lane_s8(__s2_311, __p3_311), __s0_311, __p1_311); \
+ __ret_311; \
})
#else
-#define vdup_laneq_p64(__p0_352, __p1_352) __extension__ ({ \
- poly64x1_t __ret_352; \
- poly64x2_t __s0_352 = __p0_352; \
- poly64x2_t __rev0_352; __rev0_352 = __builtin_shufflevector(__s0_352, __s0_352, 1, 0); \
- __ret_352 = __noswap_splat_laneq_p64(__rev0_352, __p1_352); \
- __ret_352; \
+#define vcopy_lane_s8(__p0_312, __p1_312, __p2_312, __p3_312) __extension__ ({ \
+ int8x8_t __ret_312; \
+ int8x8_t __s0_312 = __p0_312; \
+ int8x8_t __s2_312 = __p2_312; \
+ int8x8_t __rev0_312; __rev0_312 = __builtin_shufflevector(__s0_312, __s0_312, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x8_t __rev2_312; __rev2_312 = __builtin_shufflevector(__s2_312, __s2_312, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_312 = __noswap_vset_lane_s8(__noswap_vget_lane_s8(__rev2_312, __p3_312), __rev0_312, __p1_312); \
+ __ret_312 = __builtin_shufflevector(__ret_312, __ret_312, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_312; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdup_laneq_p16(__p0_353, __p1_353) __extension__ ({ \
- poly16x4_t __ret_353; \
- poly16x8_t __s0_353 = __p0_353; \
- __ret_353 = splat_laneq_p16(__s0_353, __p1_353); \
- __ret_353; \
+#define vcopy_lane_f32(__p0_313, __p1_313, __p2_313, __p3_313) __extension__ ({ \
+ float32x2_t __ret_313; \
+ float32x2_t __s0_313 = __p0_313; \
+ float32x2_t __s2_313 = __p2_313; \
+ __ret_313 = vset_lane_f32(vget_lane_f32(__s2_313, __p3_313), __s0_313, __p1_313); \
+ __ret_313; \
})
#else
-#define vdup_laneq_p16(__p0_354, __p1_354) __extension__ ({ \
- poly16x4_t __ret_354; \
- poly16x8_t __s0_354 = __p0_354; \
- poly16x8_t __rev0_354; __rev0_354 = __builtin_shufflevector(__s0_354, __s0_354, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_354 = __noswap_splat_laneq_p16(__rev0_354, __p1_354); \
- __ret_354 = __builtin_shufflevector(__ret_354, __ret_354, 3, 2, 1, 0); \
- __ret_354; \
+#define vcopy_lane_f32(__p0_314, __p1_314, __p2_314, __p3_314) __extension__ ({ \
+ float32x2_t __ret_314; \
+ float32x2_t __s0_314 = __p0_314; \
+ float32x2_t __s2_314 = __p2_314; \
+ float32x2_t __rev0_314; __rev0_314 = __builtin_shufflevector(__s0_314, __s0_314, 1, 0); \
+ float32x2_t __rev2_314; __rev2_314 = __builtin_shufflevector(__s2_314, __s2_314, 1, 0); \
+ __ret_314 = __noswap_vset_lane_f32(__noswap_vget_lane_f32(__rev2_314, __p3_314), __rev0_314, __p1_314); \
+ __ret_314 = __builtin_shufflevector(__ret_314, __ret_314, 1, 0); \
+ __ret_314; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupq_laneq_p8(__p0_355, __p1_355) __extension__ ({ \
- poly8x16_t __ret_355; \
- poly8x16_t __s0_355 = __p0_355; \
- __ret_355 = splatq_laneq_p8(__s0_355, __p1_355); \
- __ret_355; \
+#define vcopy_lane_s32(__p0_315, __p1_315, __p2_315, __p3_315) __extension__ ({ \
+ int32x2_t __ret_315; \
+ int32x2_t __s0_315 = __p0_315; \
+ int32x2_t __s2_315 = __p2_315; \
+ __ret_315 = vset_lane_s32(vget_lane_s32(__s2_315, __p3_315), __s0_315, __p1_315); \
+ __ret_315; \
})
#else
-#define vdupq_laneq_p8(__p0_356, __p1_356) __extension__ ({ \
- poly8x16_t __ret_356; \
- poly8x16_t __s0_356 = __p0_356; \
- poly8x16_t __rev0_356; __rev0_356 = __builtin_shufflevector(__s0_356, __s0_356, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_356 = __noswap_splatq_laneq_p8(__rev0_356, __p1_356); \
- __ret_356 = __builtin_shufflevector(__ret_356, __ret_356, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_356; \
+#define vcopy_lane_s32(__p0_316, __p1_316, __p2_316, __p3_316) __extension__ ({ \
+ int32x2_t __ret_316; \
+ int32x2_t __s0_316 = __p0_316; \
+ int32x2_t __s2_316 = __p2_316; \
+ int32x2_t __rev0_316; __rev0_316 = __builtin_shufflevector(__s0_316, __s0_316, 1, 0); \
+ int32x2_t __rev2_316; __rev2_316 = __builtin_shufflevector(__s2_316, __s2_316, 1, 0); \
+ __ret_316 = __noswap_vset_lane_s32(__noswap_vget_lane_s32(__rev2_316, __p3_316), __rev0_316, __p1_316); \
+ __ret_316 = __builtin_shufflevector(__ret_316, __ret_316, 1, 0); \
+ __ret_316; \
})
#endif
+#define vcopy_lane_s64(__p0_317, __p1_317, __p2_317, __p3_317) __extension__ ({ \
+ int64x1_t __ret_317; \
+ int64x1_t __s0_317 = __p0_317; \
+ int64x1_t __s2_317 = __p2_317; \
+ __ret_317 = vset_lane_s64(vget_lane_s64(__s2_317, __p3_317), __s0_317, __p1_317); \
+ __ret_317; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vdupq_laneq_p64(__p0_357, __p1_357) __extension__ ({ \
- poly64x2_t __ret_357; \
- poly64x2_t __s0_357 = __p0_357; \
- __ret_357 = splatq_laneq_p64(__s0_357, __p1_357); \
- __ret_357; \
+#define vcopy_lane_s16(__p0_318, __p1_318, __p2_318, __p3_318) __extension__ ({ \
+ int16x4_t __ret_318; \
+ int16x4_t __s0_318 = __p0_318; \
+ int16x4_t __s2_318 = __p2_318; \
+ __ret_318 = vset_lane_s16(vget_lane_s16(__s2_318, __p3_318), __s0_318, __p1_318); \
+ __ret_318; \
})
#else
-#define vdupq_laneq_p64(__p0_358, __p1_358) __extension__ ({ \
- poly64x2_t __ret_358; \
- poly64x2_t __s0_358 = __p0_358; \
- poly64x2_t __rev0_358; __rev0_358 = __builtin_shufflevector(__s0_358, __s0_358, 1, 0); \
- __ret_358 = __noswap_splatq_laneq_p64(__rev0_358, __p1_358); \
- __ret_358 = __builtin_shufflevector(__ret_358, __ret_358, 1, 0); \
- __ret_358; \
+#define vcopy_lane_s16(__p0_319, __p1_319, __p2_319, __p3_319) __extension__ ({ \
+ int16x4_t __ret_319; \
+ int16x4_t __s0_319 = __p0_319; \
+ int16x4_t __s2_319 = __p2_319; \
+ int16x4_t __rev0_319; __rev0_319 = __builtin_shufflevector(__s0_319, __s0_319, 3, 2, 1, 0); \
+ int16x4_t __rev2_319; __rev2_319 = __builtin_shufflevector(__s2_319, __s2_319, 3, 2, 1, 0); \
+ __ret_319 = __noswap_vset_lane_s16(__noswap_vget_lane_s16(__rev2_319, __p3_319), __rev0_319, __p1_319); \
+ __ret_319 = __builtin_shufflevector(__ret_319, __ret_319, 3, 2, 1, 0); \
+ __ret_319; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupq_laneq_p16(__p0_359, __p1_359) __extension__ ({ \
- poly16x8_t __ret_359; \
- poly16x8_t __s0_359 = __p0_359; \
- __ret_359 = splatq_laneq_p16(__s0_359, __p1_359); \
- __ret_359; \
+#define vcopyq_laneq_p8(__p0_320, __p1_320, __p2_320, __p3_320) __extension__ ({ \
+ poly8x16_t __ret_320; \
+ poly8x16_t __s0_320 = __p0_320; \
+ poly8x16_t __s2_320 = __p2_320; \
+ __ret_320 = vsetq_lane_p8(vgetq_lane_p8(__s2_320, __p3_320), __s0_320, __p1_320); \
+ __ret_320; \
})
#else
-#define vdupq_laneq_p16(__p0_360, __p1_360) __extension__ ({ \
- poly16x8_t __ret_360; \
- poly16x8_t __s0_360 = __p0_360; \
- poly16x8_t __rev0_360; __rev0_360 = __builtin_shufflevector(__s0_360, __s0_360, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_360 = __noswap_splatq_laneq_p16(__rev0_360, __p1_360); \
- __ret_360 = __builtin_shufflevector(__ret_360, __ret_360, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_360; \
+#define vcopyq_laneq_p8(__p0_321, __p1_321, __p2_321, __p3_321) __extension__ ({ \
+ poly8x16_t __ret_321; \
+ poly8x16_t __s0_321 = __p0_321; \
+ poly8x16_t __s2_321 = __p2_321; \
+ poly8x16_t __rev0_321; __rev0_321 = __builtin_shufflevector(__s0_321, __s0_321, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ poly8x16_t __rev2_321; __rev2_321 = __builtin_shufflevector(__s2_321, __s2_321, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_321 = __noswap_vsetq_lane_p8(__noswap_vgetq_lane_p8(__rev2_321, __p3_321), __rev0_321, __p1_321); \
+ __ret_321 = __builtin_shufflevector(__ret_321, __ret_321, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_321; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupq_laneq_u8(__p0_361, __p1_361) __extension__ ({ \
- uint8x16_t __ret_361; \
- uint8x16_t __s0_361 = __p0_361; \
- __ret_361 = splatq_laneq_u8(__s0_361, __p1_361); \
- __ret_361; \
+#define vcopyq_laneq_p16(__p0_322, __p1_322, __p2_322, __p3_322) __extension__ ({ \
+ poly16x8_t __ret_322; \
+ poly16x8_t __s0_322 = __p0_322; \
+ poly16x8_t __s2_322 = __p2_322; \
+ __ret_322 = vsetq_lane_p16(vgetq_lane_p16(__s2_322, __p3_322), __s0_322, __p1_322); \
+ __ret_322; \
})
#else
-#define vdupq_laneq_u8(__p0_362, __p1_362) __extension__ ({ \
- uint8x16_t __ret_362; \
- uint8x16_t __s0_362 = __p0_362; \
- uint8x16_t __rev0_362; __rev0_362 = __builtin_shufflevector(__s0_362, __s0_362, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_362 = __noswap_splatq_laneq_u8(__rev0_362, __p1_362); \
- __ret_362 = __builtin_shufflevector(__ret_362, __ret_362, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_362; \
+#define vcopyq_laneq_p16(__p0_323, __p1_323, __p2_323, __p3_323) __extension__ ({ \
+ poly16x8_t __ret_323; \
+ poly16x8_t __s0_323 = __p0_323; \
+ poly16x8_t __s2_323 = __p2_323; \
+ poly16x8_t __rev0_323; __rev0_323 = __builtin_shufflevector(__s0_323, __s0_323, 7, 6, 5, 4, 3, 2, 1, 0); \
+ poly16x8_t __rev2_323; __rev2_323 = __builtin_shufflevector(__s2_323, __s2_323, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_323 = __noswap_vsetq_lane_p16(__noswap_vgetq_lane_p16(__rev2_323, __p3_323), __rev0_323, __p1_323); \
+ __ret_323 = __builtin_shufflevector(__ret_323, __ret_323, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_323; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupq_laneq_u32(__p0_363, __p1_363) __extension__ ({ \
- uint32x4_t __ret_363; \
- uint32x4_t __s0_363 = __p0_363; \
- __ret_363 = splatq_laneq_u32(__s0_363, __p1_363); \
- __ret_363; \
+#define vcopyq_laneq_u8(__p0_324, __p1_324, __p2_324, __p3_324) __extension__ ({ \
+ uint8x16_t __ret_324; \
+ uint8x16_t __s0_324 = __p0_324; \
+ uint8x16_t __s2_324 = __p2_324; \
+ __ret_324 = vsetq_lane_u8(vgetq_lane_u8(__s2_324, __p3_324), __s0_324, __p1_324); \
+ __ret_324; \
})
#else
-#define vdupq_laneq_u32(__p0_364, __p1_364) __extension__ ({ \
- uint32x4_t __ret_364; \
- uint32x4_t __s0_364 = __p0_364; \
- uint32x4_t __rev0_364; __rev0_364 = __builtin_shufflevector(__s0_364, __s0_364, 3, 2, 1, 0); \
- __ret_364 = __noswap_splatq_laneq_u32(__rev0_364, __p1_364); \
- __ret_364 = __builtin_shufflevector(__ret_364, __ret_364, 3, 2, 1, 0); \
- __ret_364; \
+#define vcopyq_laneq_u8(__p0_325, __p1_325, __p2_325, __p3_325) __extension__ ({ \
+ uint8x16_t __ret_325; \
+ uint8x16_t __s0_325 = __p0_325; \
+ uint8x16_t __s2_325 = __p2_325; \
+ uint8x16_t __rev0_325; __rev0_325 = __builtin_shufflevector(__s0_325, __s0_325, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x16_t __rev2_325; __rev2_325 = __builtin_shufflevector(__s2_325, __s2_325, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_325 = __noswap_vsetq_lane_u8(__noswap_vgetq_lane_u8(__rev2_325, __p3_325), __rev0_325, __p1_325); \
+ __ret_325 = __builtin_shufflevector(__ret_325, __ret_325, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_325; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupq_laneq_u64(__p0_365, __p1_365) __extension__ ({ \
- uint64x2_t __ret_365; \
- uint64x2_t __s0_365 = __p0_365; \
- __ret_365 = splatq_laneq_u64(__s0_365, __p1_365); \
- __ret_365; \
+#define vcopyq_laneq_u32(__p0_326, __p1_326, __p2_326, __p3_326) __extension__ ({ \
+ uint32x4_t __ret_326; \
+ uint32x4_t __s0_326 = __p0_326; \
+ uint32x4_t __s2_326 = __p2_326; \
+ __ret_326 = vsetq_lane_u32(vgetq_lane_u32(__s2_326, __p3_326), __s0_326, __p1_326); \
+ __ret_326; \
})
#else
-#define vdupq_laneq_u64(__p0_366, __p1_366) __extension__ ({ \
- uint64x2_t __ret_366; \
- uint64x2_t __s0_366 = __p0_366; \
- uint64x2_t __rev0_366; __rev0_366 = __builtin_shufflevector(__s0_366, __s0_366, 1, 0); \
- __ret_366 = __noswap_splatq_laneq_u64(__rev0_366, __p1_366); \
- __ret_366 = __builtin_shufflevector(__ret_366, __ret_366, 1, 0); \
- __ret_366; \
+#define vcopyq_laneq_u32(__p0_327, __p1_327, __p2_327, __p3_327) __extension__ ({ \
+ uint32x4_t __ret_327; \
+ uint32x4_t __s0_327 = __p0_327; \
+ uint32x4_t __s2_327 = __p2_327; \
+ uint32x4_t __rev0_327; __rev0_327 = __builtin_shufflevector(__s0_327, __s0_327, 3, 2, 1, 0); \
+ uint32x4_t __rev2_327; __rev2_327 = __builtin_shufflevector(__s2_327, __s2_327, 3, 2, 1, 0); \
+ __ret_327 = __noswap_vsetq_lane_u32(__noswap_vgetq_lane_u32(__rev2_327, __p3_327), __rev0_327, __p1_327); \
+ __ret_327 = __builtin_shufflevector(__ret_327, __ret_327, 3, 2, 1, 0); \
+ __ret_327; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupq_laneq_u16(__p0_367, __p1_367) __extension__ ({ \
- uint16x8_t __ret_367; \
- uint16x8_t __s0_367 = __p0_367; \
- __ret_367 = splatq_laneq_u16(__s0_367, __p1_367); \
- __ret_367; \
+#define vcopyq_laneq_u64(__p0_328, __p1_328, __p2_328, __p3_328) __extension__ ({ \
+ uint64x2_t __ret_328; \
+ uint64x2_t __s0_328 = __p0_328; \
+ uint64x2_t __s2_328 = __p2_328; \
+ __ret_328 = vsetq_lane_u64(vgetq_lane_u64(__s2_328, __p3_328), __s0_328, __p1_328); \
+ __ret_328; \
})
#else
-#define vdupq_laneq_u16(__p0_368, __p1_368) __extension__ ({ \
- uint16x8_t __ret_368; \
- uint16x8_t __s0_368 = __p0_368; \
- uint16x8_t __rev0_368; __rev0_368 = __builtin_shufflevector(__s0_368, __s0_368, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_368 = __noswap_splatq_laneq_u16(__rev0_368, __p1_368); \
- __ret_368 = __builtin_shufflevector(__ret_368, __ret_368, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_368; \
+#define vcopyq_laneq_u64(__p0_329, __p1_329, __p2_329, __p3_329) __extension__ ({ \
+ uint64x2_t __ret_329; \
+ uint64x2_t __s0_329 = __p0_329; \
+ uint64x2_t __s2_329 = __p2_329; \
+ uint64x2_t __rev0_329; __rev0_329 = __builtin_shufflevector(__s0_329, __s0_329, 1, 0); \
+ uint64x2_t __rev2_329; __rev2_329 = __builtin_shufflevector(__s2_329, __s2_329, 1, 0); \
+ __ret_329 = __noswap_vsetq_lane_u64(__noswap_vgetq_lane_u64(__rev2_329, __p3_329), __rev0_329, __p1_329); \
+ __ret_329 = __builtin_shufflevector(__ret_329, __ret_329, 1, 0); \
+ __ret_329; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupq_laneq_s8(__p0_369, __p1_369) __extension__ ({ \
- int8x16_t __ret_369; \
- int8x16_t __s0_369 = __p0_369; \
- __ret_369 = splatq_laneq_s8(__s0_369, __p1_369); \
- __ret_369; \
+#define vcopyq_laneq_u16(__p0_330, __p1_330, __p2_330, __p3_330) __extension__ ({ \
+ uint16x8_t __ret_330; \
+ uint16x8_t __s0_330 = __p0_330; \
+ uint16x8_t __s2_330 = __p2_330; \
+ __ret_330 = vsetq_lane_u16(vgetq_lane_u16(__s2_330, __p3_330), __s0_330, __p1_330); \
+ __ret_330; \
})
#else
-#define vdupq_laneq_s8(__p0_370, __p1_370) __extension__ ({ \
- int8x16_t __ret_370; \
- int8x16_t __s0_370 = __p0_370; \
- int8x16_t __rev0_370; __rev0_370 = __builtin_shufflevector(__s0_370, __s0_370, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_370 = __noswap_splatq_laneq_s8(__rev0_370, __p1_370); \
- __ret_370 = __builtin_shufflevector(__ret_370, __ret_370, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_370; \
+#define vcopyq_laneq_u16(__p0_331, __p1_331, __p2_331, __p3_331) __extension__ ({ \
+ uint16x8_t __ret_331; \
+ uint16x8_t __s0_331 = __p0_331; \
+ uint16x8_t __s2_331 = __p2_331; \
+ uint16x8_t __rev0_331; __rev0_331 = __builtin_shufflevector(__s0_331, __s0_331, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev2_331; __rev2_331 = __builtin_shufflevector(__s2_331, __s2_331, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_331 = __noswap_vsetq_lane_u16(__noswap_vgetq_lane_u16(__rev2_331, __p3_331), __rev0_331, __p1_331); \
+ __ret_331 = __builtin_shufflevector(__ret_331, __ret_331, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_331; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupq_laneq_f64(__p0_371, __p1_371) __extension__ ({ \
- float64x2_t __ret_371; \
- float64x2_t __s0_371 = __p0_371; \
- __ret_371 = splatq_laneq_f64(__s0_371, __p1_371); \
- __ret_371; \
+#define vcopyq_laneq_s8(__p0_332, __p1_332, __p2_332, __p3_332) __extension__ ({ \
+ int8x16_t __ret_332; \
+ int8x16_t __s0_332 = __p0_332; \
+ int8x16_t __s2_332 = __p2_332; \
+ __ret_332 = vsetq_lane_s8(vgetq_lane_s8(__s2_332, __p3_332), __s0_332, __p1_332); \
+ __ret_332; \
})
#else
-#define vdupq_laneq_f64(__p0_372, __p1_372) __extension__ ({ \
- float64x2_t __ret_372; \
- float64x2_t __s0_372 = __p0_372; \
- float64x2_t __rev0_372; __rev0_372 = __builtin_shufflevector(__s0_372, __s0_372, 1, 0); \
- __ret_372 = __noswap_splatq_laneq_f64(__rev0_372, __p1_372); \
- __ret_372 = __builtin_shufflevector(__ret_372, __ret_372, 1, 0); \
- __ret_372; \
+#define vcopyq_laneq_s8(__p0_333, __p1_333, __p2_333, __p3_333) __extension__ ({ \
+ int8x16_t __ret_333; \
+ int8x16_t __s0_333 = __p0_333; \
+ int8x16_t __s2_333 = __p2_333; \
+ int8x16_t __rev0_333; __rev0_333 = __builtin_shufflevector(__s0_333, __s0_333, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x16_t __rev2_333; __rev2_333 = __builtin_shufflevector(__s2_333, __s2_333, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_333 = __noswap_vsetq_lane_s8(__noswap_vgetq_lane_s8(__rev2_333, __p3_333), __rev0_333, __p1_333); \
+ __ret_333 = __builtin_shufflevector(__ret_333, __ret_333, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_333; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupq_laneq_f32(__p0_373, __p1_373) __extension__ ({ \
- float32x4_t __ret_373; \
- float32x4_t __s0_373 = __p0_373; \
- __ret_373 = splatq_laneq_f32(__s0_373, __p1_373); \
- __ret_373; \
+#define vcopyq_laneq_f32(__p0_334, __p1_334, __p2_334, __p3_334) __extension__ ({ \
+ float32x4_t __ret_334; \
+ float32x4_t __s0_334 = __p0_334; \
+ float32x4_t __s2_334 = __p2_334; \
+ __ret_334 = vsetq_lane_f32(vgetq_lane_f32(__s2_334, __p3_334), __s0_334, __p1_334); \
+ __ret_334; \
})
#else
-#define vdupq_laneq_f32(__p0_374, __p1_374) __extension__ ({ \
- float32x4_t __ret_374; \
- float32x4_t __s0_374 = __p0_374; \
- float32x4_t __rev0_374; __rev0_374 = __builtin_shufflevector(__s0_374, __s0_374, 3, 2, 1, 0); \
- __ret_374 = __noswap_splatq_laneq_f32(__rev0_374, __p1_374); \
- __ret_374 = __builtin_shufflevector(__ret_374, __ret_374, 3, 2, 1, 0); \
- __ret_374; \
+#define vcopyq_laneq_f32(__p0_335, __p1_335, __p2_335, __p3_335) __extension__ ({ \
+ float32x4_t __ret_335; \
+ float32x4_t __s0_335 = __p0_335; \
+ float32x4_t __s2_335 = __p2_335; \
+ float32x4_t __rev0_335; __rev0_335 = __builtin_shufflevector(__s0_335, __s0_335, 3, 2, 1, 0); \
+ float32x4_t __rev2_335; __rev2_335 = __builtin_shufflevector(__s2_335, __s2_335, 3, 2, 1, 0); \
+ __ret_335 = __noswap_vsetq_lane_f32(__noswap_vgetq_lane_f32(__rev2_335, __p3_335), __rev0_335, __p1_335); \
+ __ret_335 = __builtin_shufflevector(__ret_335, __ret_335, 3, 2, 1, 0); \
+ __ret_335; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupq_laneq_f16(__p0_375, __p1_375) __extension__ ({ \
- float16x8_t __ret_375; \
- float16x8_t __s0_375 = __p0_375; \
- __ret_375 = splatq_laneq_f16(__s0_375, __p1_375); \
- __ret_375; \
+#define vcopyq_laneq_s32(__p0_336, __p1_336, __p2_336, __p3_336) __extension__ ({ \
+ int32x4_t __ret_336; \
+ int32x4_t __s0_336 = __p0_336; \
+ int32x4_t __s2_336 = __p2_336; \
+ __ret_336 = vsetq_lane_s32(vgetq_lane_s32(__s2_336, __p3_336), __s0_336, __p1_336); \
+ __ret_336; \
})
#else
-#define vdupq_laneq_f16(__p0_376, __p1_376) __extension__ ({ \
- float16x8_t __ret_376; \
- float16x8_t __s0_376 = __p0_376; \
- float16x8_t __rev0_376; __rev0_376 = __builtin_shufflevector(__s0_376, __s0_376, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_376 = __noswap_splatq_laneq_f16(__rev0_376, __p1_376); \
- __ret_376 = __builtin_shufflevector(__ret_376, __ret_376, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_376; \
+#define vcopyq_laneq_s32(__p0_337, __p1_337, __p2_337, __p3_337) __extension__ ({ \
+ int32x4_t __ret_337; \
+ int32x4_t __s0_337 = __p0_337; \
+ int32x4_t __s2_337 = __p2_337; \
+ int32x4_t __rev0_337; __rev0_337 = __builtin_shufflevector(__s0_337, __s0_337, 3, 2, 1, 0); \
+ int32x4_t __rev2_337; __rev2_337 = __builtin_shufflevector(__s2_337, __s2_337, 3, 2, 1, 0); \
+ __ret_337 = __noswap_vsetq_lane_s32(__noswap_vgetq_lane_s32(__rev2_337, __p3_337), __rev0_337, __p1_337); \
+ __ret_337 = __builtin_shufflevector(__ret_337, __ret_337, 3, 2, 1, 0); \
+ __ret_337; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupq_laneq_s32(__p0_377, __p1_377) __extension__ ({ \
- int32x4_t __ret_377; \
- int32x4_t __s0_377 = __p0_377; \
- __ret_377 = splatq_laneq_s32(__s0_377, __p1_377); \
- __ret_377; \
+#define vcopyq_laneq_s64(__p0_338, __p1_338, __p2_338, __p3_338) __extension__ ({ \
+ int64x2_t __ret_338; \
+ int64x2_t __s0_338 = __p0_338; \
+ int64x2_t __s2_338 = __p2_338; \
+ __ret_338 = vsetq_lane_s64(vgetq_lane_s64(__s2_338, __p3_338), __s0_338, __p1_338); \
+ __ret_338; \
})
#else
-#define vdupq_laneq_s32(__p0_378, __p1_378) __extension__ ({ \
- int32x4_t __ret_378; \
- int32x4_t __s0_378 = __p0_378; \
- int32x4_t __rev0_378; __rev0_378 = __builtin_shufflevector(__s0_378, __s0_378, 3, 2, 1, 0); \
- __ret_378 = __noswap_splatq_laneq_s32(__rev0_378, __p1_378); \
- __ret_378 = __builtin_shufflevector(__ret_378, __ret_378, 3, 2, 1, 0); \
- __ret_378; \
+#define vcopyq_laneq_s64(__p0_339, __p1_339, __p2_339, __p3_339) __extension__ ({ \
+ int64x2_t __ret_339; \
+ int64x2_t __s0_339 = __p0_339; \
+ int64x2_t __s2_339 = __p2_339; \
+ int64x2_t __rev0_339; __rev0_339 = __builtin_shufflevector(__s0_339, __s0_339, 1, 0); \
+ int64x2_t __rev2_339; __rev2_339 = __builtin_shufflevector(__s2_339, __s2_339, 1, 0); \
+ __ret_339 = __noswap_vsetq_lane_s64(__noswap_vgetq_lane_s64(__rev2_339, __p3_339), __rev0_339, __p1_339); \
+ __ret_339 = __builtin_shufflevector(__ret_339, __ret_339, 1, 0); \
+ __ret_339; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupq_laneq_s64(__p0_379, __p1_379) __extension__ ({ \
- int64x2_t __ret_379; \
- int64x2_t __s0_379 = __p0_379; \
- __ret_379 = splatq_laneq_s64(__s0_379, __p1_379); \
- __ret_379; \
+#define vcopyq_laneq_s16(__p0_340, __p1_340, __p2_340, __p3_340) __extension__ ({ \
+ int16x8_t __ret_340; \
+ int16x8_t __s0_340 = __p0_340; \
+ int16x8_t __s2_340 = __p2_340; \
+ __ret_340 = vsetq_lane_s16(vgetq_lane_s16(__s2_340, __p3_340), __s0_340, __p1_340); \
+ __ret_340; \
})
#else
-#define vdupq_laneq_s64(__p0_380, __p1_380) __extension__ ({ \
- int64x2_t __ret_380; \
- int64x2_t __s0_380 = __p0_380; \
- int64x2_t __rev0_380; __rev0_380 = __builtin_shufflevector(__s0_380, __s0_380, 1, 0); \
- __ret_380 = __noswap_splatq_laneq_s64(__rev0_380, __p1_380); \
- __ret_380 = __builtin_shufflevector(__ret_380, __ret_380, 1, 0); \
- __ret_380; \
+#define vcopyq_laneq_s16(__p0_341, __p1_341, __p2_341, __p3_341) __extension__ ({ \
+ int16x8_t __ret_341; \
+ int16x8_t __s0_341 = __p0_341; \
+ int16x8_t __s2_341 = __p2_341; \
+ int16x8_t __rev0_341; __rev0_341 = __builtin_shufflevector(__s0_341, __s0_341, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev2_341; __rev2_341 = __builtin_shufflevector(__s2_341, __s2_341, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_341 = __noswap_vsetq_lane_s16(__noswap_vgetq_lane_s16(__rev2_341, __p3_341), __rev0_341, __p1_341); \
+ __ret_341 = __builtin_shufflevector(__ret_341, __ret_341, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_341; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdupq_laneq_s16(__p0_381, __p1_381) __extension__ ({ \
- int16x8_t __ret_381; \
- int16x8_t __s0_381 = __p0_381; \
- __ret_381 = splatq_laneq_s16(__s0_381, __p1_381); \
- __ret_381; \
+#define vcopy_laneq_p8(__p0_342, __p1_342, __p2_342, __p3_342) __extension__ ({ \
+ poly8x8_t __ret_342; \
+ poly8x8_t __s0_342 = __p0_342; \
+ poly8x16_t __s2_342 = __p2_342; \
+ __ret_342 = vset_lane_p8(vgetq_lane_p8(__s2_342, __p3_342), __s0_342, __p1_342); \
+ __ret_342; \
})
#else
-#define vdupq_laneq_s16(__p0_382, __p1_382) __extension__ ({ \
- int16x8_t __ret_382; \
- int16x8_t __s0_382 = __p0_382; \
- int16x8_t __rev0_382; __rev0_382 = __builtin_shufflevector(__s0_382, __s0_382, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_382 = __noswap_splatq_laneq_s16(__rev0_382, __p1_382); \
- __ret_382 = __builtin_shufflevector(__ret_382, __ret_382, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_382; \
+#define vcopy_laneq_p8(__p0_343, __p1_343, __p2_343, __p3_343) __extension__ ({ \
+ poly8x8_t __ret_343; \
+ poly8x8_t __s0_343 = __p0_343; \
+ poly8x16_t __s2_343 = __p2_343; \
+ poly8x8_t __rev0_343; __rev0_343 = __builtin_shufflevector(__s0_343, __s0_343, 7, 6, 5, 4, 3, 2, 1, 0); \
+ poly8x16_t __rev2_343; __rev2_343 = __builtin_shufflevector(__s2_343, __s2_343, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_343 = __noswap_vset_lane_p8(__noswap_vgetq_lane_p8(__rev2_343, __p3_343), __rev0_343, __p1_343); \
+ __ret_343 = __builtin_shufflevector(__ret_343, __ret_343, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_343; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdup_laneq_u8(__p0_383, __p1_383) __extension__ ({ \
- uint8x8_t __ret_383; \
- uint8x16_t __s0_383 = __p0_383; \
- __ret_383 = splat_laneq_u8(__s0_383, __p1_383); \
- __ret_383; \
+#define vcopy_laneq_p16(__p0_344, __p1_344, __p2_344, __p3_344) __extension__ ({ \
+ poly16x4_t __ret_344; \
+ poly16x4_t __s0_344 = __p0_344; \
+ poly16x8_t __s2_344 = __p2_344; \
+ __ret_344 = vset_lane_p16(vgetq_lane_p16(__s2_344, __p3_344), __s0_344, __p1_344); \
+ __ret_344; \
})
#else
-#define vdup_laneq_u8(__p0_384, __p1_384) __extension__ ({ \
- uint8x8_t __ret_384; \
- uint8x16_t __s0_384 = __p0_384; \
- uint8x16_t __rev0_384; __rev0_384 = __builtin_shufflevector(__s0_384, __s0_384, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_384 = __noswap_splat_laneq_u8(__rev0_384, __p1_384); \
- __ret_384 = __builtin_shufflevector(__ret_384, __ret_384, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_384; \
+#define vcopy_laneq_p16(__p0_345, __p1_345, __p2_345, __p3_345) __extension__ ({ \
+ poly16x4_t __ret_345; \
+ poly16x4_t __s0_345 = __p0_345; \
+ poly16x8_t __s2_345 = __p2_345; \
+ poly16x4_t __rev0_345; __rev0_345 = __builtin_shufflevector(__s0_345, __s0_345, 3, 2, 1, 0); \
+ poly16x8_t __rev2_345; __rev2_345 = __builtin_shufflevector(__s2_345, __s2_345, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_345 = __noswap_vset_lane_p16(__noswap_vgetq_lane_p16(__rev2_345, __p3_345), __rev0_345, __p1_345); \
+ __ret_345 = __builtin_shufflevector(__ret_345, __ret_345, 3, 2, 1, 0); \
+ __ret_345; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdup_laneq_u32(__p0_385, __p1_385) __extension__ ({ \
- uint32x2_t __ret_385; \
- uint32x4_t __s0_385 = __p0_385; \
- __ret_385 = splat_laneq_u32(__s0_385, __p1_385); \
- __ret_385; \
+#define vcopy_laneq_u8(__p0_346, __p1_346, __p2_346, __p3_346) __extension__ ({ \
+ uint8x8_t __ret_346; \
+ uint8x8_t __s0_346 = __p0_346; \
+ uint8x16_t __s2_346 = __p2_346; \
+ __ret_346 = vset_lane_u8(vgetq_lane_u8(__s2_346, __p3_346), __s0_346, __p1_346); \
+ __ret_346; \
})
#else
-#define vdup_laneq_u32(__p0_386, __p1_386) __extension__ ({ \
- uint32x2_t __ret_386; \
- uint32x4_t __s0_386 = __p0_386; \
- uint32x4_t __rev0_386; __rev0_386 = __builtin_shufflevector(__s0_386, __s0_386, 3, 2, 1, 0); \
- __ret_386 = __noswap_splat_laneq_u32(__rev0_386, __p1_386); \
- __ret_386 = __builtin_shufflevector(__ret_386, __ret_386, 1, 0); \
- __ret_386; \
+#define vcopy_laneq_u8(__p0_347, __p1_347, __p2_347, __p3_347) __extension__ ({ \
+ uint8x8_t __ret_347; \
+ uint8x8_t __s0_347 = __p0_347; \
+ uint8x16_t __s2_347 = __p2_347; \
+ uint8x8_t __rev0_347; __rev0_347 = __builtin_shufflevector(__s0_347, __s0_347, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x16_t __rev2_347; __rev2_347 = __builtin_shufflevector(__s2_347, __s2_347, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_347 = __noswap_vset_lane_u8(__noswap_vgetq_lane_u8(__rev2_347, __p3_347), __rev0_347, __p1_347); \
+ __ret_347 = __builtin_shufflevector(__ret_347, __ret_347, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_347; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdup_laneq_u64(__p0_387, __p1_387) __extension__ ({ \
- uint64x1_t __ret_387; \
- uint64x2_t __s0_387 = __p0_387; \
- __ret_387 = splat_laneq_u64(__s0_387, __p1_387); \
- __ret_387; \
+#define vcopy_laneq_u32(__p0_348, __p1_348, __p2_348, __p3_348) __extension__ ({ \
+ uint32x2_t __ret_348; \
+ uint32x2_t __s0_348 = __p0_348; \
+ uint32x4_t __s2_348 = __p2_348; \
+ __ret_348 = vset_lane_u32(vgetq_lane_u32(__s2_348, __p3_348), __s0_348, __p1_348); \
+ __ret_348; \
})
#else
-#define vdup_laneq_u64(__p0_388, __p1_388) __extension__ ({ \
- uint64x1_t __ret_388; \
- uint64x2_t __s0_388 = __p0_388; \
- uint64x2_t __rev0_388; __rev0_388 = __builtin_shufflevector(__s0_388, __s0_388, 1, 0); \
- __ret_388 = __noswap_splat_laneq_u64(__rev0_388, __p1_388); \
- __ret_388; \
+#define vcopy_laneq_u32(__p0_349, __p1_349, __p2_349, __p3_349) __extension__ ({ \
+ uint32x2_t __ret_349; \
+ uint32x2_t __s0_349 = __p0_349; \
+ uint32x4_t __s2_349 = __p2_349; \
+ uint32x2_t __rev0_349; __rev0_349 = __builtin_shufflevector(__s0_349, __s0_349, 1, 0); \
+ uint32x4_t __rev2_349; __rev2_349 = __builtin_shufflevector(__s2_349, __s2_349, 3, 2, 1, 0); \
+ __ret_349 = __noswap_vset_lane_u32(__noswap_vgetq_lane_u32(__rev2_349, __p3_349), __rev0_349, __p1_349); \
+ __ret_349 = __builtin_shufflevector(__ret_349, __ret_349, 1, 0); \
+ __ret_349; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdup_laneq_u16(__p0_389, __p1_389) __extension__ ({ \
- uint16x4_t __ret_389; \
- uint16x8_t __s0_389 = __p0_389; \
- __ret_389 = splat_laneq_u16(__s0_389, __p1_389); \
- __ret_389; \
+#define vcopy_laneq_u64(__p0_350, __p1_350, __p2_350, __p3_350) __extension__ ({ \
+ uint64x1_t __ret_350; \
+ uint64x1_t __s0_350 = __p0_350; \
+ uint64x2_t __s2_350 = __p2_350; \
+ __ret_350 = vset_lane_u64(vgetq_lane_u64(__s2_350, __p3_350), __s0_350, __p1_350); \
+ __ret_350; \
})
#else
-#define vdup_laneq_u16(__p0_390, __p1_390) __extension__ ({ \
- uint16x4_t __ret_390; \
- uint16x8_t __s0_390 = __p0_390; \
- uint16x8_t __rev0_390; __rev0_390 = __builtin_shufflevector(__s0_390, __s0_390, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_390 = __noswap_splat_laneq_u16(__rev0_390, __p1_390); \
- __ret_390 = __builtin_shufflevector(__ret_390, __ret_390, 3, 2, 1, 0); \
- __ret_390; \
+#define vcopy_laneq_u64(__p0_351, __p1_351, __p2_351, __p3_351) __extension__ ({ \
+ uint64x1_t __ret_351; \
+ uint64x1_t __s0_351 = __p0_351; \
+ uint64x2_t __s2_351 = __p2_351; \
+ uint64x2_t __rev2_351; __rev2_351 = __builtin_shufflevector(__s2_351, __s2_351, 1, 0); \
+ __ret_351 = vset_lane_u64(__noswap_vgetq_lane_u64(__rev2_351, __p3_351), __s0_351, __p1_351); \
+ __ret_351; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdup_laneq_s8(__p0_391, __p1_391) __extension__ ({ \
- int8x8_t __ret_391; \
- int8x16_t __s0_391 = __p0_391; \
- __ret_391 = splat_laneq_s8(__s0_391, __p1_391); \
- __ret_391; \
+#define vcopy_laneq_u16(__p0_352, __p1_352, __p2_352, __p3_352) __extension__ ({ \
+ uint16x4_t __ret_352; \
+ uint16x4_t __s0_352 = __p0_352; \
+ uint16x8_t __s2_352 = __p2_352; \
+ __ret_352 = vset_lane_u16(vgetq_lane_u16(__s2_352, __p3_352), __s0_352, __p1_352); \
+ __ret_352; \
})
#else
-#define vdup_laneq_s8(__p0_392, __p1_392) __extension__ ({ \
- int8x8_t __ret_392; \
- int8x16_t __s0_392 = __p0_392; \
- int8x16_t __rev0_392; __rev0_392 = __builtin_shufflevector(__s0_392, __s0_392, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_392 = __noswap_splat_laneq_s8(__rev0_392, __p1_392); \
- __ret_392 = __builtin_shufflevector(__ret_392, __ret_392, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_392; \
+#define vcopy_laneq_u16(__p0_353, __p1_353, __p2_353, __p3_353) __extension__ ({ \
+ uint16x4_t __ret_353; \
+ uint16x4_t __s0_353 = __p0_353; \
+ uint16x8_t __s2_353 = __p2_353; \
+ uint16x4_t __rev0_353; __rev0_353 = __builtin_shufflevector(__s0_353, __s0_353, 3, 2, 1, 0); \
+ uint16x8_t __rev2_353; __rev2_353 = __builtin_shufflevector(__s2_353, __s2_353, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_353 = __noswap_vset_lane_u16(__noswap_vgetq_lane_u16(__rev2_353, __p3_353), __rev0_353, __p1_353); \
+ __ret_353 = __builtin_shufflevector(__ret_353, __ret_353, 3, 2, 1, 0); \
+ __ret_353; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdup_laneq_f64(__p0_393, __p1_393) __extension__ ({ \
- float64x1_t __ret_393; \
- float64x2_t __s0_393 = __p0_393; \
- __ret_393 = splat_laneq_f64(__s0_393, __p1_393); \
- __ret_393; \
+#define vcopy_laneq_s8(__p0_354, __p1_354, __p2_354, __p3_354) __extension__ ({ \
+ int8x8_t __ret_354; \
+ int8x8_t __s0_354 = __p0_354; \
+ int8x16_t __s2_354 = __p2_354; \
+ __ret_354 = vset_lane_s8(vgetq_lane_s8(__s2_354, __p3_354), __s0_354, __p1_354); \
+ __ret_354; \
})
#else
-#define vdup_laneq_f64(__p0_394, __p1_394) __extension__ ({ \
- float64x1_t __ret_394; \
- float64x2_t __s0_394 = __p0_394; \
- float64x2_t __rev0_394; __rev0_394 = __builtin_shufflevector(__s0_394, __s0_394, 1, 0); \
- __ret_394 = __noswap_splat_laneq_f64(__rev0_394, __p1_394); \
- __ret_394; \
+#define vcopy_laneq_s8(__p0_355, __p1_355, __p2_355, __p3_355) __extension__ ({ \
+ int8x8_t __ret_355; \
+ int8x8_t __s0_355 = __p0_355; \
+ int8x16_t __s2_355 = __p2_355; \
+ int8x8_t __rev0_355; __rev0_355 = __builtin_shufflevector(__s0_355, __s0_355, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x16_t __rev2_355; __rev2_355 = __builtin_shufflevector(__s2_355, __s2_355, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_355 = __noswap_vset_lane_s8(__noswap_vgetq_lane_s8(__rev2_355, __p3_355), __rev0_355, __p1_355); \
+ __ret_355 = __builtin_shufflevector(__ret_355, __ret_355, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_355; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdup_laneq_f32(__p0_395, __p1_395) __extension__ ({ \
- float32x2_t __ret_395; \
- float32x4_t __s0_395 = __p0_395; \
- __ret_395 = splat_laneq_f32(__s0_395, __p1_395); \
- __ret_395; \
+#define vcopy_laneq_f32(__p0_356, __p1_356, __p2_356, __p3_356) __extension__ ({ \
+ float32x2_t __ret_356; \
+ float32x2_t __s0_356 = __p0_356; \
+ float32x4_t __s2_356 = __p2_356; \
+ __ret_356 = vset_lane_f32(vgetq_lane_f32(__s2_356, __p3_356), __s0_356, __p1_356); \
+ __ret_356; \
})
#else
-#define vdup_laneq_f32(__p0_396, __p1_396) __extension__ ({ \
- float32x2_t __ret_396; \
- float32x4_t __s0_396 = __p0_396; \
- float32x4_t __rev0_396; __rev0_396 = __builtin_shufflevector(__s0_396, __s0_396, 3, 2, 1, 0); \
- __ret_396 = __noswap_splat_laneq_f32(__rev0_396, __p1_396); \
- __ret_396 = __builtin_shufflevector(__ret_396, __ret_396, 1, 0); \
- __ret_396; \
+#define vcopy_laneq_f32(__p0_357, __p1_357, __p2_357, __p3_357) __extension__ ({ \
+ float32x2_t __ret_357; \
+ float32x2_t __s0_357 = __p0_357; \
+ float32x4_t __s2_357 = __p2_357; \
+ float32x2_t __rev0_357; __rev0_357 = __builtin_shufflevector(__s0_357, __s0_357, 1, 0); \
+ float32x4_t __rev2_357; __rev2_357 = __builtin_shufflevector(__s2_357, __s2_357, 3, 2, 1, 0); \
+ __ret_357 = __noswap_vset_lane_f32(__noswap_vgetq_lane_f32(__rev2_357, __p3_357), __rev0_357, __p1_357); \
+ __ret_357 = __builtin_shufflevector(__ret_357, __ret_357, 1, 0); \
+ __ret_357; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdup_laneq_f16(__p0_397, __p1_397) __extension__ ({ \
- float16x4_t __ret_397; \
- float16x8_t __s0_397 = __p0_397; \
- __ret_397 = splat_laneq_f16(__s0_397, __p1_397); \
- __ret_397; \
+#define vcopy_laneq_s32(__p0_358, __p1_358, __p2_358, __p3_358) __extension__ ({ \
+ int32x2_t __ret_358; \
+ int32x2_t __s0_358 = __p0_358; \
+ int32x4_t __s2_358 = __p2_358; \
+ __ret_358 = vset_lane_s32(vgetq_lane_s32(__s2_358, __p3_358), __s0_358, __p1_358); \
+ __ret_358; \
})
#else
-#define vdup_laneq_f16(__p0_398, __p1_398) __extension__ ({ \
- float16x4_t __ret_398; \
- float16x8_t __s0_398 = __p0_398; \
- float16x8_t __rev0_398; __rev0_398 = __builtin_shufflevector(__s0_398, __s0_398, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_398 = __noswap_splat_laneq_f16(__rev0_398, __p1_398); \
- __ret_398 = __builtin_shufflevector(__ret_398, __ret_398, 3, 2, 1, 0); \
- __ret_398; \
+#define vcopy_laneq_s32(__p0_359, __p1_359, __p2_359, __p3_359) __extension__ ({ \
+ int32x2_t __ret_359; \
+ int32x2_t __s0_359 = __p0_359; \
+ int32x4_t __s2_359 = __p2_359; \
+ int32x2_t __rev0_359; __rev0_359 = __builtin_shufflevector(__s0_359, __s0_359, 1, 0); \
+ int32x4_t __rev2_359; __rev2_359 = __builtin_shufflevector(__s2_359, __s2_359, 3, 2, 1, 0); \
+ __ret_359 = __noswap_vset_lane_s32(__noswap_vgetq_lane_s32(__rev2_359, __p3_359), __rev0_359, __p1_359); \
+ __ret_359 = __builtin_shufflevector(__ret_359, __ret_359, 1, 0); \
+ __ret_359; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdup_laneq_s32(__p0_399, __p1_399) __extension__ ({ \
- int32x2_t __ret_399; \
- int32x4_t __s0_399 = __p0_399; \
- __ret_399 = splat_laneq_s32(__s0_399, __p1_399); \
- __ret_399; \
+#define vcopy_laneq_s64(__p0_360, __p1_360, __p2_360, __p3_360) __extension__ ({ \
+ int64x1_t __ret_360; \
+ int64x1_t __s0_360 = __p0_360; \
+ int64x2_t __s2_360 = __p2_360; \
+ __ret_360 = vset_lane_s64(vgetq_lane_s64(__s2_360, __p3_360), __s0_360, __p1_360); \
+ __ret_360; \
})
#else
-#define vdup_laneq_s32(__p0_400, __p1_400) __extension__ ({ \
- int32x2_t __ret_400; \
- int32x4_t __s0_400 = __p0_400; \
- int32x4_t __rev0_400; __rev0_400 = __builtin_shufflevector(__s0_400, __s0_400, 3, 2, 1, 0); \
- __ret_400 = __noswap_splat_laneq_s32(__rev0_400, __p1_400); \
- __ret_400 = __builtin_shufflevector(__ret_400, __ret_400, 1, 0); \
- __ret_400; \
+#define vcopy_laneq_s64(__p0_361, __p1_361, __p2_361, __p3_361) __extension__ ({ \
+ int64x1_t __ret_361; \
+ int64x1_t __s0_361 = __p0_361; \
+ int64x2_t __s2_361 = __p2_361; \
+ int64x2_t __rev2_361; __rev2_361 = __builtin_shufflevector(__s2_361, __s2_361, 1, 0); \
+ __ret_361 = vset_lane_s64(__noswap_vgetq_lane_s64(__rev2_361, __p3_361), __s0_361, __p1_361); \
+ __ret_361; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdup_laneq_s64(__p0_401, __p1_401) __extension__ ({ \
- int64x1_t __ret_401; \
- int64x2_t __s0_401 = __p0_401; \
- __ret_401 = splat_laneq_s64(__s0_401, __p1_401); \
- __ret_401; \
+#define vcopy_laneq_s16(__p0_362, __p1_362, __p2_362, __p3_362) __extension__ ({ \
+ int16x4_t __ret_362; \
+ int16x4_t __s0_362 = __p0_362; \
+ int16x8_t __s2_362 = __p2_362; \
+ __ret_362 = vset_lane_s16(vgetq_lane_s16(__s2_362, __p3_362), __s0_362, __p1_362); \
+ __ret_362; \
})
#else
-#define vdup_laneq_s64(__p0_402, __p1_402) __extension__ ({ \
- int64x1_t __ret_402; \
- int64x2_t __s0_402 = __p0_402; \
- int64x2_t __rev0_402; __rev0_402 = __builtin_shufflevector(__s0_402, __s0_402, 1, 0); \
- __ret_402 = __noswap_splat_laneq_s64(__rev0_402, __p1_402); \
- __ret_402; \
+#define vcopy_laneq_s16(__p0_363, __p1_363, __p2_363, __p3_363) __extension__ ({ \
+ int16x4_t __ret_363; \
+ int16x4_t __s0_363 = __p0_363; \
+ int16x8_t __s2_363 = __p2_363; \
+ int16x4_t __rev0_363; __rev0_363 = __builtin_shufflevector(__s0_363, __s0_363, 3, 2, 1, 0); \
+ int16x8_t __rev2_363; __rev2_363 = __builtin_shufflevector(__s2_363, __s2_363, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_363 = __noswap_vset_lane_s16(__noswap_vgetq_lane_s16(__rev2_363, __p3_363), __rev0_363, __p1_363); \
+ __ret_363 = __builtin_shufflevector(__ret_363, __ret_363, 3, 2, 1, 0); \
+ __ret_363; \
})
#endif
-#ifdef __LITTLE_ENDIAN__
-#define vdup_laneq_s16(__p0_403, __p1_403) __extension__ ({ \
- int16x4_t __ret_403; \
- int16x8_t __s0_403 = __p0_403; \
- __ret_403 = splat_laneq_s16(__s0_403, __p1_403); \
- __ret_403; \
+#define vcreate_p64(__p0) __extension__ ({ \
+ poly64x1_t __ret; \
+ uint64_t __promote = __p0; \
+ __ret = (poly64x1_t)(__promote); \
+ __ret; \
})
-#else
-#define vdup_laneq_s16(__p0_404, __p1_404) __extension__ ({ \
- int16x4_t __ret_404; \
- int16x8_t __s0_404 = __p0_404; \
- int16x8_t __rev0_404; __rev0_404 = __builtin_shufflevector(__s0_404, __s0_404, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_404 = __noswap_splat_laneq_s16(__rev0_404, __p1_404); \
- __ret_404 = __builtin_shufflevector(__ret_404, __ret_404, 3, 2, 1, 0); \
- __ret_404; \
+#define vcreate_f64(__p0) __extension__ ({ \
+ float64x1_t __ret; \
+ uint64_t __promote = __p0; \
+ __ret = (float64x1_t)(__promote); \
+ __ret; \
})
+__ai __attribute__((target("neon"))) float32_t vcvts_f32_s32(int32_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vcvts_f32_s32(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float32_t vcvts_f32_u32(uint32_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vcvts_f32_u32(__p0);
+ return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vcvt_f32_f64(float64x2_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vcvt_f32_f64((int8x16_t)__p0, 9);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vcvt_f32_f64(float64x2_t __p0) {
+ float32x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vcvt_f32_f64((int8x16_t)__rev0, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t __noswap_vcvt_f32_f64(float64x2_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vcvt_f32_f64((int8x16_t)__p0, 9);
+ return __ret;
+}
#endif
-__ai poly64x1_t vdup_n_p64(poly64_t __p0) {
- poly64x1_t __ret;
- __ret = (poly64x1_t) {__p0};
+__ai __attribute__((target("neon"))) float64_t vcvtd_f64_s64(int64_t __p0) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vcvtd_f64_s64(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float64_t vcvtd_f64_u64(uint64_t __p0) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vcvtd_f64_u64(__p0);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai poly64x2_t vdupq_n_p64(poly64_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t) {__p0, __p0};
+__ai __attribute__((target("neon"))) float64x2_t vcvtq_f64_u64(uint64x2_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vcvtq_f64_v((int8x16_t)__p0, 51);
return __ret;
}
#else
-__ai poly64x2_t vdupq_n_p64(poly64_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t) {__p0, __p0};
+__ai __attribute__((target("neon"))) float64x2_t vcvtq_f64_u64(uint64x2_t __p0) {
+ float64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vcvtq_f64_v((int8x16_t)__rev0, 51);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vdupq_n_f64(float64_t __p0) {
+__ai __attribute__((target("neon"))) float64x2_t vcvtq_f64_s64(int64x2_t __p0) {
float64x2_t __ret;
- __ret = (float64x2_t) {__p0, __p0};
+ __ret = (float64x2_t) __builtin_neon_vcvtq_f64_v((int8x16_t)__p0, 35);
return __ret;
}
#else
-__ai float64x2_t vdupq_n_f64(float64_t __p0) {
+__ai __attribute__((target("neon"))) float64x2_t vcvtq_f64_s64(int64x2_t __p0) {
float64x2_t __ret;
- __ret = (float64x2_t) {__p0, __p0};
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vcvtq_f64_v((int8x16_t)__rev0, 35);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai float64x1_t vdup_n_f64(float64_t __p0) {
+__ai __attribute__((target("neon"))) float64x1_t vcvt_f64_u64(uint64x1_t __p0) {
float64x1_t __ret;
- __ret = (float64x1_t) {__p0};
+ __ret = (float64x1_t) __builtin_neon_vcvt_f64_v((int8x8_t)__p0, 19);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float64x1_t vcvt_f64_s64(int64x1_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vcvt_f64_v((int8x8_t)__p0, 3);
return __ret;
}
-#define vext_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x1_t __ret; \
- poly64x1_t __s0 = __p0; \
- poly64x1_t __s1 = __p1; \
- __ret = (poly64x1_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 6); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vextq_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2_t __ret; \
- poly64x2_t __s0 = __p0; \
- poly64x2_t __s1 = __p1; \
- __ret = (poly64x2_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 38); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vcvt_f64_f32(float32x2_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vcvt_f64_f32((int8x8_t)__p0, 42);
+ return __ret;
+}
#else
-#define vextq_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2_t __ret; \
- poly64x2_t __s0 = __p0; \
- poly64x2_t __s1 = __p1; \
- poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (poly64x2_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 38); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vcvt_f64_f32(float32x2_t __p0) {
+ float64x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vcvt_f64_f32((int8x8_t)__rev0, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t __noswap_vcvt_f64_f32(float32x2_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vcvt_f64_f32((int8x8_t)__p0, 42);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vextq_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2_t __ret; \
- float64x2_t __s0 = __p0; \
- float64x2_t __s1 = __p1; \
- __ret = (float64x2_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 42); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float16x8_t vcvt_high_f16_f32(float16x4_t __p0, float32x4_t __p1) {
+ float16x8_t __ret;
+ __ret = vcombine_f16(__p0, vcvt_f16_f32(__p1));
+ return __ret;
+}
#else
-#define vextq_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2_t __ret; \
- float64x2_t __s0 = __p0; \
- float64x2_t __s1 = __p1; \
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (float64x2_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 42); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float16x8_t vcvt_high_f16_f32(float16x4_t __p0, float32x4_t __p1) {
+ float16x8_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_f16(__rev0, __noswap_vcvt_f16_f32(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-#define vext_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x1_t __ret; \
- float64x1_t __s0 = __p0; \
- float64x1_t __s1 = __p1; \
- __ret = (float64x1_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 10); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vfmaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vfmaq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
+__ai __attribute__((target("neon"))) float32x4_t vcvt_high_f32_f16(float16x8_t __p0) {
+ float32x4_t __ret;
+ __ret = vcvt_f32_f16(vget_high_f16(__p0));
return __ret;
}
#else
-__ai float64x2_t vfmaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- float64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vfmaq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) float32x4_t vcvt_high_f32_f16(float16x8_t __p0) {
+ float32x4_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vcvt_f32_f16(__noswap_vget_high_f16(__rev0));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai float64x2_t __noswap_vfmaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vfmaq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vcvt_high_f32_f64(float32x2_t __p0, float64x2_t __p1) {
+ float32x4_t __ret;
+ __ret = vcombine_f32(__p0, vcvt_f32_f64(__p1));
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vcvt_high_f32_f64(float32x2_t __p0, float64x2_t __p1) {
+ float32x4_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __noswap_vcombine_f32(__rev0, __noswap_vcvt_f32_f64(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai float64x1_t vfma_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vfma_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 10);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vcvt_high_f64_f32(float32x4_t __p0) {
+ float64x2_t __ret;
+ __ret = vcvt_f64_f32(vget_high_f32(__p0));
return __ret;
}
-#define vfmad_lane_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
- float64_t __ret; \
- float64_t __s0 = __p0; \
- float64_t __s1 = __p1; \
- float64x1_t __s2 = __p2; \
- __ret = (float64_t) __builtin_neon_vfmad_lane_f64(__s0, __s1, (float64x1_t)__s2, __p3); \
- __ret; \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vfmas_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
- float32_t __ret; \
- float32_t __s0 = __p0; \
- float32_t __s1 = __p1; \
- float32x2_t __s2 = __p2; \
- __ret = (float32_t) __builtin_neon_vfmas_lane_f32(__s0, __s1, (float32x2_t)__s2, __p3); \
- __ret; \
-})
#else
-#define vfmas_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+__ai __attribute__((target("neon"))) float64x2_t vcvt_high_f64_f32(float32x4_t __p0) {
+ float64x2_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __noswap_vcvt_f64_f32(__noswap_vget_high_f32(__rev0));
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#define vcvts_n_f32_u32(__p0, __p1) __extension__ ({ \
float32_t __ret; \
- float32_t __s0 = __p0; \
- float32_t __s1 = __p1; \
- float32x2_t __s2 = __p2; \
- float32x2_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
- __ret = (float32_t) __builtin_neon_vfmas_lane_f32(__s0, __s1, (float32x2_t)__rev2, __p3); \
+ uint32_t __s0 = __p0; \
+ __ret = (float32_t) __builtin_neon_vcvts_n_f32_u32(__s0, __p1); \
__ret; \
})
-#define __noswap_vfmas_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+#define vcvts_n_f32_s32(__p0, __p1) __extension__ ({ \
float32_t __ret; \
- float32_t __s0 = __p0; \
- float32_t __s1 = __p1; \
- float32x2_t __s2 = __p2; \
- __ret = (float32_t) __builtin_neon_vfmas_lane_f32(__s0, __s1, (float32x2_t)__s2, __p3); \
+ int32_t __s0 = __p0; \
+ __ret = (float32_t) __builtin_neon_vcvts_n_f32_s32(__s0, __p1); \
__ret; \
})
-#endif
-
#ifdef __LITTLE_ENDIAN__
-#define vfmaq_lane_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+#define vcvtq_n_f64_u64(__p0, __p1) __extension__ ({ \
float64x2_t __ret; \
- float64x2_t __s0 = __p0; \
- float64x2_t __s1 = __p1; \
- float64x1_t __s2 = __p2; \
- __ret = (float64x2_t) __builtin_neon_vfmaq_lane_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x8_t)__s2, __p3, 42); \
+ uint64x2_t __s0 = __p0; \
+ __ret = (float64x2_t) __builtin_neon_vcvtq_n_f64_v((int8x16_t)__s0, __p1, 51); \
__ret; \
})
#else
-#define vfmaq_lane_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+#define vcvtq_n_f64_u64(__p0, __p1) __extension__ ({ \
float64x2_t __ret; \
- float64x2_t __s0 = __p0; \
- float64x2_t __s1 = __p1; \
- float64x1_t __s2 = __p2; \
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (float64x2_t) __builtin_neon_vfmaq_lane_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x8_t)__s2, __p3, 42); \
+ uint64x2_t __s0 = __p0; \
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (float64x2_t) __builtin_neon_vcvtq_n_f64_v((int8x16_t)__rev0, __p1, 51); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
-#define __noswap_vfmaq_lane_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
- float64x2_t __ret; \
- float64x2_t __s0 = __p0; \
- float64x2_t __s1 = __p1; \
- float64x1_t __s2 = __p2; \
- __ret = (float64x2_t) __builtin_neon_vfmaq_lane_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x8_t)__s2, __p3, 42); \
- __ret; \
-})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vfmaq_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
- float32x4_t __ret; \
- float32x4_t __s0 = __p0; \
- float32x4_t __s1 = __p1; \
- float32x2_t __s2 = __p2; \
- __ret = (float32x4_t) __builtin_neon_vfmaq_lane_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x8_t)__s2, __p3, 41); \
+#define vcvtq_n_f64_s64(__p0, __p1) __extension__ ({ \
+ float64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (float64x2_t) __builtin_neon_vcvtq_n_f64_v((int8x16_t)__s0, __p1, 35); \
__ret; \
})
#else
-#define vfmaq_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
- float32x4_t __ret; \
- float32x4_t __s0 = __p0; \
- float32x4_t __s1 = __p1; \
- float32x2_t __s2 = __p2; \
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- float32x2_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
- __ret = (float32x4_t) __builtin_neon_vfmaq_lane_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x8_t)__rev2, __p3, 41); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vfmaq_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
- float32x4_t __ret; \
- float32x4_t __s0 = __p0; \
- float32x4_t __s1 = __p1; \
- float32x2_t __s2 = __p2; \
- __ret = (float32x4_t) __builtin_neon_vfmaq_lane_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x8_t)__s2, __p3, 41); \
+#define vcvtq_n_f64_s64(__p0, __p1) __extension__ ({ \
+ float64x2_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (float64x2_t) __builtin_neon_vcvtq_n_f64_v((int8x16_t)__rev0, __p1, 35); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
-#define vfma_lane_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+#define vcvt_n_f64_u64(__p0, __p1) __extension__ ({ \
float64x1_t __ret; \
- float64x1_t __s0 = __p0; \
- float64x1_t __s1 = __p1; \
- float64x1_t __s2 = __p2; \
- __ret = (float64x1_t) __builtin_neon_vfma_lane_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x8_t)__s2, __p3, 10); \
+ uint64x1_t __s0 = __p0; \
+ __ret = (float64x1_t) __builtin_neon_vcvt_n_f64_v((int8x8_t)__s0, __p1, 19); \
__ret; \
})
-#ifdef __LITTLE_ENDIAN__
-#define vfma_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
- float32x2_t __ret; \
- float32x2_t __s0 = __p0; \
- float32x2_t __s1 = __p1; \
- float32x2_t __s2 = __p2; \
- __ret = (float32x2_t) __builtin_neon_vfma_lane_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x8_t)__s2, __p3, 9); \
+#define vcvt_n_f64_s64(__p0, __p1) __extension__ ({ \
+ float64x1_t __ret; \
+ int64x1_t __s0 = __p0; \
+ __ret = (float64x1_t) __builtin_neon_vcvt_n_f64_v((int8x8_t)__s0, __p1, 3); \
__ret; \
})
-#else
-#define vfma_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
- float32x2_t __ret; \
- float32x2_t __s0 = __p0; \
- float32x2_t __s1 = __p1; \
- float32x2_t __s2 = __p2; \
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- float32x2_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
- __ret = (float32x2_t) __builtin_neon_vfma_lane_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, __p3, 9); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+#define vcvtd_n_f64_u64(__p0, __p1) __extension__ ({ \
+ float64_t __ret; \
+ uint64_t __s0 = __p0; \
+ __ret = (float64_t) __builtin_neon_vcvtd_n_f64_u64(__s0, __p1); \
__ret; \
})
-#define __noswap_vfma_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
- float32x2_t __ret; \
- float32x2_t __s0 = __p0; \
- float32x2_t __s1 = __p1; \
- float32x2_t __s2 = __p2; \
- __ret = (float32x2_t) __builtin_neon_vfma_lane_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x8_t)__s2, __p3, 9); \
+#define vcvtd_n_f64_s64(__p0, __p1) __extension__ ({ \
+ float64_t __ret; \
+ int64_t __s0 = __p0; \
+ __ret = (float64_t) __builtin_neon_vcvtd_n_f64_s64(__s0, __p1); \
__ret; \
})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vfmad_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
- float64_t __ret; \
- float64_t __s0 = __p0; \
- float64_t __s1 = __p1; \
- float64x2_t __s2 = __p2; \
- __ret = (float64_t) __builtin_neon_vfmad_laneq_f64(__s0, __s1, (float64x2_t)__s2, __p3); \
+#define vcvts_n_s32_f32(__p0, __p1) __extension__ ({ \
+ int32_t __ret; \
+ float32_t __s0 = __p0; \
+ __ret = (int32_t) __builtin_neon_vcvts_n_s32_f32(__s0, __p1); \
__ret; \
})
-#else
-#define vfmad_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
- float64_t __ret; \
- float64_t __s0 = __p0; \
- float64_t __s1 = __p1; \
- float64x2_t __s2 = __p2; \
- float64x2_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
- __ret = (float64_t) __builtin_neon_vfmad_laneq_f64(__s0, __s1, (float64x2_t)__rev2, __p3); \
+#ifdef __LITTLE_ENDIAN__
+#define vcvtq_n_s64_f64(__p0, __p1) __extension__ ({ \
+ int64x2_t __ret; \
+ float64x2_t __s0 = __p0; \
+ __ret = (int64x2_t) __builtin_neon_vcvtq_n_s64_v((int8x16_t)__s0, __p1, 35); \
__ret; \
})
-#define __noswap_vfmad_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
- float64_t __ret; \
- float64_t __s0 = __p0; \
- float64_t __s1 = __p1; \
- float64x2_t __s2 = __p2; \
- __ret = (float64_t) __builtin_neon_vfmad_laneq_f64(__s0, __s1, (float64x2_t)__s2, __p3); \
+#else
+#define vcvtq_n_s64_f64(__p0, __p1) __extension__ ({ \
+ int64x2_t __ret; \
+ float64x2_t __s0 = __p0; \
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (int64x2_t) __builtin_neon_vcvtq_n_s64_v((int8x16_t)__rev0, __p1, 35); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
-#ifdef __LITTLE_ENDIAN__
-#define vfmas_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
- float32_t __ret; \
- float32_t __s0 = __p0; \
- float32_t __s1 = __p1; \
- float32x4_t __s2 = __p2; \
- __ret = (float32_t) __builtin_neon_vfmas_laneq_f32(__s0, __s1, (float32x4_t)__s2, __p3); \
+#define vcvt_n_s64_f64(__p0, __p1) __extension__ ({ \
+ int64x1_t __ret; \
+ float64x1_t __s0 = __p0; \
+ __ret = (int64x1_t) __builtin_neon_vcvt_n_s64_v((int8x8_t)__s0, __p1, 3); \
__ret; \
})
-#else
-#define vfmas_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
- float32_t __ret; \
- float32_t __s0 = __p0; \
- float32_t __s1 = __p1; \
- float32x4_t __s2 = __p2; \
- float32x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
- __ret = (float32_t) __builtin_neon_vfmas_laneq_f32(__s0, __s1, (float32x4_t)__rev2, __p3); \
+#define vcvtd_n_s64_f64(__p0, __p1) __extension__ ({ \
+ int64_t __ret; \
+ float64_t __s0 = __p0; \
+ __ret = (int64_t) __builtin_neon_vcvtd_n_s64_f64(__s0, __p1); \
__ret; \
})
-#define __noswap_vfmas_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
- float32_t __ret; \
+#define vcvts_n_u32_f32(__p0, __p1) __extension__ ({ \
+ uint32_t __ret; \
float32_t __s0 = __p0; \
- float32_t __s1 = __p1; \
- float32x4_t __s2 = __p2; \
- __ret = (float32_t) __builtin_neon_vfmas_laneq_f32(__s0, __s1, (float32x4_t)__s2, __p3); \
+ __ret = (uint32_t) __builtin_neon_vcvts_n_u32_f32(__s0, __p1); \
__ret; \
})
-#endif
-
#ifdef __LITTLE_ENDIAN__
-#define vfmaq_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
- float64x2_t __ret; \
+#define vcvtq_n_u64_f64(__p0, __p1) __extension__ ({ \
+ uint64x2_t __ret; \
float64x2_t __s0 = __p0; \
- float64x2_t __s1 = __p1; \
- float64x2_t __s2 = __p2; \
- __ret = (float64x2_t) __builtin_neon_vfmaq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 42); \
+ __ret = (uint64x2_t) __builtin_neon_vcvtq_n_u64_v((int8x16_t)__s0, __p1, 51); \
__ret; \
})
#else
-#define vfmaq_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
- float64x2_t __ret; \
+#define vcvtq_n_u64_f64(__p0, __p1) __extension__ ({ \
+ uint64x2_t __ret; \
float64x2_t __s0 = __p0; \
- float64x2_t __s1 = __p1; \
- float64x2_t __s2 = __p2; \
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- float64x2_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
- __ret = (float64x2_t) __builtin_neon_vfmaq_laneq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, __p3, 42); \
+ __ret = (uint64x2_t) __builtin_neon_vcvtq_n_u64_v((int8x16_t)__rev0, __p1, 51); \
__ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
-#define __noswap_vfmaq_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
- float64x2_t __ret; \
- float64x2_t __s0 = __p0; \
- float64x2_t __s1 = __p1; \
- float64x2_t __s2 = __p2; \
- __ret = (float64x2_t) __builtin_neon_vfmaq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 42); \
- __ret; \
-})
#endif
-#ifdef __LITTLE_ENDIAN__
-#define vfmaq_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
- float32x4_t __ret; \
- float32x4_t __s0 = __p0; \
- float32x4_t __s1 = __p1; \
- float32x4_t __s2 = __p2; \
- __ret = (float32x4_t) __builtin_neon_vfmaq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 41); \
- __ret; \
-})
-#else
-#define vfmaq_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
- float32x4_t __ret; \
- float32x4_t __s0 = __p0; \
- float32x4_t __s1 = __p1; \
- float32x4_t __s2 = __p2; \
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- float32x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
- __ret = (float32x4_t) __builtin_neon_vfmaq_laneq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, __p3, 41); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+#define vcvt_n_u64_f64(__p0, __p1) __extension__ ({ \
+ uint64x1_t __ret; \
+ float64x1_t __s0 = __p0; \
+ __ret = (uint64x1_t) __builtin_neon_vcvt_n_u64_v((int8x8_t)__s0, __p1, 19); \
__ret; \
})
-#define __noswap_vfmaq_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
- float32x4_t __ret; \
- float32x4_t __s0 = __p0; \
- float32x4_t __s1 = __p1; \
- float32x4_t __s2 = __p2; \
- __ret = (float32x4_t) __builtin_neon_vfmaq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 41); \
+#define vcvtd_n_u64_f64(__p0, __p1) __extension__ ({ \
+ uint64_t __ret; \
+ float64_t __s0 = __p0; \
+ __ret = (uint64_t) __builtin_neon_vcvtd_n_u64_f64(__s0, __p1); \
__ret; \
})
-#endif
-
+__ai __attribute__((target("neon"))) int32_t vcvts_s32_f32(float32_t __p0) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vcvts_s32_f32(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vcvtd_s64_f64(float64_t __p0) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vcvtd_s64_f64(__p0);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vfma_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
- float64x1_t __ret; \
- float64x1_t __s0 = __p0; \
- float64x1_t __s1 = __p1; \
- float64x2_t __s2 = __p2; \
- __ret = (float64x1_t) __builtin_neon_vfma_laneq_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__s2, __p3, 10); \
- __ret; \
-})
-#else
-#define vfma_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
- float64x1_t __ret; \
- float64x1_t __s0 = __p0; \
- float64x1_t __s1 = __p1; \
- float64x2_t __s2 = __p2; \
- float64x2_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
- __ret = (float64x1_t) __builtin_neon_vfma_laneq_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__rev2, __p3, 10); \
- __ret; \
-})
-#define __noswap_vfma_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
- float64x1_t __ret; \
- float64x1_t __s0 = __p0; \
- float64x1_t __s1 = __p1; \
- float64x2_t __s2 = __p2; \
- __ret = (float64x1_t) __builtin_neon_vfma_laneq_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__s2, __p3, 10); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vfma_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
- float32x2_t __ret; \
- float32x2_t __s0 = __p0; \
- float32x2_t __s1 = __p1; \
- float32x4_t __s2 = __p2; \
- __ret = (float32x2_t) __builtin_neon_vfma_laneq_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__s2, __p3, 9); \
- __ret; \
-})
-#else
-#define vfma_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
- float32x2_t __ret; \
- float32x2_t __s0 = __p0; \
- float32x2_t __s1 = __p1; \
- float32x4_t __s2 = __p2; \
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- float32x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
- __ret = (float32x2_t) __builtin_neon_vfma_laneq_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x16_t)__rev2, __p3, 9); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_vfma_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
- float32x2_t __ret; \
- float32x2_t __s0 = __p0; \
- float32x2_t __s1 = __p1; \
- float32x4_t __s2 = __p2; \
- __ret = (float32x2_t) __builtin_neon_vfma_laneq_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__s2, __p3, 9); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vfmaq_n_f64(float64x2_t __p0, float64x2_t __p1, float64_t __p2) {
- float64x2_t __ret;
- __ret = vfmaq_f64(__p0, __p1, (float64x2_t) {__p2, __p2});
+__ai __attribute__((target("neon"))) int64x2_t vcvtq_s64_f64(float64x2_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vcvtq_s64_v((int8x16_t)__p0, 35);
return __ret;
}
#else
-__ai float64x2_t vfmaq_n_f64(float64x2_t __p0, float64x2_t __p1, float64_t __p2) {
- float64x2_t __ret;
+__ai __attribute__((target("neon"))) int64x2_t vcvtq_s64_f64(float64x2_t __p0) {
+ int64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __noswap_vfmaq_f64(__rev0, __rev1, (float64x2_t) {__p2, __p2});
+ __ret = (int64x2_t) __builtin_neon_vcvtq_s64_v((int8x16_t)__rev0, 35);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai float64x1_t vfma_n_f64(float64x1_t __p0, float64x1_t __p1, float64_t __p2) {
- float64x1_t __ret;
- __ret = vfma_f64(__p0, __p1, (float64x1_t) {__p2});
+__ai __attribute__((target("neon"))) int64x1_t vcvt_s64_f64(float64x1_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t) __builtin_neon_vcvt_s64_v((int8x8_t)__p0, 3);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcvts_u32_f32(float32_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vcvts_u32_f32(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcvtd_u64_f64(float64_t __p0) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcvtd_u64_f64(__p0);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vfmsq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
- float64x2_t __ret;
- __ret = vfmaq_f64(__p0, -__p1, __p2);
+__ai __attribute__((target("neon"))) uint64x2_t vcvtq_u64_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vcvtq_u64_v((int8x16_t)__p0, 51);
return __ret;
}
#else
-__ai float64x2_t vfmsq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
- float64x2_t __ret;
+__ai __attribute__((target("neon"))) uint64x2_t vcvtq_u64_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- float64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = __noswap_vfmaq_f64(__rev0, -__rev1, __rev2);
+ __ret = (uint64x2_t) __builtin_neon_vcvtq_u64_v((int8x16_t)__rev0, 51);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai float64x1_t vfms_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
- float64x1_t __ret;
- __ret = vfma_f64(__p0, -__p1, __p2);
+__ai __attribute__((target("neon"))) uint64x1_t vcvt_u64_f64(float64x1_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vcvt_u64_v((int8x8_t)__p0, 19);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vcvtas_s32_f32(float32_t __p0) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vcvtas_s32_f32(__p0);
return __ret;
}
-#define vfmsd_lane_f64(__p0_405, __p1_405, __p2_405, __p3_405) __extension__ ({ \
- float64_t __ret_405; \
- float64_t __s0_405 = __p0_405; \
- float64_t __s1_405 = __p1_405; \
- float64x1_t __s2_405 = __p2_405; \
- __ret_405 = vfmad_lane_f64(__s0_405, -__s1_405, __s2_405, __p3_405); \
- __ret_405; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vfmss_lane_f32(__p0_406, __p1_406, __p2_406, __p3_406) __extension__ ({ \
- float32_t __ret_406; \
- float32_t __s0_406 = __p0_406; \
- float32_t __s1_406 = __p1_406; \
- float32x2_t __s2_406 = __p2_406; \
- __ret_406 = vfmas_lane_f32(__s0_406, -__s1_406, __s2_406, __p3_406); \
- __ret_406; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vcvtaq_s64_f64(float64x2_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vcvtaq_s64_v((int8x16_t)__p0, 35);
+ return __ret;
+}
#else
-#define vfmss_lane_f32(__p0_407, __p1_407, __p2_407, __p3_407) __extension__ ({ \
- float32_t __ret_407; \
- float32_t __s0_407 = __p0_407; \
- float32_t __s1_407 = __p1_407; \
- float32x2_t __s2_407 = __p2_407; \
- float32x2_t __rev2_407; __rev2_407 = __builtin_shufflevector(__s2_407, __s2_407, 1, 0); \
- __ret_407 = __noswap_vfmas_lane_f32(__s0_407, -__s1_407, __rev2_407, __p3_407); \
- __ret_407; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vcvtaq_s64_f64(float64x2_t __p0) {
+ int64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vcvtaq_s64_v((int8x16_t)__rev0, 35);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) int64x1_t vcvta_s64_f64(float64x1_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t) __builtin_neon_vcvta_s64_v((int8x8_t)__p0, 3);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vcvtad_s64_f64(float64_t __p0) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vcvtad_s64_f64(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcvtas_u32_f32(float32_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vcvtas_u32_f32(__p0);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vfmsq_lane_f64(__p0_408, __p1_408, __p2_408, __p3_408) __extension__ ({ \
- float64x2_t __ret_408; \
- float64x2_t __s0_408 = __p0_408; \
- float64x2_t __s1_408 = __p1_408; \
- float64x1_t __s2_408 = __p2_408; \
- __ret_408 = vfmaq_lane_f64(__s0_408, -__s1_408, __s2_408, __p3_408); \
- __ret_408; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcvtaq_u64_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vcvtaq_u64_v((int8x16_t)__p0, 51);
+ return __ret;
+}
#else
-#define vfmsq_lane_f64(__p0_409, __p1_409, __p2_409, __p3_409) __extension__ ({ \
- float64x2_t __ret_409; \
- float64x2_t __s0_409 = __p0_409; \
- float64x2_t __s1_409 = __p1_409; \
- float64x1_t __s2_409 = __p2_409; \
- float64x2_t __rev0_409; __rev0_409 = __builtin_shufflevector(__s0_409, __s0_409, 1, 0); \
- float64x2_t __rev1_409; __rev1_409 = __builtin_shufflevector(__s1_409, __s1_409, 1, 0); \
- __ret_409 = __noswap_vfmaq_lane_f64(__rev0_409, -__rev1_409, __s2_409, __p3_409); \
- __ret_409 = __builtin_shufflevector(__ret_409, __ret_409, 1, 0); \
- __ret_409; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcvtaq_u64_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vcvtaq_u64_v((int8x16_t)__rev0, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vcvta_u64_f64(float64x1_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vcvta_u64_v((int8x8_t)__p0, 19);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcvtad_u64_f64(float64_t __p0) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcvtad_u64_f64(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vcvtms_s32_f32(float32_t __p0) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vcvtms_s32_f32(__p0);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vfmsq_lane_f32(__p0_410, __p1_410, __p2_410, __p3_410) __extension__ ({ \
- float32x4_t __ret_410; \
- float32x4_t __s0_410 = __p0_410; \
- float32x4_t __s1_410 = __p1_410; \
- float32x2_t __s2_410 = __p2_410; \
- __ret_410 = vfmaq_lane_f32(__s0_410, -__s1_410, __s2_410, __p3_410); \
- __ret_410; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vcvtmq_s64_f64(float64x2_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vcvtmq_s64_v((int8x16_t)__p0, 35);
+ return __ret;
+}
#else
-#define vfmsq_lane_f32(__p0_411, __p1_411, __p2_411, __p3_411) __extension__ ({ \
- float32x4_t __ret_411; \
- float32x4_t __s0_411 = __p0_411; \
- float32x4_t __s1_411 = __p1_411; \
- float32x2_t __s2_411 = __p2_411; \
- float32x4_t __rev0_411; __rev0_411 = __builtin_shufflevector(__s0_411, __s0_411, 3, 2, 1, 0); \
- float32x4_t __rev1_411; __rev1_411 = __builtin_shufflevector(__s1_411, __s1_411, 3, 2, 1, 0); \
- float32x2_t __rev2_411; __rev2_411 = __builtin_shufflevector(__s2_411, __s2_411, 1, 0); \
- __ret_411 = __noswap_vfmaq_lane_f32(__rev0_411, -__rev1_411, __rev2_411, __p3_411); \
- __ret_411 = __builtin_shufflevector(__ret_411, __ret_411, 3, 2, 1, 0); \
- __ret_411; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vcvtmq_s64_f64(float64x2_t __p0) {
+ int64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vcvtmq_s64_v((int8x16_t)__rev0, 35);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
-#define vfms_lane_f64(__p0_412, __p1_412, __p2_412, __p3_412) __extension__ ({ \
- float64x1_t __ret_412; \
- float64x1_t __s0_412 = __p0_412; \
- float64x1_t __s1_412 = __p1_412; \
- float64x1_t __s2_412 = __p2_412; \
- __ret_412 = vfma_lane_f64(__s0_412, -__s1_412, __s2_412, __p3_412); \
- __ret_412; \
-})
+__ai __attribute__((target("neon"))) int64x1_t vcvtm_s64_f64(float64x1_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t) __builtin_neon_vcvtm_s64_v((int8x8_t)__p0, 3);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vcvtmd_s64_f64(float64_t __p0) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vcvtmd_s64_f64(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcvtms_u32_f32(float32_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vcvtms_u32_f32(__p0);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vfms_lane_f32(__p0_413, __p1_413, __p2_413, __p3_413) __extension__ ({ \
- float32x2_t __ret_413; \
- float32x2_t __s0_413 = __p0_413; \
- float32x2_t __s1_413 = __p1_413; \
- float32x2_t __s2_413 = __p2_413; \
- __ret_413 = vfma_lane_f32(__s0_413, -__s1_413, __s2_413, __p3_413); \
- __ret_413; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcvtmq_u64_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vcvtmq_u64_v((int8x16_t)__p0, 51);
+ return __ret;
+}
#else
-#define vfms_lane_f32(__p0_414, __p1_414, __p2_414, __p3_414) __extension__ ({ \
- float32x2_t __ret_414; \
- float32x2_t __s0_414 = __p0_414; \
- float32x2_t __s1_414 = __p1_414; \
- float32x2_t __s2_414 = __p2_414; \
- float32x2_t __rev0_414; __rev0_414 = __builtin_shufflevector(__s0_414, __s0_414, 1, 0); \
- float32x2_t __rev1_414; __rev1_414 = __builtin_shufflevector(__s1_414, __s1_414, 1, 0); \
- float32x2_t __rev2_414; __rev2_414 = __builtin_shufflevector(__s2_414, __s2_414, 1, 0); \
- __ret_414 = __noswap_vfma_lane_f32(__rev0_414, -__rev1_414, __rev2_414, __p3_414); \
- __ret_414 = __builtin_shufflevector(__ret_414, __ret_414, 1, 0); \
- __ret_414; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcvtmq_u64_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vcvtmq_u64_v((int8x16_t)__rev0, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vcvtm_u64_f64(float64x1_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vcvtm_u64_v((int8x8_t)__p0, 19);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcvtmd_u64_f64(float64_t __p0) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcvtmd_u64_f64(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vcvtns_s32_f32(float32_t __p0) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vcvtns_s32_f32(__p0);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vfmsd_laneq_f64(__p0_415, __p1_415, __p2_415, __p3_415) __extension__ ({ \
- float64_t __ret_415; \
- float64_t __s0_415 = __p0_415; \
- float64_t __s1_415 = __p1_415; \
- float64x2_t __s2_415 = __p2_415; \
- __ret_415 = vfmad_laneq_f64(__s0_415, -__s1_415, __s2_415, __p3_415); \
- __ret_415; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vcvtnq_s64_f64(float64x2_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vcvtnq_s64_v((int8x16_t)__p0, 35);
+ return __ret;
+}
#else
-#define vfmsd_laneq_f64(__p0_416, __p1_416, __p2_416, __p3_416) __extension__ ({ \
- float64_t __ret_416; \
- float64_t __s0_416 = __p0_416; \
- float64_t __s1_416 = __p1_416; \
- float64x2_t __s2_416 = __p2_416; \
- float64x2_t __rev2_416; __rev2_416 = __builtin_shufflevector(__s2_416, __s2_416, 1, 0); \
- __ret_416 = __noswap_vfmad_laneq_f64(__s0_416, -__s1_416, __rev2_416, __p3_416); \
- __ret_416; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vcvtnq_s64_f64(float64x2_t __p0) {
+ int64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vcvtnq_s64_v((int8x16_t)__rev0, 35);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) int64x1_t vcvtn_s64_f64(float64x1_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t) __builtin_neon_vcvtn_s64_v((int8x8_t)__p0, 3);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vcvtnd_s64_f64(float64_t __p0) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vcvtnd_s64_f64(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcvtns_u32_f32(float32_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vcvtns_u32_f32(__p0);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vfmss_laneq_f32(__p0_417, __p1_417, __p2_417, __p3_417) __extension__ ({ \
- float32_t __ret_417; \
- float32_t __s0_417 = __p0_417; \
- float32_t __s1_417 = __p1_417; \
- float32x4_t __s2_417 = __p2_417; \
- __ret_417 = vfmas_laneq_f32(__s0_417, -__s1_417, __s2_417, __p3_417); \
- __ret_417; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcvtnq_u64_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vcvtnq_u64_v((int8x16_t)__p0, 51);
+ return __ret;
+}
#else
-#define vfmss_laneq_f32(__p0_418, __p1_418, __p2_418, __p3_418) __extension__ ({ \
- float32_t __ret_418; \
- float32_t __s0_418 = __p0_418; \
- float32_t __s1_418 = __p1_418; \
- float32x4_t __s2_418 = __p2_418; \
- float32x4_t __rev2_418; __rev2_418 = __builtin_shufflevector(__s2_418, __s2_418, 3, 2, 1, 0); \
- __ret_418 = __noswap_vfmas_laneq_f32(__s0_418, -__s1_418, __rev2_418, __p3_418); \
- __ret_418; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcvtnq_u64_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vcvtnq_u64_v((int8x16_t)__rev0, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vcvtn_u64_f64(float64x1_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vcvtn_u64_v((int8x8_t)__p0, 19);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcvtnd_u64_f64(float64_t __p0) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcvtnd_u64_f64(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vcvtps_s32_f32(float32_t __p0) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vcvtps_s32_f32(__p0);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vfmsq_laneq_f64(__p0_419, __p1_419, __p2_419, __p3_419) __extension__ ({ \
- float64x2_t __ret_419; \
- float64x2_t __s0_419 = __p0_419; \
- float64x2_t __s1_419 = __p1_419; \
- float64x2_t __s2_419 = __p2_419; \
- __ret_419 = vfmaq_laneq_f64(__s0_419, -__s1_419, __s2_419, __p3_419); \
- __ret_419; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vcvtpq_s64_f64(float64x2_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vcvtpq_s64_v((int8x16_t)__p0, 35);
+ return __ret;
+}
#else
-#define vfmsq_laneq_f64(__p0_420, __p1_420, __p2_420, __p3_420) __extension__ ({ \
- float64x2_t __ret_420; \
- float64x2_t __s0_420 = __p0_420; \
- float64x2_t __s1_420 = __p1_420; \
- float64x2_t __s2_420 = __p2_420; \
- float64x2_t __rev0_420; __rev0_420 = __builtin_shufflevector(__s0_420, __s0_420, 1, 0); \
- float64x2_t __rev1_420; __rev1_420 = __builtin_shufflevector(__s1_420, __s1_420, 1, 0); \
- float64x2_t __rev2_420; __rev2_420 = __builtin_shufflevector(__s2_420, __s2_420, 1, 0); \
- __ret_420 = __noswap_vfmaq_laneq_f64(__rev0_420, -__rev1_420, __rev2_420, __p3_420); \
- __ret_420 = __builtin_shufflevector(__ret_420, __ret_420, 1, 0); \
- __ret_420; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vcvtpq_s64_f64(float64x2_t __p0) {
+ int64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vcvtpq_s64_v((int8x16_t)__rev0, 35);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) int64x1_t vcvtp_s64_f64(float64x1_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t) __builtin_neon_vcvtp_s64_v((int8x8_t)__p0, 3);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vcvtpd_s64_f64(float64_t __p0) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vcvtpd_s64_f64(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcvtps_u32_f32(float32_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vcvtps_u32_f32(__p0);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vfmsq_laneq_f32(__p0_421, __p1_421, __p2_421, __p3_421) __extension__ ({ \
- float32x4_t __ret_421; \
- float32x4_t __s0_421 = __p0_421; \
- float32x4_t __s1_421 = __p1_421; \
- float32x4_t __s2_421 = __p2_421; \
- __ret_421 = vfmaq_laneq_f32(__s0_421, -__s1_421, __s2_421, __p3_421); \
- __ret_421; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcvtpq_u64_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vcvtpq_u64_v((int8x16_t)__p0, 51);
+ return __ret;
+}
#else
-#define vfmsq_laneq_f32(__p0_422, __p1_422, __p2_422, __p3_422) __extension__ ({ \
- float32x4_t __ret_422; \
- float32x4_t __s0_422 = __p0_422; \
- float32x4_t __s1_422 = __p1_422; \
- float32x4_t __s2_422 = __p2_422; \
- float32x4_t __rev0_422; __rev0_422 = __builtin_shufflevector(__s0_422, __s0_422, 3, 2, 1, 0); \
- float32x4_t __rev1_422; __rev1_422 = __builtin_shufflevector(__s1_422, __s1_422, 3, 2, 1, 0); \
- float32x4_t __rev2_422; __rev2_422 = __builtin_shufflevector(__s2_422, __s2_422, 3, 2, 1, 0); \
- __ret_422 = __noswap_vfmaq_laneq_f32(__rev0_422, -__rev1_422, __rev2_422, __p3_422); \
- __ret_422 = __builtin_shufflevector(__ret_422, __ret_422, 3, 2, 1, 0); \
- __ret_422; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vcvtpq_u64_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vcvtpq_u64_v((int8x16_t)__rev0, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vcvtp_u64_f64(float64x1_t __p0) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vcvtp_u64_v((int8x8_t)__p0, 19);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcvtpd_u64_f64(float64_t __p0) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vcvtpd_u64_f64(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float32_t vcvtxd_f32_f64(float64_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vcvtxd_f32_f64(__p0);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vfms_laneq_f64(__p0_423, __p1_423, __p2_423, __p3_423) __extension__ ({ \
- float64x1_t __ret_423; \
- float64x1_t __s0_423 = __p0_423; \
- float64x1_t __s1_423 = __p1_423; \
- float64x2_t __s2_423 = __p2_423; \
- __ret_423 = vfma_laneq_f64(__s0_423, -__s1_423, __s2_423, __p3_423); \
- __ret_423; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vcvtx_f32_f64(float64x2_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vcvtx_f32_v((int8x16_t)__p0, 42);
+ return __ret;
+}
#else
-#define vfms_laneq_f64(__p0_424, __p1_424, __p2_424, __p3_424) __extension__ ({ \
- float64x1_t __ret_424; \
- float64x1_t __s0_424 = __p0_424; \
- float64x1_t __s1_424 = __p1_424; \
- float64x2_t __s2_424 = __p2_424; \
- float64x2_t __rev2_424; __rev2_424 = __builtin_shufflevector(__s2_424, __s2_424, 1, 0); \
- __ret_424 = __noswap_vfma_laneq_f64(__s0_424, -__s1_424, __rev2_424, __p3_424); \
- __ret_424; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vcvtx_f32_f64(float64x2_t __p0) {
+ float32x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vcvtx_f32_v((int8x16_t)__rev0, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t __noswap_vcvtx_f32_f64(float64x2_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vcvtx_f32_v((int8x16_t)__p0, 42);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vfms_laneq_f32(__p0_425, __p1_425, __p2_425, __p3_425) __extension__ ({ \
- float32x2_t __ret_425; \
- float32x2_t __s0_425 = __p0_425; \
- float32x2_t __s1_425 = __p1_425; \
- float32x4_t __s2_425 = __p2_425; \
- __ret_425 = vfma_laneq_f32(__s0_425, -__s1_425, __s2_425, __p3_425); \
- __ret_425; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vcvtx_high_f32_f64(float32x2_t __p0, float64x2_t __p1) {
+ float32x4_t __ret;
+ __ret = vcombine_f32(__p0, vcvtx_f32_f64(__p1));
+ return __ret;
+}
#else
-#define vfms_laneq_f32(__p0_426, __p1_426, __p2_426, __p3_426) __extension__ ({ \
- float32x2_t __ret_426; \
- float32x2_t __s0_426 = __p0_426; \
- float32x2_t __s1_426 = __p1_426; \
- float32x4_t __s2_426 = __p2_426; \
- float32x2_t __rev0_426; __rev0_426 = __builtin_shufflevector(__s0_426, __s0_426, 1, 0); \
- float32x2_t __rev1_426; __rev1_426 = __builtin_shufflevector(__s1_426, __s1_426, 1, 0); \
- float32x4_t __rev2_426; __rev2_426 = __builtin_shufflevector(__s2_426, __s2_426, 3, 2, 1, 0); \
- __ret_426 = __noswap_vfma_laneq_f32(__rev0_426, -__rev1_426, __rev2_426, __p3_426); \
- __ret_426 = __builtin_shufflevector(__ret_426, __ret_426, 1, 0); \
- __ret_426; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vcvtx_high_f32_f64(float32x2_t __p0, float64x2_t __p1) {
+ float32x4_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __noswap_vcombine_f32(__rev0, __noswap_vcvtx_f32_f64(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vfmsq_n_f64(float64x2_t __p0, float64x2_t __p1, float64_t __p2) {
+__ai __attribute__((target("neon"))) float64x2_t vdivq_f64(float64x2_t __p0, float64x2_t __p1) {
float64x2_t __ret;
- __ret = vfmaq_f64(__p0, -__p1, (float64x2_t) {__p2, __p2});
+ __ret = __p0 / __p1;
return __ret;
}
#else
-__ai float64x2_t vfmsq_n_f64(float64x2_t __p0, float64x2_t __p1, float64_t __p2) {
+__ai __attribute__((target("neon"))) float64x2_t vdivq_f64(float64x2_t __p0, float64x2_t __p1) {
float64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __noswap_vfmaq_f64(__rev0, -__rev1, (float64x2_t) {__p2, __p2});
+ __ret = __rev0 / __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vfmsq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
+__ai __attribute__((target("neon"))) float32x4_t vdivq_f32(float32x4_t __p0, float32x4_t __p1) {
float32x4_t __ret;
- __ret = vfmaq_f32(__p0, -__p1, (float32x4_t) {__p2, __p2, __p2, __p2});
+ __ret = __p0 / __p1;
return __ret;
}
#else
-__ai float32x4_t vfmsq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
+__ai __attribute__((target("neon"))) float32x4_t vdivq_f32(float32x4_t __p0, float32x4_t __p1) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vfmaq_f32(__rev0, -__rev1, (float32x4_t) {__p2, __p2, __p2, __p2});
+ __ret = __rev0 / __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai float64x1_t vfms_n_f64(float64x1_t __p0, float64x1_t __p1, float64_t __p2) {
+__ai __attribute__((target("neon"))) float64x1_t vdiv_f64(float64x1_t __p0, float64x1_t __p1) {
float64x1_t __ret;
- __ret = vfma_f64(__p0, -__p1, (float64x1_t) {__p2});
+ __ret = __p0 / __p1;
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vfms_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
+__ai __attribute__((target("neon"))) float32x2_t vdiv_f32(float32x2_t __p0, float32x2_t __p1) {
float32x2_t __ret;
- __ret = vfma_f32(__p0, -__p1, (float32x2_t) {__p2, __p2});
+ __ret = __p0 / __p1;
return __ret;
}
#else
-__ai float32x2_t vfms_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
+__ai __attribute__((target("neon"))) float32x2_t vdiv_f32(float32x2_t __p0, float32x2_t __p1) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __noswap_vfma_f32(__rev0, -__rev1, (float32x2_t) {__p2, __p2});
+ __ret = __rev0 / __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly64x1_t vget_high_p64(poly64x2_t __p0) {
- poly64x1_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1);
- return __ret;
-}
-#else
-__ai poly64x1_t vget_high_p64(poly64x2_t __p0) {
- poly64x1_t __ret;
- poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1);
- return __ret;
-}
-__ai poly64x1_t __noswap_vget_high_p64(poly64x2_t __p0) {
- poly64x1_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float64x1_t vget_high_f64(float64x2_t __p0) {
- float64x1_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 1);
- return __ret;
-}
-#else
-__ai float64x1_t vget_high_f64(float64x2_t __p0) {
- float64x1_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 1);
- return __ret;
-}
-#endif
-
-#define vget_lane_p64(__p0, __p1) __extension__ ({ \
- poly64_t __ret; \
- poly64x1_t __s0 = __p0; \
- __ret = (poly64_t) __builtin_neon_vget_lane_i64((poly64x1_t)__s0, __p1); \
- __ret; \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vgetq_lane_p64(__p0, __p1) __extension__ ({ \
- poly64_t __ret; \
- poly64x2_t __s0 = __p0; \
- __ret = (poly64_t) __builtin_neon_vgetq_lane_i64((poly64x2_t)__s0, __p1); \
+#define vdupb_lane_p8(__p0, __p1) __extension__ ({ \
+ poly8_t __ret; \
+ poly8x8_t __s0 = __p0; \
+ __ret = (poly8_t) __builtin_neon_vdupb_lane_i8((poly8x8_t)__s0, __p1); \
__ret; \
})
#else
-#define vgetq_lane_p64(__p0, __p1) __extension__ ({ \
- poly64_t __ret; \
- poly64x2_t __s0 = __p0; \
- poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (poly64_t) __builtin_neon_vgetq_lane_i64((poly64x2_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vgetq_lane_p64(__p0, __p1) __extension__ ({ \
- poly64_t __ret; \
- poly64x2_t __s0 = __p0; \
- __ret = (poly64_t) __builtin_neon_vgetq_lane_i64((poly64x2_t)__s0, __p1); \
+#define vdupb_lane_p8(__p0, __p1) __extension__ ({ \
+ poly8_t __ret; \
+ poly8x8_t __s0 = __p0; \
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly8_t) __builtin_neon_vdupb_lane_i8((poly8x8_t)__rev0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vgetq_lane_f64(__p0, __p1) __extension__ ({ \
- float64_t __ret; \
- float64x2_t __s0 = __p0; \
- __ret = (float64_t) __builtin_neon_vgetq_lane_f64((float64x2_t)__s0, __p1); \
+#define vduph_lane_p16(__p0, __p1) __extension__ ({ \
+ poly16_t __ret; \
+ poly16x4_t __s0 = __p0; \
+ __ret = (poly16_t) __builtin_neon_vduph_lane_i16((poly16x4_t)__s0, __p1); \
__ret; \
})
#else
-#define vgetq_lane_f64(__p0, __p1) __extension__ ({ \
- float64_t __ret; \
- float64x2_t __s0 = __p0; \
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- __ret = (float64_t) __builtin_neon_vgetq_lane_f64((float64x2_t)__rev0, __p1); \
- __ret; \
-})
-#define __noswap_vgetq_lane_f64(__p0, __p1) __extension__ ({ \
- float64_t __ret; \
- float64x2_t __s0 = __p0; \
- __ret = (float64_t) __builtin_neon_vgetq_lane_f64((float64x2_t)__s0, __p1); \
+#define vduph_lane_p16(__p0, __p1) __extension__ ({ \
+ poly16_t __ret; \
+ poly16x4_t __s0 = __p0; \
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (poly16_t) __builtin_neon_vduph_lane_i16((poly16x4_t)__rev0, __p1); \
__ret; \
})
#endif
-#define vget_lane_f64(__p0, __p1) __extension__ ({ \
- float64_t __ret; \
- float64x1_t __s0 = __p0; \
- __ret = (float64_t) __builtin_neon_vget_lane_f64((float64x1_t)__s0, __p1); \
+#ifdef __LITTLE_ENDIAN__
+#define vdupb_lane_u8(__p0, __p1) __extension__ ({ \
+ uint8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ __ret = (uint8_t) __builtin_neon_vdupb_lane_i8((int8x8_t)__s0, __p1); \
__ret; \
})
-#ifdef __LITTLE_ENDIAN__
-__ai poly64x1_t vget_low_p64(poly64x2_t __p0) {
- poly64x1_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 0);
- return __ret;
-}
#else
-__ai poly64x1_t vget_low_p64(poly64x2_t __p0) {
- poly64x1_t __ret;
- poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 0);
- return __ret;
-}
+#define vdupb_lane_u8(__p0, __p1) __extension__ ({ \
+ uint8_t __ret; \
+ uint8x8_t __s0 = __p0; \
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8_t) __builtin_neon_vdupb_lane_i8((int8x8_t)__rev0, __p1); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x1_t vget_low_f64(float64x2_t __p0) {
- float64x1_t __ret;
- __ret = __builtin_shufflevector(__p0, __p0, 0);
- return __ret;
-}
+#define vdups_lane_u32(__p0, __p1) __extension__ ({ \
+ uint32_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ __ret = (uint32_t) __builtin_neon_vdups_lane_i32((int32x2_t)__s0, __p1); \
+ __ret; \
+})
#else
-__ai float64x1_t vget_low_f64(float64x2_t __p0) {
- float64x1_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev0, 0);
- return __ret;
-}
+#define vdups_lane_u32(__p0, __p1) __extension__ ({ \
+ uint32_t __ret; \
+ uint32x2_t __s0 = __p0; \
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint32_t) __builtin_neon_vdups_lane_i32((int32x2_t)__rev0, __p1); \
+ __ret; \
+})
#endif
-#define vld1_p64(__p0) __extension__ ({ \
- poly64x1_t __ret; \
- __ret = (poly64x1_t) __builtin_neon_vld1_v(__p0, 6); \
+#define vdupd_lane_u64(__p0, __p1) __extension__ ({ \
+ uint64_t __ret; \
+ uint64x1_t __s0 = __p0; \
+ __ret = (uint64_t) __builtin_neon_vdupd_lane_i64((int64x1_t)__s0, __p1); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vld1q_p64(__p0) __extension__ ({ \
- poly64x2_t __ret; \
- __ret = (poly64x2_t) __builtin_neon_vld1q_v(__p0, 38); \
+#define vduph_lane_u16(__p0, __p1) __extension__ ({ \
+ uint16_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ __ret = (uint16_t) __builtin_neon_vduph_lane_i16((int16x4_t)__s0, __p1); \
__ret; \
})
#else
-#define vld1q_p64(__p0) __extension__ ({ \
- poly64x2_t __ret; \
- __ret = (poly64x2_t) __builtin_neon_vld1q_v(__p0, 38); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+#define vduph_lane_u16(__p0, __p1) __extension__ ({ \
+ uint16_t __ret; \
+ uint16x4_t __s0 = __p0; \
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint16_t) __builtin_neon_vduph_lane_i16((int16x4_t)__rev0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_f64(__p0) __extension__ ({ \
- float64x2_t __ret; \
- __ret = (float64x2_t) __builtin_neon_vld1q_v(__p0, 42); \
+#define vdupb_lane_s8(__p0, __p1) __extension__ ({ \
+ int8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ __ret = (int8_t) __builtin_neon_vdupb_lane_i8((int8x8_t)__s0, __p1); \
__ret; \
})
#else
-#define vld1q_f64(__p0) __extension__ ({ \
- float64x2_t __ret; \
- __ret = (float64x2_t) __builtin_neon_vld1q_v(__p0, 42); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+#define vdupb_lane_s8(__p0, __p1) __extension__ ({ \
+ int8_t __ret; \
+ int8x8_t __s0 = __p0; \
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8_t) __builtin_neon_vdupb_lane_i8((int8x8_t)__rev0, __p1); \
__ret; \
})
#endif
-#define vld1_f64(__p0) __extension__ ({ \
- float64x1_t __ret; \
- __ret = (float64x1_t) __builtin_neon_vld1_v(__p0, 10); \
- __ret; \
-})
-#define vld1_dup_p64(__p0) __extension__ ({ \
- poly64x1_t __ret; \
- __ret = (poly64x1_t) __builtin_neon_vld1_dup_v(__p0, 6); \
+#define vdupd_lane_f64(__p0, __p1) __extension__ ({ \
+ float64_t __ret; \
+ float64x1_t __s0 = __p0; \
+ __ret = (float64_t) __builtin_neon_vdupd_lane_f64((float64x1_t)__s0, __p1); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vld1q_dup_p64(__p0) __extension__ ({ \
- poly64x2_t __ret; \
- __ret = (poly64x2_t) __builtin_neon_vld1q_dup_v(__p0, 38); \
+#define vdups_lane_f32(__p0, __p1) __extension__ ({ \
+ float32_t __ret; \
+ float32x2_t __s0 = __p0; \
+ __ret = (float32_t) __builtin_neon_vdups_lane_f32((float32x2_t)__s0, __p1); \
__ret; \
})
#else
-#define vld1q_dup_p64(__p0) __extension__ ({ \
- poly64x2_t __ret; \
- __ret = (poly64x2_t) __builtin_neon_vld1q_dup_v(__p0, 38); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+#define vdups_lane_f32(__p0, __p1) __extension__ ({ \
+ float32_t __ret; \
+ float32x2_t __s0 = __p0; \
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (float32_t) __builtin_neon_vdups_lane_f32((float32x2_t)__rev0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_dup_f64(__p0) __extension__ ({ \
- float64x2_t __ret; \
- __ret = (float64x2_t) __builtin_neon_vld1q_dup_v(__p0, 42); \
+#define vdups_lane_s32(__p0, __p1) __extension__ ({ \
+ int32_t __ret; \
+ int32x2_t __s0 = __p0; \
+ __ret = (int32_t) __builtin_neon_vdups_lane_i32((int32x2_t)__s0, __p1); \
__ret; \
})
#else
-#define vld1q_dup_f64(__p0) __extension__ ({ \
- float64x2_t __ret; \
- __ret = (float64x2_t) __builtin_neon_vld1q_dup_v(__p0, 42); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+#define vdups_lane_s32(__p0, __p1) __extension__ ({ \
+ int32_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (int32_t) __builtin_neon_vdups_lane_i32((int32x2_t)__rev0, __p1); \
__ret; \
})
#endif
-#define vld1_dup_f64(__p0) __extension__ ({ \
- float64x1_t __ret; \
- __ret = (float64x1_t) __builtin_neon_vld1_dup_v(__p0, 10); \
- __ret; \
-})
-#define vld1_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x1_t __ret; \
- poly64x1_t __s1 = __p1; \
- __ret = (poly64x1_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 6); \
+#define vdupd_lane_s64(__p0, __p1) __extension__ ({ \
+ int64_t __ret; \
+ int64x1_t __s0 = __p0; \
+ __ret = (int64_t) __builtin_neon_vdupd_lane_i64((int64x1_t)__s0, __p1); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vld1q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2_t __ret; \
- poly64x2_t __s1 = __p1; \
- __ret = (poly64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 38); \
+#define vduph_lane_s16(__p0, __p1) __extension__ ({ \
+ int16_t __ret; \
+ int16x4_t __s0 = __p0; \
+ __ret = (int16_t) __builtin_neon_vduph_lane_i16((int16x4_t)__s0, __p1); \
__ret; \
})
#else
-#define vld1q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2_t __ret; \
- poly64x2_t __s1 = __p1; \
- poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (poly64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 38); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+#define vduph_lane_s16(__p0, __p1) __extension__ ({ \
+ int16_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (int16_t) __builtin_neon_vduph_lane_i16((int16x4_t)__rev0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2_t __ret; \
- float64x2_t __s1 = __p1; \
- __ret = (float64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 42); \
+#define vduph_lane_f16(__p0, __p1) __extension__ ({ \
+ float16_t __ret; \
+ float16x4_t __s0 = __p0; \
+ __ret = (float16_t) __builtin_neon_vduph_lane_f16((float16x4_t)__s0, __p1); \
__ret; \
})
#else
-#define vld1q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2_t __ret; \
- float64x2_t __s1 = __p1; \
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (float64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 42); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+#define vduph_lane_f16(__p0, __p1) __extension__ ({ \
+ float16_t __ret; \
+ float16x4_t __s0 = __p0; \
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (float16_t) __builtin_neon_vduph_lane_f16((float16x4_t)__rev0, __p1); \
__ret; \
})
#endif
-#define vld1_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x1_t __ret; \
- float64x1_t __s1 = __p1; \
- __ret = (float64x1_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 10); \
- __ret; \
-})
-#define vld1_p64_x2(__p0) __extension__ ({ \
- poly64x1x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 6); \
- __ret; \
+#define vdup_lane_p64(__p0_364, __p1_364) __extension__ ({ \
+ poly64x1_t __ret_364; \
+ poly64x1_t __s0_364 = __p0_364; \
+ __ret_364 = splat_lane_p64(__s0_364, __p1_364); \
+ __ret_364; \
})
#ifdef __LITTLE_ENDIAN__
-#define vld1q_p64_x2(__p0) __extension__ ({ \
- poly64x2x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 38); \
- __ret; \
+#define vdupq_lane_p64(__p0_365, __p1_365) __extension__ ({ \
+ poly64x2_t __ret_365; \
+ poly64x1_t __s0_365 = __p0_365; \
+ __ret_365 = splatq_lane_p64(__s0_365, __p1_365); \
+ __ret_365; \
})
#else
-#define vld1q_p64_x2(__p0) __extension__ ({ \
- poly64x2x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 38); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret; \
+#define vdupq_lane_p64(__p0_366, __p1_366) __extension__ ({ \
+ poly64x2_t __ret_366; \
+ poly64x1_t __s0_366 = __p0_366; \
+ __ret_366 = __noswap_splatq_lane_p64(__s0_366, __p1_366); \
+ __ret_366 = __builtin_shufflevector(__ret_366, __ret_366, 1, 0); \
+ __ret_366; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_f64_x2(__p0) __extension__ ({ \
- float64x2x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 42); \
- __ret; \
+#define vdupq_lane_f64(__p0_367, __p1_367) __extension__ ({ \
+ float64x2_t __ret_367; \
+ float64x1_t __s0_367 = __p0_367; \
+ __ret_367 = splatq_lane_f64(__s0_367, __p1_367); \
+ __ret_367; \
})
#else
-#define vld1q_f64_x2(__p0) __extension__ ({ \
- float64x2x2_t __ret; \
- __builtin_neon_vld1q_x2_v(&__ret, __p0, 42); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret; \
+#define vdupq_lane_f64(__p0_368, __p1_368) __extension__ ({ \
+ float64x2_t __ret_368; \
+ float64x1_t __s0_368 = __p0_368; \
+ __ret_368 = __noswap_splatq_lane_f64(__s0_368, __p1_368); \
+ __ret_368 = __builtin_shufflevector(__ret_368, __ret_368, 1, 0); \
+ __ret_368; \
})
#endif
-#define vld1_f64_x2(__p0) __extension__ ({ \
- float64x1x2_t __ret; \
- __builtin_neon_vld1_x2_v(&__ret, __p0, 10); \
- __ret; \
-})
-#define vld1_p64_x3(__p0) __extension__ ({ \
- poly64x1x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 6); \
- __ret; \
+#define vdup_lane_f64(__p0_369, __p1_369) __extension__ ({ \
+ float64x1_t __ret_369; \
+ float64x1_t __s0_369 = __p0_369; \
+ __ret_369 = splat_lane_f64(__s0_369, __p1_369); \
+ __ret_369; \
})
#ifdef __LITTLE_ENDIAN__
-#define vld1q_p64_x3(__p0) __extension__ ({ \
- poly64x2x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 38); \
+#define vdupb_laneq_p8(__p0, __p1) __extension__ ({ \
+ poly8_t __ret; \
+ poly8x16_t __s0 = __p0; \
+ __ret = (poly8_t) __builtin_neon_vdupb_laneq_i8((poly8x16_t)__s0, __p1); \
__ret; \
})
#else
-#define vld1q_p64_x3(__p0) __extension__ ({ \
- poly64x2x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 38); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+#define vdupb_laneq_p8(__p0, __p1) __extension__ ({ \
+ poly8_t __ret; \
+ poly8x16_t __s0 = __p0; \
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly8_t) __builtin_neon_vdupb_laneq_i8((poly8x16_t)__rev0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_f64_x3(__p0) __extension__ ({ \
- float64x2x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 42); \
+#define vduph_laneq_p16(__p0, __p1) __extension__ ({ \
+ poly16_t __ret; \
+ poly16x8_t __s0 = __p0; \
+ __ret = (poly16_t) __builtin_neon_vduph_laneq_i16((poly16x8_t)__s0, __p1); \
__ret; \
})
#else
-#define vld1q_f64_x3(__p0) __extension__ ({ \
- float64x2x3_t __ret; \
- __builtin_neon_vld1q_x3_v(&__ret, __p0, 42); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+#define vduph_laneq_p16(__p0, __p1) __extension__ ({ \
+ poly16_t __ret; \
+ poly16x8_t __s0 = __p0; \
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (poly16_t) __builtin_neon_vduph_laneq_i16((poly16x8_t)__rev0, __p1); \
__ret; \
})
#endif
-#define vld1_f64_x3(__p0) __extension__ ({ \
- float64x1x3_t __ret; \
- __builtin_neon_vld1_x3_v(&__ret, __p0, 10); \
+#ifdef __LITTLE_ENDIAN__
+#define vdupb_laneq_u8(__p0, __p1) __extension__ ({ \
+ uint8_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ __ret = (uint8_t) __builtin_neon_vdupb_laneq_i8((int8x16_t)__s0, __p1); \
__ret; \
})
-#define vld1_p64_x4(__p0) __extension__ ({ \
- poly64x1x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 6); \
+#else
+#define vdupb_laneq_u8(__p0, __p1) __extension__ ({ \
+ uint8_t __ret; \
+ uint8x16_t __s0 = __p0; \
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint8_t) __builtin_neon_vdupb_laneq_i8((int8x16_t)__rev0, __p1); \
__ret; \
})
+#endif
+
#ifdef __LITTLE_ENDIAN__
-#define vld1q_p64_x4(__p0) __extension__ ({ \
- poly64x2x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 38); \
+#define vdups_laneq_u32(__p0, __p1) __extension__ ({ \
+ uint32_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ __ret = (uint32_t) __builtin_neon_vdups_laneq_i32((int32x4_t)__s0, __p1); \
__ret; \
})
#else
-#define vld1q_p64_x4(__p0) __extension__ ({ \
- poly64x2x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 38); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+#define vdups_laneq_u32(__p0, __p1) __extension__ ({ \
+ uint32_t __ret; \
+ uint32x4_t __s0 = __p0; \
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (uint32_t) __builtin_neon_vdups_laneq_i32((int32x4_t)__rev0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld1q_f64_x4(__p0) __extension__ ({ \
- float64x2x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 42); \
+#define vdupd_laneq_u64(__p0, __p1) __extension__ ({ \
+ uint64_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ __ret = (uint64_t) __builtin_neon_vdupd_laneq_i64((int64x2_t)__s0, __p1); \
__ret; \
})
#else
-#define vld1q_f64_x4(__p0) __extension__ ({ \
- float64x2x4_t __ret; \
- __builtin_neon_vld1q_x4_v(&__ret, __p0, 42); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+#define vdupd_laneq_u64(__p0, __p1) __extension__ ({ \
+ uint64_t __ret; \
+ uint64x2_t __s0 = __p0; \
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (uint64_t) __builtin_neon_vdupd_laneq_i64((int64x2_t)__rev0, __p1); \
__ret; \
})
#endif
-#define vld1_f64_x4(__p0) __extension__ ({ \
- float64x1x4_t __ret; \
- __builtin_neon_vld1_x4_v(&__ret, __p0, 10); \
+#ifdef __LITTLE_ENDIAN__
+#define vduph_laneq_u16(__p0, __p1) __extension__ ({ \
+ uint16_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ __ret = (uint16_t) __builtin_neon_vduph_laneq_i16((int16x8_t)__s0, __p1); \
__ret; \
})
-#define vld2_p64(__p0) __extension__ ({ \
- poly64x1x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 6); \
+#else
+#define vduph_laneq_u16(__p0, __p1) __extension__ ({ \
+ uint16_t __ret; \
+ uint16x8_t __s0 = __p0; \
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (uint16_t) __builtin_neon_vduph_laneq_i16((int16x8_t)__rev0, __p1); \
__ret; \
})
+#endif
+
#ifdef __LITTLE_ENDIAN__
-#define vld2q_p64(__p0) __extension__ ({ \
- poly64x2x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 38); \
+#define vdupb_laneq_s8(__p0, __p1) __extension__ ({ \
+ int8_t __ret; \
+ int8x16_t __s0 = __p0; \
+ __ret = (int8_t) __builtin_neon_vdupb_laneq_i8((int8x16_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2q_p64(__p0) __extension__ ({ \
- poly64x2x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 38); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+#define vdupb_laneq_s8(__p0, __p1) __extension__ ({ \
+ int8_t __ret; \
+ int8x16_t __s0 = __p0; \
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int8_t) __builtin_neon_vdupb_laneq_i8((int8x16_t)__rev0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_u64(__p0) __extension__ ({ \
- uint64x2x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 51); \
+#define vdupd_laneq_f64(__p0, __p1) __extension__ ({ \
+ float64_t __ret; \
+ float64x2_t __s0 = __p0; \
+ __ret = (float64_t) __builtin_neon_vdupd_laneq_f64((float64x2_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2q_u64(__p0) __extension__ ({ \
- uint64x2x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 51); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+#define vdupd_laneq_f64(__p0, __p1) __extension__ ({ \
+ float64_t __ret; \
+ float64x2_t __s0 = __p0; \
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (float64_t) __builtin_neon_vdupd_laneq_f64((float64x2_t)__rev0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_f64(__p0) __extension__ ({ \
- float64x2x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 42); \
+#define vdups_laneq_f32(__p0, __p1) __extension__ ({ \
+ float32_t __ret; \
+ float32x4_t __s0 = __p0; \
+ __ret = (float32_t) __builtin_neon_vdups_laneq_f32((float32x4_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2q_f64(__p0) __extension__ ({ \
- float64x2x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 42); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+#define vdups_laneq_f32(__p0, __p1) __extension__ ({ \
+ float32_t __ret; \
+ float32x4_t __s0 = __p0; \
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (float32_t) __builtin_neon_vdups_laneq_f32((float32x4_t)__rev0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_s64(__p0) __extension__ ({ \
- int64x2x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 35); \
+#define vdups_laneq_s32(__p0, __p1) __extension__ ({ \
+ int32_t __ret; \
+ int32x4_t __s0 = __p0; \
+ __ret = (int32_t) __builtin_neon_vdups_laneq_i32((int32x4_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2q_s64(__p0) __extension__ ({ \
- int64x2x2_t __ret; \
- __builtin_neon_vld2q_v(&__ret, __p0, 35); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+#define vdups_laneq_s32(__p0, __p1) __extension__ ({ \
+ int32_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ __ret = (int32_t) __builtin_neon_vdups_laneq_i32((int32x4_t)__rev0, __p1); \
__ret; \
})
#endif
-#define vld2_f64(__p0) __extension__ ({ \
- float64x1x2_t __ret; \
- __builtin_neon_vld2_v(&__ret, __p0, 10); \
+#ifdef __LITTLE_ENDIAN__
+#define vdupd_laneq_s64(__p0, __p1) __extension__ ({ \
+ int64_t __ret; \
+ int64x2_t __s0 = __p0; \
+ __ret = (int64_t) __builtin_neon_vdupd_laneq_i64((int64x2_t)__s0, __p1); \
__ret; \
})
-#define vld2_dup_p64(__p0) __extension__ ({ \
- poly64x1x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 6); \
+#else
+#define vdupd_laneq_s64(__p0, __p1) __extension__ ({ \
+ int64_t __ret; \
+ int64x2_t __s0 = __p0; \
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (int64_t) __builtin_neon_vdupd_laneq_i64((int64x2_t)__rev0, __p1); \
__ret; \
})
+#endif
+
#ifdef __LITTLE_ENDIAN__
-#define vld2q_dup_p64(__p0) __extension__ ({ \
- poly64x2x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 38); \
+#define vduph_laneq_s16(__p0, __p1) __extension__ ({ \
+ int16_t __ret; \
+ int16x8_t __s0 = __p0; \
+ __ret = (int16_t) __builtin_neon_vduph_laneq_i16((int16x8_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2q_dup_p64(__p0) __extension__ ({ \
- poly64x2x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 38); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+#define vduph_laneq_s16(__p0, __p1) __extension__ ({ \
+ int16_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int16_t) __builtin_neon_vduph_laneq_i16((int16x8_t)__rev0, __p1); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_dup_f64(__p0) __extension__ ({ \
- float64x2x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 42); \
+#define vduph_laneq_f16(__p0, __p1) __extension__ ({ \
+ float16_t __ret; \
+ float16x8_t __s0 = __p0; \
+ __ret = (float16_t) __builtin_neon_vduph_laneq_f16((float16x8_t)__s0, __p1); \
__ret; \
})
#else
-#define vld2q_dup_f64(__p0) __extension__ ({ \
- float64x2x2_t __ret; \
- __builtin_neon_vld2q_dup_v(&__ret, __p0, 42); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+#define vduph_laneq_f16(__p0, __p1) __extension__ ({ \
+ float16_t __ret; \
+ float16x8_t __s0 = __p0; \
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (float16_t) __builtin_neon_vduph_laneq_f16((float16x8_t)__rev0, __p1); \
__ret; \
})
#endif
-#define vld2_dup_f64(__p0) __extension__ ({ \
- float64x1x2_t __ret; \
- __builtin_neon_vld2_dup_v(&__ret, __p0, 10); \
- __ret; \
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_p8(__p0_370, __p1_370) __extension__ ({ \
+ poly8x8_t __ret_370; \
+ poly8x16_t __s0_370 = __p0_370; \
+ __ret_370 = splat_laneq_p8(__s0_370, __p1_370); \
+ __ret_370; \
})
-#define vld2_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x1x2_t __ret; \
- poly64x1x2_t __s1 = __p1; \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 6); \
- __ret; \
+#else
+#define vdup_laneq_p8(__p0_371, __p1_371) __extension__ ({ \
+ poly8x8_t __ret_371; \
+ poly8x16_t __s0_371 = __p0_371; \
+ poly8x16_t __rev0_371; __rev0_371 = __builtin_shufflevector(__s0_371, __s0_371, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_371 = __noswap_splat_laneq_p8(__rev0_371, __p1_371); \
+ __ret_371 = __builtin_shufflevector(__ret_371, __ret_371, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_371; \
})
+#endif
+
#ifdef __LITTLE_ENDIAN__
-#define vld2q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16x2_t __ret; \
- poly8x16x2_t __s1 = __p1; \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 36); \
- __ret; \
+#define vdup_laneq_p64(__p0_372, __p1_372) __extension__ ({ \
+ poly64x1_t __ret_372; \
+ poly64x2_t __s0_372 = __p0_372; \
+ __ret_372 = splat_laneq_p64(__s0_372, __p1_372); \
+ __ret_372; \
})
#else
-#define vld2q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16x2_t __ret; \
- poly8x16x2_t __s1 = __p1; \
- poly8x16x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 36); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vdup_laneq_p64(__p0_373, __p1_373) __extension__ ({ \
+ poly64x1_t __ret_373; \
+ poly64x2_t __s0_373 = __p0_373; \
+ poly64x2_t __rev0_373; __rev0_373 = __builtin_shufflevector(__s0_373, __s0_373, 1, 0); \
+ __ret_373 = __noswap_splat_laneq_p64(__rev0_373, __p1_373); \
+ __ret_373; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2x2_t __ret; \
- poly64x2x2_t __s1 = __p1; \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 38); \
- __ret; \
+#define vdup_laneq_p16(__p0_374, __p1_374) __extension__ ({ \
+ poly16x4_t __ret_374; \
+ poly16x8_t __s0_374 = __p0_374; \
+ __ret_374 = splat_laneq_p16(__s0_374, __p1_374); \
+ __ret_374; \
})
#else
-#define vld2q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2x2_t __ret; \
- poly64x2x2_t __s1 = __p1; \
- poly64x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 38); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret; \
+#define vdup_laneq_p16(__p0_375, __p1_375) __extension__ ({ \
+ poly16x4_t __ret_375; \
+ poly16x8_t __s0_375 = __p0_375; \
+ poly16x8_t __rev0_375; __rev0_375 = __builtin_shufflevector(__s0_375, __s0_375, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_375 = __noswap_splat_laneq_p16(__rev0_375, __p1_375); \
+ __ret_375 = __builtin_shufflevector(__ret_375, __ret_375, 3, 2, 1, 0); \
+ __ret_375; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16x2_t __ret; \
- uint8x16x2_t __s1 = __p1; \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 48); \
- __ret; \
+#define vdupq_laneq_p8(__p0_376, __p1_376) __extension__ ({ \
+ poly8x16_t __ret_376; \
+ poly8x16_t __s0_376 = __p0_376; \
+ __ret_376 = splatq_laneq_p8(__s0_376, __p1_376); \
+ __ret_376; \
})
#else
-#define vld2q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16x2_t __ret; \
- uint8x16x2_t __s1 = __p1; \
- uint8x16x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 48); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vdupq_laneq_p8(__p0_377, __p1_377) __extension__ ({ \
+ poly8x16_t __ret_377; \
+ poly8x16_t __s0_377 = __p0_377; \
+ poly8x16_t __rev0_377; __rev0_377 = __builtin_shufflevector(__s0_377, __s0_377, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_377 = __noswap_splatq_laneq_p8(__rev0_377, __p1_377); \
+ __ret_377 = __builtin_shufflevector(__ret_377, __ret_377, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_377; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2x2_t __ret; \
- uint64x2x2_t __s1 = __p1; \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 51); \
- __ret; \
+#define vdupq_laneq_p64(__p0_378, __p1_378) __extension__ ({ \
+ poly64x2_t __ret_378; \
+ poly64x2_t __s0_378 = __p0_378; \
+ __ret_378 = splatq_laneq_p64(__s0_378, __p1_378); \
+ __ret_378; \
})
#else
-#define vld2q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2x2_t __ret; \
- uint64x2x2_t __s1 = __p1; \
- uint64x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 51); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret; \
+#define vdupq_laneq_p64(__p0_379, __p1_379) __extension__ ({ \
+ poly64x2_t __ret_379; \
+ poly64x2_t __s0_379 = __p0_379; \
+ poly64x2_t __rev0_379; __rev0_379 = __builtin_shufflevector(__s0_379, __s0_379, 1, 0); \
+ __ret_379 = __noswap_splatq_laneq_p64(__rev0_379, __p1_379); \
+ __ret_379 = __builtin_shufflevector(__ret_379, __ret_379, 1, 0); \
+ __ret_379; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16x2_t __ret; \
- int8x16x2_t __s1 = __p1; \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 32); \
- __ret; \
+#define vdupq_laneq_p16(__p0_380, __p1_380) __extension__ ({ \
+ poly16x8_t __ret_380; \
+ poly16x8_t __s0_380 = __p0_380; \
+ __ret_380 = splatq_laneq_p16(__s0_380, __p1_380); \
+ __ret_380; \
})
#else
-#define vld2q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16x2_t __ret; \
- int8x16x2_t __s1 = __p1; \
- int8x16x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 32); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vdupq_laneq_p16(__p0_381, __p1_381) __extension__ ({ \
+ poly16x8_t __ret_381; \
+ poly16x8_t __s0_381 = __p0_381; \
+ poly16x8_t __rev0_381; __rev0_381 = __builtin_shufflevector(__s0_381, __s0_381, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_381 = __noswap_splatq_laneq_p16(__rev0_381, __p1_381); \
+ __ret_381 = __builtin_shufflevector(__ret_381, __ret_381, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_381; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2x2_t __ret; \
- float64x2x2_t __s1 = __p1; \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 42); \
- __ret; \
+#define vdupq_laneq_u8(__p0_382, __p1_382) __extension__ ({ \
+ uint8x16_t __ret_382; \
+ uint8x16_t __s0_382 = __p0_382; \
+ __ret_382 = splatq_laneq_u8(__s0_382, __p1_382); \
+ __ret_382; \
})
#else
-#define vld2q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2x2_t __ret; \
- float64x2x2_t __s1 = __p1; \
- float64x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 42); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret; \
+#define vdupq_laneq_u8(__p0_383, __p1_383) __extension__ ({ \
+ uint8x16_t __ret_383; \
+ uint8x16_t __s0_383 = __p0_383; \
+ uint8x16_t __rev0_383; __rev0_383 = __builtin_shufflevector(__s0_383, __s0_383, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_383 = __noswap_splatq_laneq_u8(__rev0_383, __p1_383); \
+ __ret_383 = __builtin_shufflevector(__ret_383, __ret_383, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_383; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld2q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2x2_t __ret; \
- int64x2x2_t __s1 = __p1; \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 35); \
- __ret; \
+#define vdupq_laneq_u32(__p0_384, __p1_384) __extension__ ({ \
+ uint32x4_t __ret_384; \
+ uint32x4_t __s0_384 = __p0_384; \
+ __ret_384 = splatq_laneq_u32(__s0_384, __p1_384); \
+ __ret_384; \
})
#else
-#define vld2q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2x2_t __ret; \
- int64x2x2_t __s1 = __p1; \
- int64x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 35); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret; \
+#define vdupq_laneq_u32(__p0_385, __p1_385) __extension__ ({ \
+ uint32x4_t __ret_385; \
+ uint32x4_t __s0_385 = __p0_385; \
+ uint32x4_t __rev0_385; __rev0_385 = __builtin_shufflevector(__s0_385, __s0_385, 3, 2, 1, 0); \
+ __ret_385 = __noswap_splatq_laneq_u32(__rev0_385, __p1_385); \
+ __ret_385 = __builtin_shufflevector(__ret_385, __ret_385, 3, 2, 1, 0); \
+ __ret_385; \
})
#endif
-#define vld2_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x1x2_t __ret; \
- uint64x1x2_t __s1 = __p1; \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 19); \
- __ret; \
-})
-#define vld2_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x1x2_t __ret; \
- float64x1x2_t __s1 = __p1; \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 10); \
- __ret; \
-})
-#define vld2_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x1x2_t __ret; \
- int64x1x2_t __s1 = __p1; \
- __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 3); \
- __ret; \
-})
-#define vld3_p64(__p0) __extension__ ({ \
- poly64x1x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 6); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vld3q_p64(__p0) __extension__ ({ \
- poly64x2x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 38); \
- __ret; \
+#define vdupq_laneq_u64(__p0_386, __p1_386) __extension__ ({ \
+ uint64x2_t __ret_386; \
+ uint64x2_t __s0_386 = __p0_386; \
+ __ret_386 = splatq_laneq_u64(__s0_386, __p1_386); \
+ __ret_386; \
})
#else
-#define vld3q_p64(__p0) __extension__ ({ \
- poly64x2x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 38); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret; \
+#define vdupq_laneq_u64(__p0_387, __p1_387) __extension__ ({ \
+ uint64x2_t __ret_387; \
+ uint64x2_t __s0_387 = __p0_387; \
+ uint64x2_t __rev0_387; __rev0_387 = __builtin_shufflevector(__s0_387, __s0_387, 1, 0); \
+ __ret_387 = __noswap_splatq_laneq_u64(__rev0_387, __p1_387); \
+ __ret_387 = __builtin_shufflevector(__ret_387, __ret_387, 1, 0); \
+ __ret_387; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_u64(__p0) __extension__ ({ \
- uint64x2x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 51); \
- __ret; \
+#define vdupq_laneq_u16(__p0_388, __p1_388) __extension__ ({ \
+ uint16x8_t __ret_388; \
+ uint16x8_t __s0_388 = __p0_388; \
+ __ret_388 = splatq_laneq_u16(__s0_388, __p1_388); \
+ __ret_388; \
})
#else
-#define vld3q_u64(__p0) __extension__ ({ \
- uint64x2x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 51); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret; \
+#define vdupq_laneq_u16(__p0_389, __p1_389) __extension__ ({ \
+ uint16x8_t __ret_389; \
+ uint16x8_t __s0_389 = __p0_389; \
+ uint16x8_t __rev0_389; __rev0_389 = __builtin_shufflevector(__s0_389, __s0_389, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_389 = __noswap_splatq_laneq_u16(__rev0_389, __p1_389); \
+ __ret_389 = __builtin_shufflevector(__ret_389, __ret_389, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_389; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_f64(__p0) __extension__ ({ \
- float64x2x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 42); \
- __ret; \
+#define vdupq_laneq_s8(__p0_390, __p1_390) __extension__ ({ \
+ int8x16_t __ret_390; \
+ int8x16_t __s0_390 = __p0_390; \
+ __ret_390 = splatq_laneq_s8(__s0_390, __p1_390); \
+ __ret_390; \
})
#else
-#define vld3q_f64(__p0) __extension__ ({ \
- float64x2x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 42); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret; \
+#define vdupq_laneq_s8(__p0_391, __p1_391) __extension__ ({ \
+ int8x16_t __ret_391; \
+ int8x16_t __s0_391 = __p0_391; \
+ int8x16_t __rev0_391; __rev0_391 = __builtin_shufflevector(__s0_391, __s0_391, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_391 = __noswap_splatq_laneq_s8(__rev0_391, __p1_391); \
+ __ret_391 = __builtin_shufflevector(__ret_391, __ret_391, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_391; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_s64(__p0) __extension__ ({ \
- int64x2x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 35); \
- __ret; \
+#define vdupq_laneq_f64(__p0_392, __p1_392) __extension__ ({ \
+ float64x2_t __ret_392; \
+ float64x2_t __s0_392 = __p0_392; \
+ __ret_392 = splatq_laneq_f64(__s0_392, __p1_392); \
+ __ret_392; \
})
#else
-#define vld3q_s64(__p0) __extension__ ({ \
- int64x2x3_t __ret; \
- __builtin_neon_vld3q_v(&__ret, __p0, 35); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret; \
+#define vdupq_laneq_f64(__p0_393, __p1_393) __extension__ ({ \
+ float64x2_t __ret_393; \
+ float64x2_t __s0_393 = __p0_393; \
+ float64x2_t __rev0_393; __rev0_393 = __builtin_shufflevector(__s0_393, __s0_393, 1, 0); \
+ __ret_393 = __noswap_splatq_laneq_f64(__rev0_393, __p1_393); \
+ __ret_393 = __builtin_shufflevector(__ret_393, __ret_393, 1, 0); \
+ __ret_393; \
})
#endif
-#define vld3_f64(__p0) __extension__ ({ \
- float64x1x3_t __ret; \
- __builtin_neon_vld3_v(&__ret, __p0, 10); \
- __ret; \
-})
-#define vld3_dup_p64(__p0) __extension__ ({ \
- poly64x1x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 6); \
- __ret; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vld3q_dup_p64(__p0) __extension__ ({ \
- poly64x2x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 38); \
- __ret; \
+#define vdupq_laneq_f32(__p0_394, __p1_394) __extension__ ({ \
+ float32x4_t __ret_394; \
+ float32x4_t __s0_394 = __p0_394; \
+ __ret_394 = splatq_laneq_f32(__s0_394, __p1_394); \
+ __ret_394; \
})
#else
-#define vld3q_dup_p64(__p0) __extension__ ({ \
- poly64x2x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 38); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret; \
+#define vdupq_laneq_f32(__p0_395, __p1_395) __extension__ ({ \
+ float32x4_t __ret_395; \
+ float32x4_t __s0_395 = __p0_395; \
+ float32x4_t __rev0_395; __rev0_395 = __builtin_shufflevector(__s0_395, __s0_395, 3, 2, 1, 0); \
+ __ret_395 = __noswap_splatq_laneq_f32(__rev0_395, __p1_395); \
+ __ret_395 = __builtin_shufflevector(__ret_395, __ret_395, 3, 2, 1, 0); \
+ __ret_395; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_dup_f64(__p0) __extension__ ({ \
- float64x2x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 42); \
- __ret; \
+#define vdupq_laneq_f16(__p0_396, __p1_396) __extension__ ({ \
+ float16x8_t __ret_396; \
+ float16x8_t __s0_396 = __p0_396; \
+ __ret_396 = splatq_laneq_f16(__s0_396, __p1_396); \
+ __ret_396; \
})
#else
-#define vld3q_dup_f64(__p0) __extension__ ({ \
- float64x2x3_t __ret; \
- __builtin_neon_vld3q_dup_v(&__ret, __p0, 42); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret; \
+#define vdupq_laneq_f16(__p0_397, __p1_397) __extension__ ({ \
+ float16x8_t __ret_397; \
+ float16x8_t __s0_397 = __p0_397; \
+ float16x8_t __rev0_397; __rev0_397 = __builtin_shufflevector(__s0_397, __s0_397, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_397 = __noswap_splatq_laneq_f16(__rev0_397, __p1_397); \
+ __ret_397 = __builtin_shufflevector(__ret_397, __ret_397, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_397; \
})
#endif
-#define vld3_dup_f64(__p0) __extension__ ({ \
- float64x1x3_t __ret; \
- __builtin_neon_vld3_dup_v(&__ret, __p0, 10); \
- __ret; \
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_laneq_s32(__p0_398, __p1_398) __extension__ ({ \
+ int32x4_t __ret_398; \
+ int32x4_t __s0_398 = __p0_398; \
+ __ret_398 = splatq_laneq_s32(__s0_398, __p1_398); \
+ __ret_398; \
})
-#define vld3_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x1x3_t __ret; \
- poly64x1x3_t __s1 = __p1; \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 6); \
- __ret; \
+#else
+#define vdupq_laneq_s32(__p0_399, __p1_399) __extension__ ({ \
+ int32x4_t __ret_399; \
+ int32x4_t __s0_399 = __p0_399; \
+ int32x4_t __rev0_399; __rev0_399 = __builtin_shufflevector(__s0_399, __s0_399, 3, 2, 1, 0); \
+ __ret_399 = __noswap_splatq_laneq_s32(__rev0_399, __p1_399); \
+ __ret_399 = __builtin_shufflevector(__ret_399, __ret_399, 3, 2, 1, 0); \
+ __ret_399; \
})
+#endif
+
#ifdef __LITTLE_ENDIAN__
-#define vld3q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16x3_t __ret; \
- poly8x16x3_t __s1 = __p1; \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 36); \
- __ret; \
+#define vdupq_laneq_s64(__p0_400, __p1_400) __extension__ ({ \
+ int64x2_t __ret_400; \
+ int64x2_t __s0_400 = __p0_400; \
+ __ret_400 = splatq_laneq_s64(__s0_400, __p1_400); \
+ __ret_400; \
})
#else
-#define vld3q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16x3_t __ret; \
- poly8x16x3_t __s1 = __p1; \
- poly8x16x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 36); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vdupq_laneq_s64(__p0_401, __p1_401) __extension__ ({ \
+ int64x2_t __ret_401; \
+ int64x2_t __s0_401 = __p0_401; \
+ int64x2_t __rev0_401; __rev0_401 = __builtin_shufflevector(__s0_401, __s0_401, 1, 0); \
+ __ret_401 = __noswap_splatq_laneq_s64(__rev0_401, __p1_401); \
+ __ret_401 = __builtin_shufflevector(__ret_401, __ret_401, 1, 0); \
+ __ret_401; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2x3_t __ret; \
- poly64x2x3_t __s1 = __p1; \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 38); \
- __ret; \
+#define vdupq_laneq_s16(__p0_402, __p1_402) __extension__ ({ \
+ int16x8_t __ret_402; \
+ int16x8_t __s0_402 = __p0_402; \
+ __ret_402 = splatq_laneq_s16(__s0_402, __p1_402); \
+ __ret_402; \
})
#else
-#define vld3q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2x3_t __ret; \
- poly64x2x3_t __s1 = __p1; \
- poly64x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 38); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret; \
+#define vdupq_laneq_s16(__p0_403, __p1_403) __extension__ ({ \
+ int16x8_t __ret_403; \
+ int16x8_t __s0_403 = __p0_403; \
+ int16x8_t __rev0_403; __rev0_403 = __builtin_shufflevector(__s0_403, __s0_403, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_403 = __noswap_splatq_laneq_s16(__rev0_403, __p1_403); \
+ __ret_403 = __builtin_shufflevector(__ret_403, __ret_403, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_403; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16x3_t __ret; \
- uint8x16x3_t __s1 = __p1; \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 48); \
- __ret; \
+#define vdup_laneq_u8(__p0_404, __p1_404) __extension__ ({ \
+ uint8x8_t __ret_404; \
+ uint8x16_t __s0_404 = __p0_404; \
+ __ret_404 = splat_laneq_u8(__s0_404, __p1_404); \
+ __ret_404; \
})
#else
-#define vld3q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16x3_t __ret; \
- uint8x16x3_t __s1 = __p1; \
- uint8x16x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 48); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vdup_laneq_u8(__p0_405, __p1_405) __extension__ ({ \
+ uint8x8_t __ret_405; \
+ uint8x16_t __s0_405 = __p0_405; \
+ uint8x16_t __rev0_405; __rev0_405 = __builtin_shufflevector(__s0_405, __s0_405, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_405 = __noswap_splat_laneq_u8(__rev0_405, __p1_405); \
+ __ret_405 = __builtin_shufflevector(__ret_405, __ret_405, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_405; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2x3_t __ret; \
- uint64x2x3_t __s1 = __p1; \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 51); \
- __ret; \
+#define vdup_laneq_u32(__p0_406, __p1_406) __extension__ ({ \
+ uint32x2_t __ret_406; \
+ uint32x4_t __s0_406 = __p0_406; \
+ __ret_406 = splat_laneq_u32(__s0_406, __p1_406); \
+ __ret_406; \
})
#else
-#define vld3q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2x3_t __ret; \
- uint64x2x3_t __s1 = __p1; \
- uint64x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 51); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret; \
+#define vdup_laneq_u32(__p0_407, __p1_407) __extension__ ({ \
+ uint32x2_t __ret_407; \
+ uint32x4_t __s0_407 = __p0_407; \
+ uint32x4_t __rev0_407; __rev0_407 = __builtin_shufflevector(__s0_407, __s0_407, 3, 2, 1, 0); \
+ __ret_407 = __noswap_splat_laneq_u32(__rev0_407, __p1_407); \
+ __ret_407 = __builtin_shufflevector(__ret_407, __ret_407, 1, 0); \
+ __ret_407; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16x3_t __ret; \
- int8x16x3_t __s1 = __p1; \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 32); \
- __ret; \
+#define vdup_laneq_u64(__p0_408, __p1_408) __extension__ ({ \
+ uint64x1_t __ret_408; \
+ uint64x2_t __s0_408 = __p0_408; \
+ __ret_408 = splat_laneq_u64(__s0_408, __p1_408); \
+ __ret_408; \
})
#else
-#define vld3q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16x3_t __ret; \
- int8x16x3_t __s1 = __p1; \
- int8x16x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 32); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vdup_laneq_u64(__p0_409, __p1_409) __extension__ ({ \
+ uint64x1_t __ret_409; \
+ uint64x2_t __s0_409 = __p0_409; \
+ uint64x2_t __rev0_409; __rev0_409 = __builtin_shufflevector(__s0_409, __s0_409, 1, 0); \
+ __ret_409 = __noswap_splat_laneq_u64(__rev0_409, __p1_409); \
+ __ret_409; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2x3_t __ret; \
- float64x2x3_t __s1 = __p1; \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 42); \
- __ret; \
+#define vdup_laneq_u16(__p0_410, __p1_410) __extension__ ({ \
+ uint16x4_t __ret_410; \
+ uint16x8_t __s0_410 = __p0_410; \
+ __ret_410 = splat_laneq_u16(__s0_410, __p1_410); \
+ __ret_410; \
})
#else
-#define vld3q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2x3_t __ret; \
- float64x2x3_t __s1 = __p1; \
- float64x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 42); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret; \
+#define vdup_laneq_u16(__p0_411, __p1_411) __extension__ ({ \
+ uint16x4_t __ret_411; \
+ uint16x8_t __s0_411 = __p0_411; \
+ uint16x8_t __rev0_411; __rev0_411 = __builtin_shufflevector(__s0_411, __s0_411, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_411 = __noswap_splat_laneq_u16(__rev0_411, __p1_411); \
+ __ret_411 = __builtin_shufflevector(__ret_411, __ret_411, 3, 2, 1, 0); \
+ __ret_411; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld3q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2x3_t __ret; \
- int64x2x3_t __s1 = __p1; \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 35); \
- __ret; \
+#define vdup_laneq_s8(__p0_412, __p1_412) __extension__ ({ \
+ int8x8_t __ret_412; \
+ int8x16_t __s0_412 = __p0_412; \
+ __ret_412 = splat_laneq_s8(__s0_412, __p1_412); \
+ __ret_412; \
})
#else
-#define vld3q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2x3_t __ret; \
- int64x2x3_t __s1 = __p1; \
- int64x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 35); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret; \
+#define vdup_laneq_s8(__p0_413, __p1_413) __extension__ ({ \
+ int8x8_t __ret_413; \
+ int8x16_t __s0_413 = __p0_413; \
+ int8x16_t __rev0_413; __rev0_413 = __builtin_shufflevector(__s0_413, __s0_413, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_413 = __noswap_splat_laneq_s8(__rev0_413, __p1_413); \
+ __ret_413 = __builtin_shufflevector(__ret_413, __ret_413, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_413; \
})
#endif
-#define vld3_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x1x3_t __ret; \
- uint64x1x3_t __s1 = __p1; \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 19); \
- __ret; \
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_f64(__p0_414, __p1_414) __extension__ ({ \
+ float64x1_t __ret_414; \
+ float64x2_t __s0_414 = __p0_414; \
+ __ret_414 = splat_laneq_f64(__s0_414, __p1_414); \
+ __ret_414; \
})
-#define vld3_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x1x3_t __ret; \
- float64x1x3_t __s1 = __p1; \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 10); \
- __ret; \
+#else
+#define vdup_laneq_f64(__p0_415, __p1_415) __extension__ ({ \
+ float64x1_t __ret_415; \
+ float64x2_t __s0_415 = __p0_415; \
+ float64x2_t __rev0_415; __rev0_415 = __builtin_shufflevector(__s0_415, __s0_415, 1, 0); \
+ __ret_415 = __noswap_splat_laneq_f64(__rev0_415, __p1_415); \
+ __ret_415; \
})
-#define vld3_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x1x3_t __ret; \
- int64x1x3_t __s1 = __p1; \
- __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 3); \
- __ret; \
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_f32(__p0_416, __p1_416) __extension__ ({ \
+ float32x2_t __ret_416; \
+ float32x4_t __s0_416 = __p0_416; \
+ __ret_416 = splat_laneq_f32(__s0_416, __p1_416); \
+ __ret_416; \
})
-#define vld4_p64(__p0) __extension__ ({ \
- poly64x1x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 6); \
- __ret; \
+#else
+#define vdup_laneq_f32(__p0_417, __p1_417) __extension__ ({ \
+ float32x2_t __ret_417; \
+ float32x4_t __s0_417 = __p0_417; \
+ float32x4_t __rev0_417; __rev0_417 = __builtin_shufflevector(__s0_417, __s0_417, 3, 2, 1, 0); \
+ __ret_417 = __noswap_splat_laneq_f32(__rev0_417, __p1_417); \
+ __ret_417 = __builtin_shufflevector(__ret_417, __ret_417, 1, 0); \
+ __ret_417; \
})
+#endif
+
#ifdef __LITTLE_ENDIAN__
-#define vld4q_p64(__p0) __extension__ ({ \
- poly64x2x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 38); \
- __ret; \
+#define vdup_laneq_f16(__p0_418, __p1_418) __extension__ ({ \
+ float16x4_t __ret_418; \
+ float16x8_t __s0_418 = __p0_418; \
+ __ret_418 = splat_laneq_f16(__s0_418, __p1_418); \
+ __ret_418; \
})
#else
-#define vld4q_p64(__p0) __extension__ ({ \
- poly64x2x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 38); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
- __ret; \
+#define vdup_laneq_f16(__p0_419, __p1_419) __extension__ ({ \
+ float16x4_t __ret_419; \
+ float16x8_t __s0_419 = __p0_419; \
+ float16x8_t __rev0_419; __rev0_419 = __builtin_shufflevector(__s0_419, __s0_419, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_419 = __noswap_splat_laneq_f16(__rev0_419, __p1_419); \
+ __ret_419 = __builtin_shufflevector(__ret_419, __ret_419, 3, 2, 1, 0); \
+ __ret_419; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_u64(__p0) __extension__ ({ \
- uint64x2x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 51); \
- __ret; \
+#define vdup_laneq_s32(__p0_420, __p1_420) __extension__ ({ \
+ int32x2_t __ret_420; \
+ int32x4_t __s0_420 = __p0_420; \
+ __ret_420 = splat_laneq_s32(__s0_420, __p1_420); \
+ __ret_420; \
})
#else
-#define vld4q_u64(__p0) __extension__ ({ \
- uint64x2x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 51); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
- __ret; \
+#define vdup_laneq_s32(__p0_421, __p1_421) __extension__ ({ \
+ int32x2_t __ret_421; \
+ int32x4_t __s0_421 = __p0_421; \
+ int32x4_t __rev0_421; __rev0_421 = __builtin_shufflevector(__s0_421, __s0_421, 3, 2, 1, 0); \
+ __ret_421 = __noswap_splat_laneq_s32(__rev0_421, __p1_421); \
+ __ret_421 = __builtin_shufflevector(__ret_421, __ret_421, 1, 0); \
+ __ret_421; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_f64(__p0) __extension__ ({ \
- float64x2x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 42); \
- __ret; \
+#define vdup_laneq_s64(__p0_422, __p1_422) __extension__ ({ \
+ int64x1_t __ret_422; \
+ int64x2_t __s0_422 = __p0_422; \
+ __ret_422 = splat_laneq_s64(__s0_422, __p1_422); \
+ __ret_422; \
})
#else
-#define vld4q_f64(__p0) __extension__ ({ \
- float64x2x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 42); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
- __ret; \
+#define vdup_laneq_s64(__p0_423, __p1_423) __extension__ ({ \
+ int64x1_t __ret_423; \
+ int64x2_t __s0_423 = __p0_423; \
+ int64x2_t __rev0_423; __rev0_423 = __builtin_shufflevector(__s0_423, __s0_423, 1, 0); \
+ __ret_423 = __noswap_splat_laneq_s64(__rev0_423, __p1_423); \
+ __ret_423; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_s64(__p0) __extension__ ({ \
- int64x2x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 35); \
- __ret; \
+#define vdup_laneq_s16(__p0_424, __p1_424) __extension__ ({ \
+ int16x4_t __ret_424; \
+ int16x8_t __s0_424 = __p0_424; \
+ __ret_424 = splat_laneq_s16(__s0_424, __p1_424); \
+ __ret_424; \
})
#else
-#define vld4q_s64(__p0) __extension__ ({ \
- int64x2x4_t __ret; \
- __builtin_neon_vld4q_v(&__ret, __p0, 35); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
- __ret; \
+#define vdup_laneq_s16(__p0_425, __p1_425) __extension__ ({ \
+ int16x4_t __ret_425; \
+ int16x8_t __s0_425 = __p0_425; \
+ int16x8_t __rev0_425; __rev0_425 = __builtin_shufflevector(__s0_425, __s0_425, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_425 = __noswap_splat_laneq_s16(__rev0_425, __p1_425); \
+ __ret_425 = __builtin_shufflevector(__ret_425, __ret_425, 3, 2, 1, 0); \
+ __ret_425; \
})
#endif
-#define vld4_f64(__p0) __extension__ ({ \
- float64x1x4_t __ret; \
- __builtin_neon_vld4_v(&__ret, __p0, 10); \
- __ret; \
-})
-#define vld4_dup_p64(__p0) __extension__ ({ \
- poly64x1x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 6); \
+__ai __attribute__((target("neon"))) poly64x1_t vdup_n_p64(poly64_t __p0) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t) {__p0};
+ return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly64x2_t vdupq_n_p64(poly64_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t) {__p0, __p0};
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly64x2_t vdupq_n_p64(poly64_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t) {__p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vdupq_n_f64(float64_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) {__p0, __p0};
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vdupq_n_f64(float64_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) {__p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vdup_n_f64(float64_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) {__p0};
+ return __ret;
+}
+#define vext_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x1_t __ret; \
+ poly64x1_t __s0 = __p0; \
+ poly64x1_t __s1 = __p1; \
+ __ret = (poly64x1_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 6); \
__ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vld4q_dup_p64(__p0) __extension__ ({ \
- poly64x2x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 38); \
+#define vextq_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2_t __ret; \
+ poly64x2_t __s0 = __p0; \
+ poly64x2_t __s1 = __p1; \
+ __ret = (poly64x2_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 38); \
__ret; \
})
#else
-#define vld4q_dup_p64(__p0) __extension__ ({ \
- poly64x2x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 38); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+#define vextq_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2_t __ret; \
+ poly64x2_t __s0 = __p0; \
+ poly64x2_t __s1 = __p1; \
+ poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (poly64x2_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 38); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_dup_f64(__p0) __extension__ ({ \
- float64x2x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 42); \
+#define vextq_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2_t __ret; \
+ float64x2_t __s0 = __p0; \
+ float64x2_t __s1 = __p1; \
+ __ret = (float64x2_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 42); \
__ret; \
})
#else
-#define vld4q_dup_f64(__p0) __extension__ ({ \
- float64x2x4_t __ret; \
- __builtin_neon_vld4q_dup_v(&__ret, __p0, 42); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+#define vextq_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2_t __ret; \
+ float64x2_t __s0 = __p0; \
+ float64x2_t __s1 = __p1; \
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (float64x2_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 42); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
__ret; \
})
#endif
-#define vld4_dup_f64(__p0) __extension__ ({ \
- float64x1x4_t __ret; \
- __builtin_neon_vld4_dup_v(&__ret, __p0, 10); \
+#define vext_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x1_t __ret; \
+ float64x1_t __s0 = __p0; \
+ float64x1_t __s1 = __p1; \
+ __ret = (float64x1_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 10); \
__ret; \
})
-#define vld4_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x1x4_t __ret; \
- poly64x1x4_t __s1 = __p1; \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 6); \
- __ret; \
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vfmaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vfmaq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vfmaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ float64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vfmaq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t __noswap_vfmaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vfmaq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
+ return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vfma_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vfma_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 10);
+ return __ret;
+}
+#define vfmad_lane_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float64_t __ret; \
+ float64_t __s0 = __p0; \
+ float64_t __s1 = __p1; \
+ float64x1_t __s2 = __p2; \
+ __ret = (float64_t) __builtin_neon_vfmad_lane_f64(__s0, __s1, (float64x1_t)__s2, __p3); \
+ __ret; \
})
#ifdef __LITTLE_ENDIAN__
-#define vld4q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16x4_t __ret; \
- poly8x16x4_t __s1 = __p1; \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 36); \
+#define vfmas_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float32_t __ret; \
+ float32_t __s0 = __p0; \
+ float32_t __s1 = __p1; \
+ float32x2_t __s2 = __p2; \
+ __ret = (float32_t) __builtin_neon_vfmas_lane_f32(__s0, __s1, (float32x2_t)__s2, __p3); \
__ret; \
})
#else
-#define vld4q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16x4_t __ret; \
- poly8x16x4_t __s1 = __p1; \
- poly8x16x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 36); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vfmas_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float32_t __ret; \
+ float32_t __s0 = __p0; \
+ float32_t __s1 = __p1; \
+ float32x2_t __s2 = __p2; \
+ float32x2_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
+ __ret = (float32_t) __builtin_neon_vfmas_lane_f32(__s0, __s1, (float32x2_t)__rev2, __p3); \
+ __ret; \
+})
+#define __noswap_vfmas_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float32_t __ret; \
+ float32_t __s0 = __p0; \
+ float32_t __s1 = __p1; \
+ float32x2_t __s2 = __p2; \
+ __ret = (float32_t) __builtin_neon_vfmas_lane_f32(__s0, __s1, (float32x2_t)__s2, __p3); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2x4_t __ret; \
- poly64x2x4_t __s1 = __p1; \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 38); \
+#define vfmaq_lane_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float64x2_t __ret; \
+ float64x2_t __s0 = __p0; \
+ float64x2_t __s1 = __p1; \
+ float64x1_t __s2 = __p2; \
+ __ret = (float64x2_t) __builtin_neon_vfmaq_lane_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x8_t)__s2, __p3, 42); \
__ret; \
})
#else
-#define vld4q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2x4_t __ret; \
- poly64x2x4_t __s1 = __p1; \
- poly64x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 38); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+#define vfmaq_lane_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float64x2_t __ret; \
+ float64x2_t __s0 = __p0; \
+ float64x2_t __s1 = __p1; \
+ float64x1_t __s2 = __p2; \
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (float64x2_t) __builtin_neon_vfmaq_lane_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x8_t)__s2, __p3, 42); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_vfmaq_lane_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float64x2_t __ret; \
+ float64x2_t __s0 = __p0; \
+ float64x2_t __s1 = __p1; \
+ float64x1_t __s2 = __p2; \
+ __ret = (float64x2_t) __builtin_neon_vfmaq_lane_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x8_t)__s2, __p3, 42); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16x4_t __ret; \
- uint8x16x4_t __s1 = __p1; \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 48); \
+#define vfmaq_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float32x4_t __ret; \
+ float32x4_t __s0 = __p0; \
+ float32x4_t __s1 = __p1; \
+ float32x2_t __s2 = __p2; \
+ __ret = (float32x4_t) __builtin_neon_vfmaq_lane_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x8_t)__s2, __p3, 41); \
__ret; \
})
#else
-#define vld4q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16x4_t __ret; \
- uint8x16x4_t __s1 = __p1; \
- uint8x16x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 48); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vfmaq_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float32x4_t __ret; \
+ float32x4_t __s0 = __p0; \
+ float32x4_t __s1 = __p1; \
+ float32x2_t __s2 = __p2; \
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ float32x2_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
+ __ret = (float32x4_t) __builtin_neon_vfmaq_lane_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x8_t)__rev2, __p3, 41); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#define __noswap_vfmaq_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float32x4_t __ret; \
+ float32x4_t __s0 = __p0; \
+ float32x4_t __s1 = __p1; \
+ float32x2_t __s2 = __p2; \
+ __ret = (float32x4_t) __builtin_neon_vfmaq_lane_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x8_t)__s2, __p3, 41); \
__ret; \
})
#endif
+#define vfma_lane_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float64x1_t __ret; \
+ float64x1_t __s0 = __p0; \
+ float64x1_t __s1 = __p1; \
+ float64x1_t __s2 = __p2; \
+ __ret = (float64x1_t) __builtin_neon_vfma_lane_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x8_t)__s2, __p3, 10); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vld4q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2x4_t __ret; \
- uint64x2x4_t __s1 = __p1; \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 51); \
+#define vfma_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float32x2_t __ret; \
+ float32x2_t __s0 = __p0; \
+ float32x2_t __s1 = __p1; \
+ float32x2_t __s2 = __p2; \
+ __ret = (float32x2_t) __builtin_neon_vfma_lane_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x8_t)__s2, __p3, 9); \
__ret; \
})
#else
-#define vld4q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2x4_t __ret; \
- uint64x2x4_t __s1 = __p1; \
- uint64x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 51); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+#define vfma_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float32x2_t __ret; \
+ float32x2_t __s0 = __p0; \
+ float32x2_t __s1 = __p1; \
+ float32x2_t __s2 = __p2; \
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ float32x2_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
+ __ret = (float32x2_t) __builtin_neon_vfma_lane_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, __p3, 9); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_vfma_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float32x2_t __ret; \
+ float32x2_t __s0 = __p0; \
+ float32x2_t __s1 = __p1; \
+ float32x2_t __s2 = __p2; \
+ __ret = (float32x2_t) __builtin_neon_vfma_lane_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x8_t)__s2, __p3, 9); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16x4_t __ret; \
- int8x16x4_t __s1 = __p1; \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 32); \
+#define vfmad_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float64_t __ret; \
+ float64_t __s0 = __p0; \
+ float64_t __s1 = __p1; \
+ float64x2_t __s2 = __p2; \
+ __ret = (float64_t) __builtin_neon_vfmad_laneq_f64(__s0, __s1, (float64x2_t)__s2, __p3); \
__ret; \
})
#else
-#define vld4q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16x4_t __ret; \
- int8x16x4_t __s1 = __p1; \
- int8x16x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 32); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+#define vfmad_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float64_t __ret; \
+ float64_t __s0 = __p0; \
+ float64_t __s1 = __p1; \
+ float64x2_t __s2 = __p2; \
+ float64x2_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
+ __ret = (float64_t) __builtin_neon_vfmad_laneq_f64(__s0, __s1, (float64x2_t)__rev2, __p3); \
+ __ret; \
+})
+#define __noswap_vfmad_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float64_t __ret; \
+ float64_t __s0 = __p0; \
+ float64_t __s1 = __p1; \
+ float64x2_t __s2 = __p2; \
+ __ret = (float64_t) __builtin_neon_vfmad_laneq_f64(__s0, __s1, (float64x2_t)__s2, __p3); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2x4_t __ret; \
- float64x2x4_t __s1 = __p1; \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 42); \
+#define vfmas_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float32_t __ret; \
+ float32_t __s0 = __p0; \
+ float32_t __s1 = __p1; \
+ float32x4_t __s2 = __p2; \
+ __ret = (float32_t) __builtin_neon_vfmas_laneq_f32(__s0, __s1, (float32x4_t)__s2, __p3); \
__ret; \
})
#else
-#define vld4q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2x4_t __ret; \
- float64x2x4_t __s1 = __p1; \
- float64x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 42); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+#define vfmas_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float32_t __ret; \
+ float32_t __s0 = __p0; \
+ float32_t __s1 = __p1; \
+ float32x4_t __s2 = __p2; \
+ float32x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+ __ret = (float32_t) __builtin_neon_vfmas_laneq_f32(__s0, __s1, (float32x4_t)__rev2, __p3); \
+ __ret; \
+})
+#define __noswap_vfmas_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float32_t __ret; \
+ float32_t __s0 = __p0; \
+ float32_t __s1 = __p1; \
+ float32x4_t __s2 = __p2; \
+ __ret = (float32_t) __builtin_neon_vfmas_laneq_f32(__s0, __s1, (float32x4_t)__s2, __p3); \
__ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vld4q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2x4_t __ret; \
- int64x2x4_t __s1 = __p1; \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 35); \
+#define vfmaq_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float64x2_t __ret; \
+ float64x2_t __s0 = __p0; \
+ float64x2_t __s1 = __p1; \
+ float64x2_t __s2 = __p2; \
+ __ret = (float64x2_t) __builtin_neon_vfmaq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 42); \
__ret; \
})
#else
-#define vld4q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2x4_t __ret; \
- int64x2x4_t __s1 = __p1; \
- int64x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 35); \
- \
- __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
- __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
- __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
- __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+#define vfmaq_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float64x2_t __ret; \
+ float64x2_t __s0 = __p0; \
+ float64x2_t __s1 = __p1; \
+ float64x2_t __s2 = __p2; \
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ float64x2_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
+ __ret = (float64x2_t) __builtin_neon_vfmaq_laneq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, __p3, 42); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_vfmaq_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float64x2_t __ret; \
+ float64x2_t __s0 = __p0; \
+ float64x2_t __s1 = __p1; \
+ float64x2_t __s2 = __p2; \
+ __ret = (float64x2_t) __builtin_neon_vfmaq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 42); \
__ret; \
})
#endif
-#define vld4_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x1x4_t __ret; \
- uint64x1x4_t __s1 = __p1; \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 19); \
+#ifdef __LITTLE_ENDIAN__
+#define vfmaq_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float32x4_t __ret; \
+ float32x4_t __s0 = __p0; \
+ float32x4_t __s1 = __p1; \
+ float32x4_t __s2 = __p2; \
+ __ret = (float32x4_t) __builtin_neon_vfmaq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 41); \
__ret; \
})
-#define vld4_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x1x4_t __ret; \
- float64x1x4_t __s1 = __p1; \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 10); \
+#else
+#define vfmaq_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float32x4_t __ret; \
+ float32x4_t __s0 = __p0; \
+ float32x4_t __s1 = __p1; \
+ float32x4_t __s2 = __p2; \
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ float32x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+ __ret = (float32x4_t) __builtin_neon_vfmaq_laneq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, __p3, 41); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
-#define vld4_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x1x4_t __ret; \
- int64x1x4_t __s1 = __p1; \
- __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 3); \
+#define __noswap_vfmaq_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float32x4_t __ret; \
+ float32x4_t __s0 = __p0; \
+ float32x4_t __s1 = __p1; \
+ float32x4_t __s2 = __p2; \
+ __ret = (float32x4_t) __builtin_neon_vfmaq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 41); \
__ret; \
})
-#define vldrq_p128(__p0) __extension__ ({ \
- poly128_t __ret; \
- __ret = (poly128_t) __builtin_neon_vldrq_p128(__p0); \
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfma_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float64x1_t __ret; \
+ float64x1_t __s0 = __p0; \
+ float64x1_t __s1 = __p1; \
+ float64x2_t __s2 = __p2; \
+ __ret = (float64x1_t) __builtin_neon_vfma_laneq_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__s2, __p3, 10); \
+ __ret; \
+})
+#else
+#define vfma_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float64x1_t __ret; \
+ float64x1_t __s0 = __p0; \
+ float64x1_t __s1 = __p1; \
+ float64x2_t __s2 = __p2; \
+ float64x2_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
+ __ret = (float64x1_t) __builtin_neon_vfma_laneq_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__rev2, __p3, 10); \
+ __ret; \
+})
+#define __noswap_vfma_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float64x1_t __ret; \
+ float64x1_t __s0 = __p0; \
+ float64x1_t __s1 = __p1; \
+ float64x2_t __s2 = __p2; \
+ __ret = (float64x1_t) __builtin_neon_vfma_laneq_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__s2, __p3, 10); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfma_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float32x2_t __ret; \
+ float32x2_t __s0 = __p0; \
+ float32x2_t __s1 = __p1; \
+ float32x4_t __s2 = __p2; \
+ __ret = (float32x2_t) __builtin_neon_vfma_laneq_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__s2, __p3, 9); \
+ __ret; \
+})
+#else
+#define vfma_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float32x2_t __ret; \
+ float32x2_t __s0 = __p0; \
+ float32x2_t __s1 = __p1; \
+ float32x4_t __s2 = __p2; \
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ float32x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+ __ret = (float32x2_t) __builtin_neon_vfma_laneq_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x16_t)__rev2, __p3, 9); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_vfma_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ float32x2_t __ret; \
+ float32x2_t __s0 = __p0; \
+ float32x2_t __s1 = __p1; \
+ float32x4_t __s2 = __p2; \
+ __ret = (float32x2_t) __builtin_neon_vfma_laneq_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__s2, __p3, 9); \
__ret; \
})
+#endif
+
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vmaxq_f64(float64x2_t __p0, float64x2_t __p1) {
+__ai __attribute__((target("neon"))) float64x2_t vfmaq_n_f64(float64x2_t __p0, float64x2_t __p1, float64_t __p2) {
float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+ __ret = vfmaq_f64(__p0, __p1, (float64x2_t) {__p2, __p2});
return __ret;
}
#else
-__ai float64x2_t vmaxq_f64(float64x2_t __p0, float64x2_t __p1) {
+__ai __attribute__((target("neon"))) float64x2_t vfmaq_n_f64(float64x2_t __p0, float64x2_t __p1, float64_t __p2) {
float64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+ __ret = __noswap_vfmaq_f64(__rev0, __rev1, (float64x2_t) {__p2, __p2});
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai float64x1_t vmax_f64(float64x1_t __p0, float64x1_t __p1) {
+__ai __attribute__((target("neon"))) float64x1_t vfma_n_f64(float64x1_t __p0, float64x1_t __p1, float64_t __p2) {
float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
+ __ret = vfma_f64(__p0, __p1, (float64x1_t) {__p2});
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai float64_t vmaxnmvq_f64(float64x2_t __p0) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vmaxnmvq_f64(__p0);
+__ai __attribute__((target("neon"))) float64x2_t vfmsq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+ float64x2_t __ret;
+ __ret = vfmaq_f64(__p0, -__p1, __p2);
return __ret;
}
#else
-__ai float64_t vmaxnmvq_f64(float64x2_t __p0) {
- float64_t __ret;
+__ai __attribute__((target("neon"))) float64x2_t vfmsq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+ float64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64_t) __builtin_neon_vmaxnmvq_f64(__rev0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ float64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = __noswap_vfmaq_f64(__rev0, -__rev1, __rev2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai float32_t vmaxnmvq_f32(float32x4_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vmaxnmvq_f32(__p0);
+__ai __attribute__((target("neon"))) float64x1_t vfms_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
+ float64x1_t __ret;
+ __ret = vfma_f64(__p0, -__p1, __p2);
return __ret;
}
+#define vfmsd_lane_f64(__p0_426, __p1_426, __p2_426, __p3_426) __extension__ ({ \
+ float64_t __ret_426; \
+ float64_t __s0_426 = __p0_426; \
+ float64_t __s1_426 = __p1_426; \
+ float64x1_t __s2_426 = __p2_426; \
+ __ret_426 = vfmad_lane_f64(__s0_426, -__s1_426, __s2_426, __p3_426); \
+ __ret_426; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vfmss_lane_f32(__p0_427, __p1_427, __p2_427, __p3_427) __extension__ ({ \
+ float32_t __ret_427; \
+ float32_t __s0_427 = __p0_427; \
+ float32_t __s1_427 = __p1_427; \
+ float32x2_t __s2_427 = __p2_427; \
+ __ret_427 = vfmas_lane_f32(__s0_427, -__s1_427, __s2_427, __p3_427); \
+ __ret_427; \
+})
#else
-__ai float32_t vmaxnmvq_f32(float32x4_t __p0) {
- float32_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float32_t) __builtin_neon_vmaxnmvq_f32(__rev0);
- return __ret;
-}
+#define vfmss_lane_f32(__p0_428, __p1_428, __p2_428, __p3_428) __extension__ ({ \
+ float32_t __ret_428; \
+ float32_t __s0_428 = __p0_428; \
+ float32_t __s1_428 = __p1_428; \
+ float32x2_t __s2_428 = __p2_428; \
+ float32x2_t __rev2_428; __rev2_428 = __builtin_shufflevector(__s2_428, __s2_428, 1, 0); \
+ __ret_428 = __noswap_vfmas_lane_f32(__s0_428, -__s1_428, __rev2_428, __p3_428); \
+ __ret_428; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32_t vmaxnmv_f32(float32x2_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vmaxnmv_f32(__p0);
- return __ret;
-}
+#define vfmsq_lane_f64(__p0_429, __p1_429, __p2_429, __p3_429) __extension__ ({ \
+ float64x2_t __ret_429; \
+ float64x2_t __s0_429 = __p0_429; \
+ float64x2_t __s1_429 = __p1_429; \
+ float64x1_t __s2_429 = __p2_429; \
+ __ret_429 = vfmaq_lane_f64(__s0_429, -__s1_429, __s2_429, __p3_429); \
+ __ret_429; \
+})
#else
-__ai float32_t vmaxnmv_f32(float32x2_t __p0) {
- float32_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float32_t) __builtin_neon_vmaxnmv_f32(__rev0);
- return __ret;
-}
+#define vfmsq_lane_f64(__p0_430, __p1_430, __p2_430, __p3_430) __extension__ ({ \
+ float64x2_t __ret_430; \
+ float64x2_t __s0_430 = __p0_430; \
+ float64x2_t __s1_430 = __p1_430; \
+ float64x1_t __s2_430 = __p2_430; \
+ float64x2_t __rev0_430; __rev0_430 = __builtin_shufflevector(__s0_430, __s0_430, 1, 0); \
+ float64x2_t __rev1_430; __rev1_430 = __builtin_shufflevector(__s1_430, __s1_430, 1, 0); \
+ __ret_430 = __noswap_vfmaq_lane_f64(__rev0_430, -__rev1_430, __s2_430, __p3_430); \
+ __ret_430 = __builtin_shufflevector(__ret_430, __ret_430, 1, 0); \
+ __ret_430; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8_t vmaxvq_u8(uint8x16_t __p0) {
- uint8_t __ret;
- __ret = (uint8_t) __builtin_neon_vmaxvq_u8(__p0);
- return __ret;
-}
+#define vfmsq_lane_f32(__p0_431, __p1_431, __p2_431, __p3_431) __extension__ ({ \
+ float32x4_t __ret_431; \
+ float32x4_t __s0_431 = __p0_431; \
+ float32x4_t __s1_431 = __p1_431; \
+ float32x2_t __s2_431 = __p2_431; \
+ __ret_431 = vfmaq_lane_f32(__s0_431, -__s1_431, __s2_431, __p3_431); \
+ __ret_431; \
+})
#else
-__ai uint8_t vmaxvq_u8(uint8x16_t __p0) {
- uint8_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8_t) __builtin_neon_vmaxvq_u8(__rev0);
- return __ret;
-}
+#define vfmsq_lane_f32(__p0_432, __p1_432, __p2_432, __p3_432) __extension__ ({ \
+ float32x4_t __ret_432; \
+ float32x4_t __s0_432 = __p0_432; \
+ float32x4_t __s1_432 = __p1_432; \
+ float32x2_t __s2_432 = __p2_432; \
+ float32x4_t __rev0_432; __rev0_432 = __builtin_shufflevector(__s0_432, __s0_432, 3, 2, 1, 0); \
+ float32x4_t __rev1_432; __rev1_432 = __builtin_shufflevector(__s1_432, __s1_432, 3, 2, 1, 0); \
+ float32x2_t __rev2_432; __rev2_432 = __builtin_shufflevector(__s2_432, __s2_432, 1, 0); \
+ __ret_432 = __noswap_vfmaq_lane_f32(__rev0_432, -__rev1_432, __rev2_432, __p3_432); \
+ __ret_432 = __builtin_shufflevector(__ret_432, __ret_432, 3, 2, 1, 0); \
+ __ret_432; \
+})
#endif
+#define vfms_lane_f64(__p0_433, __p1_433, __p2_433, __p3_433) __extension__ ({ \
+ float64x1_t __ret_433; \
+ float64x1_t __s0_433 = __p0_433; \
+ float64x1_t __s1_433 = __p1_433; \
+ float64x1_t __s2_433 = __p2_433; \
+ __ret_433 = vfma_lane_f64(__s0_433, -__s1_433, __s2_433, __p3_433); \
+ __ret_433; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai uint32_t vmaxvq_u32(uint32x4_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vmaxvq_u32(__p0);
- return __ret;
-}
+#define vfms_lane_f32(__p0_434, __p1_434, __p2_434, __p3_434) __extension__ ({ \
+ float32x2_t __ret_434; \
+ float32x2_t __s0_434 = __p0_434; \
+ float32x2_t __s1_434 = __p1_434; \
+ float32x2_t __s2_434 = __p2_434; \
+ __ret_434 = vfma_lane_f32(__s0_434, -__s1_434, __s2_434, __p3_434); \
+ __ret_434; \
+})
#else
-__ai uint32_t vmaxvq_u32(uint32x4_t __p0) {
- uint32_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32_t) __builtin_neon_vmaxvq_u32(__rev0);
- return __ret;
-}
+#define vfms_lane_f32(__p0_435, __p1_435, __p2_435, __p3_435) __extension__ ({ \
+ float32x2_t __ret_435; \
+ float32x2_t __s0_435 = __p0_435; \
+ float32x2_t __s1_435 = __p1_435; \
+ float32x2_t __s2_435 = __p2_435; \
+ float32x2_t __rev0_435; __rev0_435 = __builtin_shufflevector(__s0_435, __s0_435, 1, 0); \
+ float32x2_t __rev1_435; __rev1_435 = __builtin_shufflevector(__s1_435, __s1_435, 1, 0); \
+ float32x2_t __rev2_435; __rev2_435 = __builtin_shufflevector(__s2_435, __s2_435, 1, 0); \
+ __ret_435 = __noswap_vfma_lane_f32(__rev0_435, -__rev1_435, __rev2_435, __p3_435); \
+ __ret_435 = __builtin_shufflevector(__ret_435, __ret_435, 1, 0); \
+ __ret_435; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16_t vmaxvq_u16(uint16x8_t __p0) {
- uint16_t __ret;
- __ret = (uint16_t) __builtin_neon_vmaxvq_u16(__p0);
- return __ret;
-}
-#else
-__ai uint16_t vmaxvq_u16(uint16x8_t __p0) {
- uint16_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16_t) __builtin_neon_vmaxvq_u16(__rev0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int8_t vmaxvq_s8(int8x16_t __p0) {
- int8_t __ret;
- __ret = (int8_t) __builtin_neon_vmaxvq_s8(__p0);
- return __ret;
-}
+#define vfmsd_laneq_f64(__p0_436, __p1_436, __p2_436, __p3_436) __extension__ ({ \
+ float64_t __ret_436; \
+ float64_t __s0_436 = __p0_436; \
+ float64_t __s1_436 = __p1_436; \
+ float64x2_t __s2_436 = __p2_436; \
+ __ret_436 = vfmad_laneq_f64(__s0_436, -__s1_436, __s2_436, __p3_436); \
+ __ret_436; \
+})
#else
-__ai int8_t vmaxvq_s8(int8x16_t __p0) {
- int8_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8_t) __builtin_neon_vmaxvq_s8(__rev0);
- return __ret;
-}
+#define vfmsd_laneq_f64(__p0_437, __p1_437, __p2_437, __p3_437) __extension__ ({ \
+ float64_t __ret_437; \
+ float64_t __s0_437 = __p0_437; \
+ float64_t __s1_437 = __p1_437; \
+ float64x2_t __s2_437 = __p2_437; \
+ float64x2_t __rev2_437; __rev2_437 = __builtin_shufflevector(__s2_437, __s2_437, 1, 0); \
+ __ret_437 = __noswap_vfmad_laneq_f64(__s0_437, -__s1_437, __rev2_437, __p3_437); \
+ __ret_437; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64_t vmaxvq_f64(float64x2_t __p0) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vmaxvq_f64(__p0);
- return __ret;
-}
+#define vfmss_laneq_f32(__p0_438, __p1_438, __p2_438, __p3_438) __extension__ ({ \
+ float32_t __ret_438; \
+ float32_t __s0_438 = __p0_438; \
+ float32_t __s1_438 = __p1_438; \
+ float32x4_t __s2_438 = __p2_438; \
+ __ret_438 = vfmas_laneq_f32(__s0_438, -__s1_438, __s2_438, __p3_438); \
+ __ret_438; \
+})
#else
-__ai float64_t vmaxvq_f64(float64x2_t __p0) {
- float64_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64_t) __builtin_neon_vmaxvq_f64(__rev0);
- return __ret;
-}
+#define vfmss_laneq_f32(__p0_439, __p1_439, __p2_439, __p3_439) __extension__ ({ \
+ float32_t __ret_439; \
+ float32_t __s0_439 = __p0_439; \
+ float32_t __s1_439 = __p1_439; \
+ float32x4_t __s2_439 = __p2_439; \
+ float32x4_t __rev2_439; __rev2_439 = __builtin_shufflevector(__s2_439, __s2_439, 3, 2, 1, 0); \
+ __ret_439 = __noswap_vfmas_laneq_f32(__s0_439, -__s1_439, __rev2_439, __p3_439); \
+ __ret_439; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32_t vmaxvq_f32(float32x4_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vmaxvq_f32(__p0);
- return __ret;
-}
+#define vfmsq_laneq_f64(__p0_440, __p1_440, __p2_440, __p3_440) __extension__ ({ \
+ float64x2_t __ret_440; \
+ float64x2_t __s0_440 = __p0_440; \
+ float64x2_t __s1_440 = __p1_440; \
+ float64x2_t __s2_440 = __p2_440; \
+ __ret_440 = vfmaq_laneq_f64(__s0_440, -__s1_440, __s2_440, __p3_440); \
+ __ret_440; \
+})
#else
-__ai float32_t vmaxvq_f32(float32x4_t __p0) {
- float32_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float32_t) __builtin_neon_vmaxvq_f32(__rev0);
- return __ret;
-}
+#define vfmsq_laneq_f64(__p0_441, __p1_441, __p2_441, __p3_441) __extension__ ({ \
+ float64x2_t __ret_441; \
+ float64x2_t __s0_441 = __p0_441; \
+ float64x2_t __s1_441 = __p1_441; \
+ float64x2_t __s2_441 = __p2_441; \
+ float64x2_t __rev0_441; __rev0_441 = __builtin_shufflevector(__s0_441, __s0_441, 1, 0); \
+ float64x2_t __rev1_441; __rev1_441 = __builtin_shufflevector(__s1_441, __s1_441, 1, 0); \
+ float64x2_t __rev2_441; __rev2_441 = __builtin_shufflevector(__s2_441, __s2_441, 1, 0); \
+ __ret_441 = __noswap_vfmaq_laneq_f64(__rev0_441, -__rev1_441, __rev2_441, __p3_441); \
+ __ret_441 = __builtin_shufflevector(__ret_441, __ret_441, 1, 0); \
+ __ret_441; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32_t vmaxvq_s32(int32x4_t __p0) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vmaxvq_s32(__p0);
- return __ret;
-}
+#define vfmsq_laneq_f32(__p0_442, __p1_442, __p2_442, __p3_442) __extension__ ({ \
+ float32x4_t __ret_442; \
+ float32x4_t __s0_442 = __p0_442; \
+ float32x4_t __s1_442 = __p1_442; \
+ float32x4_t __s2_442 = __p2_442; \
+ __ret_442 = vfmaq_laneq_f32(__s0_442, -__s1_442, __s2_442, __p3_442); \
+ __ret_442; \
+})
#else
-__ai int32_t vmaxvq_s32(int32x4_t __p0) {
- int32_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int32_t) __builtin_neon_vmaxvq_s32(__rev0);
- return __ret;
-}
+#define vfmsq_laneq_f32(__p0_443, __p1_443, __p2_443, __p3_443) __extension__ ({ \
+ float32x4_t __ret_443; \
+ float32x4_t __s0_443 = __p0_443; \
+ float32x4_t __s1_443 = __p1_443; \
+ float32x4_t __s2_443 = __p2_443; \
+ float32x4_t __rev0_443; __rev0_443 = __builtin_shufflevector(__s0_443, __s0_443, 3, 2, 1, 0); \
+ float32x4_t __rev1_443; __rev1_443 = __builtin_shufflevector(__s1_443, __s1_443, 3, 2, 1, 0); \
+ float32x4_t __rev2_443; __rev2_443 = __builtin_shufflevector(__s2_443, __s2_443, 3, 2, 1, 0); \
+ __ret_443 = __noswap_vfmaq_laneq_f32(__rev0_443, -__rev1_443, __rev2_443, __p3_443); \
+ __ret_443 = __builtin_shufflevector(__ret_443, __ret_443, 3, 2, 1, 0); \
+ __ret_443; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16_t vmaxvq_s16(int16x8_t __p0) {
- int16_t __ret;
- __ret = (int16_t) __builtin_neon_vmaxvq_s16(__p0);
- return __ret;
-}
+#define vfms_laneq_f64(__p0_444, __p1_444, __p2_444, __p3_444) __extension__ ({ \
+ float64x1_t __ret_444; \
+ float64x1_t __s0_444 = __p0_444; \
+ float64x1_t __s1_444 = __p1_444; \
+ float64x2_t __s2_444 = __p2_444; \
+ __ret_444 = vfma_laneq_f64(__s0_444, -__s1_444, __s2_444, __p3_444); \
+ __ret_444; \
+})
#else
-__ai int16_t vmaxvq_s16(int16x8_t __p0) {
- int16_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16_t) __builtin_neon_vmaxvq_s16(__rev0);
- return __ret;
-}
+#define vfms_laneq_f64(__p0_445, __p1_445, __p2_445, __p3_445) __extension__ ({ \
+ float64x1_t __ret_445; \
+ float64x1_t __s0_445 = __p0_445; \
+ float64x1_t __s1_445 = __p1_445; \
+ float64x2_t __s2_445 = __p2_445; \
+ float64x2_t __rev2_445; __rev2_445 = __builtin_shufflevector(__s2_445, __s2_445, 1, 0); \
+ __ret_445 = __noswap_vfma_laneq_f64(__s0_445, -__s1_445, __rev2_445, __p3_445); \
+ __ret_445; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8_t vmaxv_u8(uint8x8_t __p0) {
- uint8_t __ret;
- __ret = (uint8_t) __builtin_neon_vmaxv_u8(__p0);
- return __ret;
-}
+#define vfms_laneq_f32(__p0_446, __p1_446, __p2_446, __p3_446) __extension__ ({ \
+ float32x2_t __ret_446; \
+ float32x2_t __s0_446 = __p0_446; \
+ float32x2_t __s1_446 = __p1_446; \
+ float32x4_t __s2_446 = __p2_446; \
+ __ret_446 = vfma_laneq_f32(__s0_446, -__s1_446, __s2_446, __p3_446); \
+ __ret_446; \
+})
#else
-__ai uint8_t vmaxv_u8(uint8x8_t __p0) {
- uint8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8_t) __builtin_neon_vmaxv_u8(__rev0);
- return __ret;
-}
+#define vfms_laneq_f32(__p0_447, __p1_447, __p2_447, __p3_447) __extension__ ({ \
+ float32x2_t __ret_447; \
+ float32x2_t __s0_447 = __p0_447; \
+ float32x2_t __s1_447 = __p1_447; \
+ float32x4_t __s2_447 = __p2_447; \
+ float32x2_t __rev0_447; __rev0_447 = __builtin_shufflevector(__s0_447, __s0_447, 1, 0); \
+ float32x2_t __rev1_447; __rev1_447 = __builtin_shufflevector(__s1_447, __s1_447, 1, 0); \
+ float32x4_t __rev2_447; __rev2_447 = __builtin_shufflevector(__s2_447, __s2_447, 3, 2, 1, 0); \
+ __ret_447 = __noswap_vfma_laneq_f32(__rev0_447, -__rev1_447, __rev2_447, __p3_447); \
+ __ret_447 = __builtin_shufflevector(__ret_447, __ret_447, 1, 0); \
+ __ret_447; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32_t vmaxv_u32(uint32x2_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vmaxv_u32(__p0);
+__ai __attribute__((target("neon"))) float64x2_t vfmsq_n_f64(float64x2_t __p0, float64x2_t __p1, float64_t __p2) {
+ float64x2_t __ret;
+ __ret = vfmaq_f64(__p0, -__p1, (float64x2_t) {__p2, __p2});
return __ret;
}
#else
-__ai uint32_t vmaxv_u32(uint32x2_t __p0) {
- uint32_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32_t) __builtin_neon_vmaxv_u32(__rev0);
+__ai __attribute__((target("neon"))) float64x2_t vfmsq_n_f64(float64x2_t __p0, float64x2_t __p1, float64_t __p2) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __noswap_vfmaq_f64(__rev0, -__rev1, (float64x2_t) {__p2, __p2});
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16_t vmaxv_u16(uint16x4_t __p0) {
- uint16_t __ret;
- __ret = (uint16_t) __builtin_neon_vmaxv_u16(__p0);
+__ai __attribute__((target("neon"))) float32x4_t vfmsq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
+ float32x4_t __ret;
+ __ret = vfmaq_f32(__p0, -__p1, (float32x4_t) {__p2, __p2, __p2, __p2});
return __ret;
}
#else
-__ai uint16_t vmaxv_u16(uint16x4_t __p0) {
- uint16_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16_t) __builtin_neon_vmaxv_u16(__rev0);
+__ai __attribute__((target("neon"))) float32x4_t vfmsq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __noswap_vfmaq_f32(__rev0, -__rev1, (float32x4_t) {__p2, __p2, __p2, __p2});
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai int8_t vmaxv_s8(int8x8_t __p0) {
- int8_t __ret;
- __ret = (int8_t) __builtin_neon_vmaxv_s8(__p0);
- return __ret;
-}
-#else
-__ai int8_t vmaxv_s8(int8x8_t __p0) {
- int8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8_t) __builtin_neon_vmaxv_s8(__rev0);
+__ai __attribute__((target("neon"))) float64x1_t vfms_n_f64(float64x1_t __p0, float64x1_t __p1, float64_t __p2) {
+ float64x1_t __ret;
+ __ret = vfma_f64(__p0, -__p1, (float64x1_t) {__p2});
return __ret;
}
-#endif
-
#ifdef __LITTLE_ENDIAN__
-__ai float32_t vmaxv_f32(float32x2_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vmaxv_f32(__p0);
+__ai __attribute__((target("neon"))) float32x2_t vfms_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
+ float32x2_t __ret;
+ __ret = vfma_f32(__p0, -__p1, (float32x2_t) {__p2, __p2});
return __ret;
}
#else
-__ai float32_t vmaxv_f32(float32x2_t __p0) {
- float32_t __ret;
+__ai __attribute__((target("neon"))) float32x2_t vfms_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
+ float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float32_t) __builtin_neon_vmaxv_f32(__rev0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __noswap_vfma_f32(__rev0, -__rev1, (float32x2_t) {__p2, __p2});
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32_t vmaxv_s32(int32x2_t __p0) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vmaxv_s32(__p0);
+__ai __attribute__((target("neon"))) poly64x1_t vget_high_p64(poly64x2_t __p0) {
+ poly64x1_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1);
return __ret;
}
#else
-__ai int32_t vmaxv_s32(int32x2_t __p0) {
- int32_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int32_t) __builtin_neon_vmaxv_s32(__rev0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int16_t vmaxv_s16(int16x4_t __p0) {
- int16_t __ret;
- __ret = (int16_t) __builtin_neon_vmaxv_s16(__p0);
+__ai __attribute__((target("neon"))) poly64x1_t vget_high_p64(poly64x2_t __p0) {
+ poly64x1_t __ret;
+ poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1);
return __ret;
}
-#else
-__ai int16_t vmaxv_s16(int16x4_t __p0) {
- int16_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int16_t) __builtin_neon_vmaxv_s16(__rev0);
+__ai __attribute__((target("neon"))) poly64x1_t __noswap_vget_high_p64(poly64x2_t __p0) {
+ poly64x1_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 1);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vminq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
- return __ret;
-}
-#else
-__ai float64x2_t vminq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-__ai float64x1_t vmin_f64(float64x1_t __p0, float64x1_t __p1) {
+__ai __attribute__((target("neon"))) float64x1_t vget_high_f64(float64x2_t __p0) {
float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
- return __ret;
-}
-#ifdef __LITTLE_ENDIAN__
-__ai float64_t vminnmvq_f64(float64x2_t __p0) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vminnmvq_f64(__p0);
+ __ret = __builtin_shufflevector(__p0, __p0, 1);
return __ret;
}
#else
-__ai float64_t vminnmvq_f64(float64x2_t __p0) {
- float64_t __ret;
+__ai __attribute__((target("neon"))) float64x1_t vget_high_f64(float64x2_t __p0) {
+ float64x1_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64_t) __builtin_neon_vminnmvq_f64(__rev0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 1);
return __ret;
}
#endif
+#define vget_lane_p64(__p0, __p1) __extension__ ({ \
+ poly64_t __ret; \
+ poly64x1_t __s0 = __p0; \
+ __ret = (poly64_t) __builtin_neon_vget_lane_i64((poly64x1_t)__s0, __p1); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai float32_t vminnmvq_f32(float32x4_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vminnmvq_f32(__p0);
- return __ret;
-}
+#define vgetq_lane_p64(__p0, __p1) __extension__ ({ \
+ poly64_t __ret; \
+ poly64x2_t __s0 = __p0; \
+ __ret = (poly64_t) __builtin_neon_vgetq_lane_i64((poly64x2_t)__s0, __p1); \
+ __ret; \
+})
#else
-__ai float32_t vminnmvq_f32(float32x4_t __p0) {
- float32_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float32_t) __builtin_neon_vminnmvq_f32(__rev0);
- return __ret;
-}
+#define vgetq_lane_p64(__p0, __p1) __extension__ ({ \
+ poly64_t __ret; \
+ poly64x2_t __s0 = __p0; \
+ poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (poly64_t) __builtin_neon_vgetq_lane_i64((poly64x2_t)__rev0, __p1); \
+ __ret; \
+})
+#define __noswap_vgetq_lane_p64(__p0, __p1) __extension__ ({ \
+ poly64_t __ret; \
+ poly64x2_t __s0 = __p0; \
+ __ret = (poly64_t) __builtin_neon_vgetq_lane_i64((poly64x2_t)__s0, __p1); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32_t vminnmv_f32(float32x2_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vminnmv_f32(__p0);
- return __ret;
-}
+#define vgetq_lane_f64(__p0, __p1) __extension__ ({ \
+ float64_t __ret; \
+ float64x2_t __s0 = __p0; \
+ __ret = (float64_t) __builtin_neon_vgetq_lane_f64((float64x2_t)__s0, __p1); \
+ __ret; \
+})
#else
-__ai float32_t vminnmv_f32(float32x2_t __p0) {
- float32_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float32_t) __builtin_neon_vminnmv_f32(__rev0);
- return __ret;
-}
+#define vgetq_lane_f64(__p0, __p1) __extension__ ({ \
+ float64_t __ret; \
+ float64x2_t __s0 = __p0; \
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ __ret = (float64_t) __builtin_neon_vgetq_lane_f64((float64x2_t)__rev0, __p1); \
+ __ret; \
+})
+#define __noswap_vgetq_lane_f64(__p0, __p1) __extension__ ({ \
+ float64_t __ret; \
+ float64x2_t __s0 = __p0; \
+ __ret = (float64_t) __builtin_neon_vgetq_lane_f64((float64x2_t)__s0, __p1); \
+ __ret; \
+})
#endif
+#define vget_lane_f64(__p0, __p1) __extension__ ({ \
+ float64_t __ret; \
+ float64x1_t __s0 = __p0; \
+ __ret = (float64_t) __builtin_neon_vget_lane_f64((float64x1_t)__s0, __p1); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai uint8_t vminvq_u8(uint8x16_t __p0) {
- uint8_t __ret;
- __ret = (uint8_t) __builtin_neon_vminvq_u8(__p0);
+__ai __attribute__((target("neon"))) poly64x1_t vget_low_p64(poly64x2_t __p0) {
+ poly64x1_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 0);
return __ret;
}
#else
-__ai uint8_t vminvq_u8(uint8x16_t __p0) {
- uint8_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8_t) __builtin_neon_vminvq_u8(__rev0);
+__ai __attribute__((target("neon"))) poly64x1_t vget_low_p64(poly64x2_t __p0) {
+ poly64x1_t __ret;
+ poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32_t vminvq_u32(uint32x4_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vminvq_u32(__p0);
+__ai __attribute__((target("neon"))) float64x1_t vget_low_f64(float64x2_t __p0) {
+ float64x1_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p0, 0);
return __ret;
}
#else
-__ai uint32_t vminvq_u32(uint32x4_t __p0) {
- uint32_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint32_t) __builtin_neon_vminvq_u32(__rev0);
+__ai __attribute__((target("neon"))) float64x1_t vget_low_f64(float64x2_t __p0) {
+ float64x1_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev0, 0);
return __ret;
}
#endif
+#define vld1_p64(__p0) __extension__ ({ \
+ poly64x1_t __ret; \
+ __ret = (poly64x1_t) __builtin_neon_vld1_v(__p0, 6); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai uint16_t vminvq_u16(uint16x8_t __p0) {
- uint16_t __ret;
- __ret = (uint16_t) __builtin_neon_vminvq_u16(__p0);
- return __ret;
-}
+#define vld1q_p64(__p0) __extension__ ({ \
+ poly64x2_t __ret; \
+ __ret = (poly64x2_t) __builtin_neon_vld1q_v(__p0, 38); \
+ __ret; \
+})
#else
-__ai uint16_t vminvq_u16(uint16x8_t __p0) {
- uint16_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16_t) __builtin_neon_vminvq_u16(__rev0);
- return __ret;
-}
+#define vld1q_p64(__p0) __extension__ ({ \
+ poly64x2_t __ret; \
+ __ret = (poly64x2_t) __builtin_neon_vld1q_v(__p0, 38); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8_t vminvq_s8(int8x16_t __p0) {
- int8_t __ret;
- __ret = (int8_t) __builtin_neon_vminvq_s8(__p0);
- return __ret;
-}
+#define vld1q_f64(__p0) __extension__ ({ \
+ float64x2_t __ret; \
+ __ret = (float64x2_t) __builtin_neon_vld1q_v(__p0, 42); \
+ __ret; \
+})
#else
-__ai int8_t vminvq_s8(int8x16_t __p0) {
- int8_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8_t) __builtin_neon_vminvq_s8(__rev0);
- return __ret;
-}
+#define vld1q_f64(__p0) __extension__ ({ \
+ float64x2_t __ret; \
+ __ret = (float64x2_t) __builtin_neon_vld1q_v(__p0, 42); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
#endif
+#define vld1_f64(__p0) __extension__ ({ \
+ float64x1_t __ret; \
+ __ret = (float64x1_t) __builtin_neon_vld1_v(__p0, 10); \
+ __ret; \
+})
+#define vld1_dup_p64(__p0) __extension__ ({ \
+ poly64x1_t __ret; \
+ __ret = (poly64x1_t) __builtin_neon_vld1_dup_v(__p0, 6); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai float64_t vminvq_f64(float64x2_t __p0) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vminvq_f64(__p0);
- return __ret;
-}
+#define vld1q_dup_p64(__p0) __extension__ ({ \
+ poly64x2_t __ret; \
+ __ret = (poly64x2_t) __builtin_neon_vld1q_dup_v(__p0, 38); \
+ __ret; \
+})
#else
-__ai float64_t vminvq_f64(float64x2_t __p0) {
- float64_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64_t) __builtin_neon_vminvq_f64(__rev0);
- return __ret;
-}
+#define vld1q_dup_p64(__p0) __extension__ ({ \
+ poly64x2_t __ret; \
+ __ret = (poly64x2_t) __builtin_neon_vld1q_dup_v(__p0, 38); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32_t vminvq_f32(float32x4_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vminvq_f32(__p0);
- return __ret;
-}
+#define vld1q_dup_f64(__p0) __extension__ ({ \
+ float64x2_t __ret; \
+ __ret = (float64x2_t) __builtin_neon_vld1q_dup_v(__p0, 42); \
+ __ret; \
+})
#else
-__ai float32_t vminvq_f32(float32x4_t __p0) {
- float32_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float32_t) __builtin_neon_vminvq_f32(__rev0);
- return __ret;
-}
+#define vld1q_dup_f64(__p0) __extension__ ({ \
+ float64x2_t __ret; \
+ __ret = (float64x2_t) __builtin_neon_vld1q_dup_v(__p0, 42); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
#endif
+#define vld1_dup_f64(__p0) __extension__ ({ \
+ float64x1_t __ret; \
+ __ret = (float64x1_t) __builtin_neon_vld1_dup_v(__p0, 10); \
+ __ret; \
+})
+#define vld1_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x1_t __ret; \
+ poly64x1_t __s1 = __p1; \
+ __ret = (poly64x1_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 6); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai int32_t vminvq_s32(int32x4_t __p0) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vminvq_s32(__p0);
- return __ret;
-}
+#define vld1q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2_t __ret; \
+ poly64x2_t __s1 = __p1; \
+ __ret = (poly64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 38); \
+ __ret; \
+})
#else
-__ai int32_t vminvq_s32(int32x4_t __p0) {
- int32_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int32_t) __builtin_neon_vminvq_s32(__rev0);
- return __ret;
-}
+#define vld1q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2_t __ret; \
+ poly64x2_t __s1 = __p1; \
+ poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (poly64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 38); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16_t vminvq_s16(int16x8_t __p0) {
- int16_t __ret;
- __ret = (int16_t) __builtin_neon_vminvq_s16(__p0);
- return __ret;
-}
+#define vld1q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2_t __ret; \
+ float64x2_t __s1 = __p1; \
+ __ret = (float64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 42); \
+ __ret; \
+})
#else
-__ai int16_t vminvq_s16(int16x8_t __p0) {
- int16_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16_t) __builtin_neon_vminvq_s16(__rev0);
- return __ret;
-}
+#define vld1q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2_t __ret; \
+ float64x2_t __s1 = __p1; \
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (float64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 42); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
#endif
+#define vld1_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x1_t __ret; \
+ float64x1_t __s1 = __p1; \
+ __ret = (float64x1_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 10); \
+ __ret; \
+})
+#define vld1_p64_x2(__p0) __extension__ ({ \
+ poly64x1x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 6); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai uint8_t vminv_u8(uint8x8_t __p0) {
- uint8_t __ret;
- __ret = (uint8_t) __builtin_neon_vminv_u8(__p0);
- return __ret;
-}
+#define vld1q_p64_x2(__p0) __extension__ ({ \
+ poly64x2x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 38); \
+ __ret; \
+})
#else
-__ai uint8_t vminv_u8(uint8x8_t __p0) {
- uint8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8_t) __builtin_neon_vminv_u8(__rev0);
- return __ret;
-}
+#define vld1q_p64_x2(__p0) __extension__ ({ \
+ poly64x2x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 38); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32_t vminv_u32(uint32x2_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vminv_u32(__p0);
- return __ret;
-}
+#define vld1q_f64_x2(__p0) __extension__ ({ \
+ float64x2x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 42); \
+ __ret; \
+})
#else
-__ai uint32_t vminv_u32(uint32x2_t __p0) {
- uint32_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint32_t) __builtin_neon_vminv_u32(__rev0);
- return __ret;
-}
+#define vld1q_f64_x2(__p0) __extension__ ({ \
+ float64x2x2_t __ret; \
+ __builtin_neon_vld1q_x2_v(&__ret, __p0, 42); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
+})
#endif
+#define vld1_f64_x2(__p0) __extension__ ({ \
+ float64x1x2_t __ret; \
+ __builtin_neon_vld1_x2_v(&__ret, __p0, 10); \
+ __ret; \
+})
+#define vld1_p64_x3(__p0) __extension__ ({ \
+ poly64x1x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 6); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai uint16_t vminv_u16(uint16x4_t __p0) {
- uint16_t __ret;
- __ret = (uint16_t) __builtin_neon_vminv_u16(__p0);
- return __ret;
-}
+#define vld1q_p64_x3(__p0) __extension__ ({ \
+ poly64x2x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 38); \
+ __ret; \
+})
#else
-__ai uint16_t vminv_u16(uint16x4_t __p0) {
- uint16_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (uint16_t) __builtin_neon_vminv_u16(__rev0);
- return __ret;
-}
+#define vld1q_p64_x3(__p0) __extension__ ({ \
+ poly64x2x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 38); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8_t vminv_s8(int8x8_t __p0) {
- int8_t __ret;
- __ret = (int8_t) __builtin_neon_vminv_s8(__p0);
- return __ret;
-}
-#else
-__ai int8_t vminv_s8(int8x8_t __p0) {
- int8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8_t) __builtin_neon_vminv_s8(__rev0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float32_t vminv_f32(float32x2_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vminv_f32(__p0);
- return __ret;
-}
-#else
-__ai float32_t vminv_f32(float32x2_t __p0) {
- float32_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float32_t) __builtin_neon_vminv_f32(__rev0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int32_t vminv_s32(int32x2_t __p0) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vminv_s32(__p0);
- return __ret;
-}
-#else
-__ai int32_t vminv_s32(int32x2_t __p0) {
- int32_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int32_t) __builtin_neon_vminv_s32(__rev0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int16_t vminv_s16(int16x4_t __p0) {
- int16_t __ret;
- __ret = (int16_t) __builtin_neon_vminv_s16(__p0);
- return __ret;
-}
-#else
-__ai int16_t vminv_s16(int16x4_t __p0) {
- int16_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (int16_t) __builtin_neon_vminv_s16(__rev0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vmlaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
- float64x2_t __ret;
- __ret = __p0 + __p1 * __p2;
- return __ret;
-}
-#else
-__ai float64x2_t vmlaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- float64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = __rev0 + __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-__ai float64x1_t vmla_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
- float64x1_t __ret;
- __ret = __p0 + __p1 * __p2;
- return __ret;
-}
-#ifdef __LITTLE_ENDIAN__
-#define vmlaq_laneq_u32(__p0_427, __p1_427, __p2_427, __p3_427) __extension__ ({ \
- uint32x4_t __ret_427; \
- uint32x4_t __s0_427 = __p0_427; \
- uint32x4_t __s1_427 = __p1_427; \
- uint32x4_t __s2_427 = __p2_427; \
- __ret_427 = __s0_427 + __s1_427 * splatq_laneq_u32(__s2_427, __p3_427); \
- __ret_427; \
+#define vld1q_f64_x3(__p0) __extension__ ({ \
+ float64x2x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 42); \
+ __ret; \
})
#else
-#define vmlaq_laneq_u32(__p0_428, __p1_428, __p2_428, __p3_428) __extension__ ({ \
- uint32x4_t __ret_428; \
- uint32x4_t __s0_428 = __p0_428; \
- uint32x4_t __s1_428 = __p1_428; \
- uint32x4_t __s2_428 = __p2_428; \
- uint32x4_t __rev0_428; __rev0_428 = __builtin_shufflevector(__s0_428, __s0_428, 3, 2, 1, 0); \
- uint32x4_t __rev1_428; __rev1_428 = __builtin_shufflevector(__s1_428, __s1_428, 3, 2, 1, 0); \
- uint32x4_t __rev2_428; __rev2_428 = __builtin_shufflevector(__s2_428, __s2_428, 3, 2, 1, 0); \
- __ret_428 = __rev0_428 + __rev1_428 * __noswap_splatq_laneq_u32(__rev2_428, __p3_428); \
- __ret_428 = __builtin_shufflevector(__ret_428, __ret_428, 3, 2, 1, 0); \
- __ret_428; \
+#define vld1q_f64_x3(__p0) __extension__ ({ \
+ float64x2x3_t __ret; \
+ __builtin_neon_vld1q_x3_v(&__ret, __p0, 42); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
})
#endif
-#ifdef __LITTLE_ENDIAN__
-#define vmlaq_laneq_u16(__p0_429, __p1_429, __p2_429, __p3_429) __extension__ ({ \
- uint16x8_t __ret_429; \
- uint16x8_t __s0_429 = __p0_429; \
- uint16x8_t __s1_429 = __p1_429; \
- uint16x8_t __s2_429 = __p2_429; \
- __ret_429 = __s0_429 + __s1_429 * splatq_laneq_u16(__s2_429, __p3_429); \
- __ret_429; \
+#define vld1_f64_x3(__p0) __extension__ ({ \
+ float64x1x3_t __ret; \
+ __builtin_neon_vld1_x3_v(&__ret, __p0, 10); \
+ __ret; \
})
-#else
-#define vmlaq_laneq_u16(__p0_430, __p1_430, __p2_430, __p3_430) __extension__ ({ \
- uint16x8_t __ret_430; \
- uint16x8_t __s0_430 = __p0_430; \
- uint16x8_t __s1_430 = __p1_430; \
- uint16x8_t __s2_430 = __p2_430; \
- uint16x8_t __rev0_430; __rev0_430 = __builtin_shufflevector(__s0_430, __s0_430, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x8_t __rev1_430; __rev1_430 = __builtin_shufflevector(__s1_430, __s1_430, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x8_t __rev2_430; __rev2_430 = __builtin_shufflevector(__s2_430, __s2_430, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_430 = __rev0_430 + __rev1_430 * __noswap_splatq_laneq_u16(__rev2_430, __p3_430); \
- __ret_430 = __builtin_shufflevector(__ret_430, __ret_430, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_430; \
+#define vld1_p64_x4(__p0) __extension__ ({ \
+ poly64x1x4_t __ret; \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 6); \
+ __ret; \
})
-#endif
-
#ifdef __LITTLE_ENDIAN__
-#define vmlaq_laneq_f32(__p0_431, __p1_431, __p2_431, __p3_431) __extension__ ({ \
- float32x4_t __ret_431; \
- float32x4_t __s0_431 = __p0_431; \
- float32x4_t __s1_431 = __p1_431; \
- float32x4_t __s2_431 = __p2_431; \
- __ret_431 = __s0_431 + __s1_431 * splatq_laneq_f32(__s2_431, __p3_431); \
- __ret_431; \
+#define vld1q_p64_x4(__p0) __extension__ ({ \
+ poly64x2x4_t __ret; \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 38); \
+ __ret; \
})
#else
-#define vmlaq_laneq_f32(__p0_432, __p1_432, __p2_432, __p3_432) __extension__ ({ \
- float32x4_t __ret_432; \
- float32x4_t __s0_432 = __p0_432; \
- float32x4_t __s1_432 = __p1_432; \
- float32x4_t __s2_432 = __p2_432; \
- float32x4_t __rev0_432; __rev0_432 = __builtin_shufflevector(__s0_432, __s0_432, 3, 2, 1, 0); \
- float32x4_t __rev1_432; __rev1_432 = __builtin_shufflevector(__s1_432, __s1_432, 3, 2, 1, 0); \
- float32x4_t __rev2_432; __rev2_432 = __builtin_shufflevector(__s2_432, __s2_432, 3, 2, 1, 0); \
- __ret_432 = __rev0_432 + __rev1_432 * __noswap_splatq_laneq_f32(__rev2_432, __p3_432); \
- __ret_432 = __builtin_shufflevector(__ret_432, __ret_432, 3, 2, 1, 0); \
- __ret_432; \
+#define vld1q_p64_x4(__p0) __extension__ ({ \
+ poly64x2x4_t __ret; \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 38); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlaq_laneq_s32(__p0_433, __p1_433, __p2_433, __p3_433) __extension__ ({ \
- int32x4_t __ret_433; \
- int32x4_t __s0_433 = __p0_433; \
- int32x4_t __s1_433 = __p1_433; \
- int32x4_t __s2_433 = __p2_433; \
- __ret_433 = __s0_433 + __s1_433 * splatq_laneq_s32(__s2_433, __p3_433); \
- __ret_433; \
+#define vld1q_f64_x4(__p0) __extension__ ({ \
+ float64x2x4_t __ret; \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 42); \
+ __ret; \
})
#else
-#define vmlaq_laneq_s32(__p0_434, __p1_434, __p2_434, __p3_434) __extension__ ({ \
- int32x4_t __ret_434; \
- int32x4_t __s0_434 = __p0_434; \
- int32x4_t __s1_434 = __p1_434; \
- int32x4_t __s2_434 = __p2_434; \
- int32x4_t __rev0_434; __rev0_434 = __builtin_shufflevector(__s0_434, __s0_434, 3, 2, 1, 0); \
- int32x4_t __rev1_434; __rev1_434 = __builtin_shufflevector(__s1_434, __s1_434, 3, 2, 1, 0); \
- int32x4_t __rev2_434; __rev2_434 = __builtin_shufflevector(__s2_434, __s2_434, 3, 2, 1, 0); \
- __ret_434 = __rev0_434 + __rev1_434 * __noswap_splatq_laneq_s32(__rev2_434, __p3_434); \
- __ret_434 = __builtin_shufflevector(__ret_434, __ret_434, 3, 2, 1, 0); \
- __ret_434; \
+#define vld1q_f64_x4(__p0) __extension__ ({ \
+ float64x2x4_t __ret; \
+ __builtin_neon_vld1q_x4_v(&__ret, __p0, 42); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
})
#endif
-#ifdef __LITTLE_ENDIAN__
-#define vmlaq_laneq_s16(__p0_435, __p1_435, __p2_435, __p3_435) __extension__ ({ \
- int16x8_t __ret_435; \
- int16x8_t __s0_435 = __p0_435; \
- int16x8_t __s1_435 = __p1_435; \
- int16x8_t __s2_435 = __p2_435; \
- __ret_435 = __s0_435 + __s1_435 * splatq_laneq_s16(__s2_435, __p3_435); \
- __ret_435; \
+#define vld1_f64_x4(__p0) __extension__ ({ \
+ float64x1x4_t __ret; \
+ __builtin_neon_vld1_x4_v(&__ret, __p0, 10); \
+ __ret; \
})
-#else
-#define vmlaq_laneq_s16(__p0_436, __p1_436, __p2_436, __p3_436) __extension__ ({ \
- int16x8_t __ret_436; \
- int16x8_t __s0_436 = __p0_436; \
- int16x8_t __s1_436 = __p1_436; \
- int16x8_t __s2_436 = __p2_436; \
- int16x8_t __rev0_436; __rev0_436 = __builtin_shufflevector(__s0_436, __s0_436, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1_436; __rev1_436 = __builtin_shufflevector(__s1_436, __s1_436, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev2_436; __rev2_436 = __builtin_shufflevector(__s2_436, __s2_436, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_436 = __rev0_436 + __rev1_436 * __noswap_splatq_laneq_s16(__rev2_436, __p3_436); \
- __ret_436 = __builtin_shufflevector(__ret_436, __ret_436, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_436; \
+#define vld2_p64(__p0) __extension__ ({ \
+ poly64x1x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 6); \
+ __ret; \
})
-#endif
-
#ifdef __LITTLE_ENDIAN__
-#define vmla_laneq_u32(__p0_437, __p1_437, __p2_437, __p3_437) __extension__ ({ \
- uint32x2_t __ret_437; \
- uint32x2_t __s0_437 = __p0_437; \
- uint32x2_t __s1_437 = __p1_437; \
- uint32x4_t __s2_437 = __p2_437; \
- __ret_437 = __s0_437 + __s1_437 * splat_laneq_u32(__s2_437, __p3_437); \
- __ret_437; \
+#define vld2q_p64(__p0) __extension__ ({ \
+ poly64x2x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 38); \
+ __ret; \
})
#else
-#define vmla_laneq_u32(__p0_438, __p1_438, __p2_438, __p3_438) __extension__ ({ \
- uint32x2_t __ret_438; \
- uint32x2_t __s0_438 = __p0_438; \
- uint32x2_t __s1_438 = __p1_438; \
- uint32x4_t __s2_438 = __p2_438; \
- uint32x2_t __rev0_438; __rev0_438 = __builtin_shufflevector(__s0_438, __s0_438, 1, 0); \
- uint32x2_t __rev1_438; __rev1_438 = __builtin_shufflevector(__s1_438, __s1_438, 1, 0); \
- uint32x4_t __rev2_438; __rev2_438 = __builtin_shufflevector(__s2_438, __s2_438, 3, 2, 1, 0); \
- __ret_438 = __rev0_438 + __rev1_438 * __noswap_splat_laneq_u32(__rev2_438, __p3_438); \
- __ret_438 = __builtin_shufflevector(__ret_438, __ret_438, 1, 0); \
- __ret_438; \
+#define vld2q_p64(__p0) __extension__ ({ \
+ poly64x2x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 38); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmla_laneq_u16(__p0_439, __p1_439, __p2_439, __p3_439) __extension__ ({ \
- uint16x4_t __ret_439; \
- uint16x4_t __s0_439 = __p0_439; \
- uint16x4_t __s1_439 = __p1_439; \
- uint16x8_t __s2_439 = __p2_439; \
- __ret_439 = __s0_439 + __s1_439 * splat_laneq_u16(__s2_439, __p3_439); \
- __ret_439; \
+#define vld2q_u64(__p0) __extension__ ({ \
+ uint64x2x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 51); \
+ __ret; \
})
#else
-#define vmla_laneq_u16(__p0_440, __p1_440, __p2_440, __p3_440) __extension__ ({ \
- uint16x4_t __ret_440; \
- uint16x4_t __s0_440 = __p0_440; \
- uint16x4_t __s1_440 = __p1_440; \
- uint16x8_t __s2_440 = __p2_440; \
- uint16x4_t __rev0_440; __rev0_440 = __builtin_shufflevector(__s0_440, __s0_440, 3, 2, 1, 0); \
- uint16x4_t __rev1_440; __rev1_440 = __builtin_shufflevector(__s1_440, __s1_440, 3, 2, 1, 0); \
- uint16x8_t __rev2_440; __rev2_440 = __builtin_shufflevector(__s2_440, __s2_440, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_440 = __rev0_440 + __rev1_440 * __noswap_splat_laneq_u16(__rev2_440, __p3_440); \
- __ret_440 = __builtin_shufflevector(__ret_440, __ret_440, 3, 2, 1, 0); \
- __ret_440; \
+#define vld2q_u64(__p0) __extension__ ({ \
+ uint64x2x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 51); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmla_laneq_f32(__p0_441, __p1_441, __p2_441, __p3_441) __extension__ ({ \
- float32x2_t __ret_441; \
- float32x2_t __s0_441 = __p0_441; \
- float32x2_t __s1_441 = __p1_441; \
- float32x4_t __s2_441 = __p2_441; \
- __ret_441 = __s0_441 + __s1_441 * splat_laneq_f32(__s2_441, __p3_441); \
- __ret_441; \
+#define vld2q_f64(__p0) __extension__ ({ \
+ float64x2x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 42); \
+ __ret; \
})
#else
-#define vmla_laneq_f32(__p0_442, __p1_442, __p2_442, __p3_442) __extension__ ({ \
- float32x2_t __ret_442; \
- float32x2_t __s0_442 = __p0_442; \
- float32x2_t __s1_442 = __p1_442; \
- float32x4_t __s2_442 = __p2_442; \
- float32x2_t __rev0_442; __rev0_442 = __builtin_shufflevector(__s0_442, __s0_442, 1, 0); \
- float32x2_t __rev1_442; __rev1_442 = __builtin_shufflevector(__s1_442, __s1_442, 1, 0); \
- float32x4_t __rev2_442; __rev2_442 = __builtin_shufflevector(__s2_442, __s2_442, 3, 2, 1, 0); \
- __ret_442 = __rev0_442 + __rev1_442 * __noswap_splat_laneq_f32(__rev2_442, __p3_442); \
- __ret_442 = __builtin_shufflevector(__ret_442, __ret_442, 1, 0); \
- __ret_442; \
+#define vld2q_f64(__p0) __extension__ ({ \
+ float64x2x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 42); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmla_laneq_s32(__p0_443, __p1_443, __p2_443, __p3_443) __extension__ ({ \
- int32x2_t __ret_443; \
- int32x2_t __s0_443 = __p0_443; \
- int32x2_t __s1_443 = __p1_443; \
- int32x4_t __s2_443 = __p2_443; \
- __ret_443 = __s0_443 + __s1_443 * splat_laneq_s32(__s2_443, __p3_443); \
- __ret_443; \
+#define vld2q_s64(__p0) __extension__ ({ \
+ int64x2x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 35); \
+ __ret; \
})
#else
-#define vmla_laneq_s32(__p0_444, __p1_444, __p2_444, __p3_444) __extension__ ({ \
- int32x2_t __ret_444; \
- int32x2_t __s0_444 = __p0_444; \
- int32x2_t __s1_444 = __p1_444; \
- int32x4_t __s2_444 = __p2_444; \
- int32x2_t __rev0_444; __rev0_444 = __builtin_shufflevector(__s0_444, __s0_444, 1, 0); \
- int32x2_t __rev1_444; __rev1_444 = __builtin_shufflevector(__s1_444, __s1_444, 1, 0); \
- int32x4_t __rev2_444; __rev2_444 = __builtin_shufflevector(__s2_444, __s2_444, 3, 2, 1, 0); \
- __ret_444 = __rev0_444 + __rev1_444 * __noswap_splat_laneq_s32(__rev2_444, __p3_444); \
- __ret_444 = __builtin_shufflevector(__ret_444, __ret_444, 1, 0); \
- __ret_444; \
+#define vld2q_s64(__p0) __extension__ ({ \
+ int64x2x2_t __ret; \
+ __builtin_neon_vld2q_v(&__ret, __p0, 35); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
})
#endif
-#ifdef __LITTLE_ENDIAN__
-#define vmla_laneq_s16(__p0_445, __p1_445, __p2_445, __p3_445) __extension__ ({ \
- int16x4_t __ret_445; \
- int16x4_t __s0_445 = __p0_445; \
- int16x4_t __s1_445 = __p1_445; \
- int16x8_t __s2_445 = __p2_445; \
- __ret_445 = __s0_445 + __s1_445 * splat_laneq_s16(__s2_445, __p3_445); \
- __ret_445; \
+#define vld2_f64(__p0) __extension__ ({ \
+ float64x1x2_t __ret; \
+ __builtin_neon_vld2_v(&__ret, __p0, 10); \
+ __ret; \
})
-#else
-#define vmla_laneq_s16(__p0_446, __p1_446, __p2_446, __p3_446) __extension__ ({ \
- int16x4_t __ret_446; \
- int16x4_t __s0_446 = __p0_446; \
- int16x4_t __s1_446 = __p1_446; \
- int16x8_t __s2_446 = __p2_446; \
- int16x4_t __rev0_446; __rev0_446 = __builtin_shufflevector(__s0_446, __s0_446, 3, 2, 1, 0); \
- int16x4_t __rev1_446; __rev1_446 = __builtin_shufflevector(__s1_446, __s1_446, 3, 2, 1, 0); \
- int16x8_t __rev2_446; __rev2_446 = __builtin_shufflevector(__s2_446, __s2_446, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_446 = __rev0_446 + __rev1_446 * __noswap_splat_laneq_s16(__rev2_446, __p3_446); \
- __ret_446 = __builtin_shufflevector(__ret_446, __ret_446, 3, 2, 1, 0); \
- __ret_446; \
+#define vld2_dup_p64(__p0) __extension__ ({ \
+ poly64x1x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 6); \
+ __ret; \
})
-#endif
-
#ifdef __LITTLE_ENDIAN__
-#define vmlal_high_lane_u32(__p0_447, __p1_447, __p2_447, __p3_447) __extension__ ({ \
- uint64x2_t __ret_447; \
- uint64x2_t __s0_447 = __p0_447; \
- uint32x4_t __s1_447 = __p1_447; \
- uint32x2_t __s2_447 = __p2_447; \
- __ret_447 = __s0_447 + vmull_u32(vget_high_u32(__s1_447), splat_lane_u32(__s2_447, __p3_447)); \
- __ret_447; \
+#define vld2q_dup_p64(__p0) __extension__ ({ \
+ poly64x2x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 38); \
+ __ret; \
})
#else
-#define vmlal_high_lane_u32(__p0_448, __p1_448, __p2_448, __p3_448) __extension__ ({ \
- uint64x2_t __ret_448; \
- uint64x2_t __s0_448 = __p0_448; \
- uint32x4_t __s1_448 = __p1_448; \
- uint32x2_t __s2_448 = __p2_448; \
- uint64x2_t __rev0_448; __rev0_448 = __builtin_shufflevector(__s0_448, __s0_448, 1, 0); \
- uint32x4_t __rev1_448; __rev1_448 = __builtin_shufflevector(__s1_448, __s1_448, 3, 2, 1, 0); \
- uint32x2_t __rev2_448; __rev2_448 = __builtin_shufflevector(__s2_448, __s2_448, 1, 0); \
- __ret_448 = __rev0_448 + __noswap_vmull_u32(__noswap_vget_high_u32(__rev1_448), __noswap_splat_lane_u32(__rev2_448, __p3_448)); \
- __ret_448 = __builtin_shufflevector(__ret_448, __ret_448, 1, 0); \
- __ret_448; \
+#define vld2q_dup_p64(__p0) __extension__ ({ \
+ poly64x2x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 38); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlal_high_lane_u16(__p0_449, __p1_449, __p2_449, __p3_449) __extension__ ({ \
- uint32x4_t __ret_449; \
- uint32x4_t __s0_449 = __p0_449; \
- uint16x8_t __s1_449 = __p1_449; \
- uint16x4_t __s2_449 = __p2_449; \
- __ret_449 = __s0_449 + vmull_u16(vget_high_u16(__s1_449), splat_lane_u16(__s2_449, __p3_449)); \
- __ret_449; \
+#define vld2q_dup_f64(__p0) __extension__ ({ \
+ float64x2x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 42); \
+ __ret; \
})
#else
-#define vmlal_high_lane_u16(__p0_450, __p1_450, __p2_450, __p3_450) __extension__ ({ \
- uint32x4_t __ret_450; \
- uint32x4_t __s0_450 = __p0_450; \
- uint16x8_t __s1_450 = __p1_450; \
- uint16x4_t __s2_450 = __p2_450; \
- uint32x4_t __rev0_450; __rev0_450 = __builtin_shufflevector(__s0_450, __s0_450, 3, 2, 1, 0); \
- uint16x8_t __rev1_450; __rev1_450 = __builtin_shufflevector(__s1_450, __s1_450, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x4_t __rev2_450; __rev2_450 = __builtin_shufflevector(__s2_450, __s2_450, 3, 2, 1, 0); \
- __ret_450 = __rev0_450 + __noswap_vmull_u16(__noswap_vget_high_u16(__rev1_450), __noswap_splat_lane_u16(__rev2_450, __p3_450)); \
- __ret_450 = __builtin_shufflevector(__ret_450, __ret_450, 3, 2, 1, 0); \
- __ret_450; \
+#define vld2q_dup_f64(__p0) __extension__ ({ \
+ float64x2x2_t __ret; \
+ __builtin_neon_vld2q_dup_v(&__ret, __p0, 42); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
})
#endif
-#ifdef __LITTLE_ENDIAN__
-#define vmlal_high_lane_s32(__p0_451, __p1_451, __p2_451, __p3_451) __extension__ ({ \
- int64x2_t __ret_451; \
- int64x2_t __s0_451 = __p0_451; \
- int32x4_t __s1_451 = __p1_451; \
- int32x2_t __s2_451 = __p2_451; \
- __ret_451 = __s0_451 + vmull_s32(vget_high_s32(__s1_451), splat_lane_s32(__s2_451, __p3_451)); \
- __ret_451; \
+#define vld2_dup_f64(__p0) __extension__ ({ \
+ float64x1x2_t __ret; \
+ __builtin_neon_vld2_dup_v(&__ret, __p0, 10); \
+ __ret; \
})
-#else
-#define vmlal_high_lane_s32(__p0_452, __p1_452, __p2_452, __p3_452) __extension__ ({ \
- int64x2_t __ret_452; \
- int64x2_t __s0_452 = __p0_452; \
- int32x4_t __s1_452 = __p1_452; \
- int32x2_t __s2_452 = __p2_452; \
- int64x2_t __rev0_452; __rev0_452 = __builtin_shufflevector(__s0_452, __s0_452, 1, 0); \
- int32x4_t __rev1_452; __rev1_452 = __builtin_shufflevector(__s1_452, __s1_452, 3, 2, 1, 0); \
- int32x2_t __rev2_452; __rev2_452 = __builtin_shufflevector(__s2_452, __s2_452, 1, 0); \
- __ret_452 = __rev0_452 + __noswap_vmull_s32(__noswap_vget_high_s32(__rev1_452), __noswap_splat_lane_s32(__rev2_452, __p3_452)); \
- __ret_452 = __builtin_shufflevector(__ret_452, __ret_452, 1, 0); \
- __ret_452; \
+#define vld2_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x1x2_t __ret; \
+ poly64x1x2_t __s1 = __p1; \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 6); \
+ __ret; \
})
-#endif
-
#ifdef __LITTLE_ENDIAN__
-#define vmlal_high_lane_s16(__p0_453, __p1_453, __p2_453, __p3_453) __extension__ ({ \
- int32x4_t __ret_453; \
- int32x4_t __s0_453 = __p0_453; \
- int16x8_t __s1_453 = __p1_453; \
- int16x4_t __s2_453 = __p2_453; \
- __ret_453 = __s0_453 + vmull_s16(vget_high_s16(__s1_453), splat_lane_s16(__s2_453, __p3_453)); \
- __ret_453; \
+#define vld2q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16x2_t __ret; \
+ poly8x16x2_t __s1 = __p1; \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 36); \
+ __ret; \
})
#else
-#define vmlal_high_lane_s16(__p0_454, __p1_454, __p2_454, __p3_454) __extension__ ({ \
- int32x4_t __ret_454; \
- int32x4_t __s0_454 = __p0_454; \
- int16x8_t __s1_454 = __p1_454; \
- int16x4_t __s2_454 = __p2_454; \
- int32x4_t __rev0_454; __rev0_454 = __builtin_shufflevector(__s0_454, __s0_454, 3, 2, 1, 0); \
- int16x8_t __rev1_454; __rev1_454 = __builtin_shufflevector(__s1_454, __s1_454, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x4_t __rev2_454; __rev2_454 = __builtin_shufflevector(__s2_454, __s2_454, 3, 2, 1, 0); \
- __ret_454 = __rev0_454 + __noswap_vmull_s16(__noswap_vget_high_s16(__rev1_454), __noswap_splat_lane_s16(__rev2_454, __p3_454)); \
- __ret_454 = __builtin_shufflevector(__ret_454, __ret_454, 3, 2, 1, 0); \
- __ret_454; \
+#define vld2q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16x2_t __ret; \
+ poly8x16x2_t __s1 = __p1; \
+ poly8x16x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 36); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlal_high_laneq_u32(__p0_455, __p1_455, __p2_455, __p3_455) __extension__ ({ \
- uint64x2_t __ret_455; \
- uint64x2_t __s0_455 = __p0_455; \
- uint32x4_t __s1_455 = __p1_455; \
- uint32x4_t __s2_455 = __p2_455; \
- __ret_455 = __s0_455 + vmull_u32(vget_high_u32(__s1_455), splat_laneq_u32(__s2_455, __p3_455)); \
- __ret_455; \
+#define vld2q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2x2_t __ret; \
+ poly64x2x2_t __s1 = __p1; \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 38); \
+ __ret; \
})
#else
-#define vmlal_high_laneq_u32(__p0_456, __p1_456, __p2_456, __p3_456) __extension__ ({ \
- uint64x2_t __ret_456; \
- uint64x2_t __s0_456 = __p0_456; \
- uint32x4_t __s1_456 = __p1_456; \
- uint32x4_t __s2_456 = __p2_456; \
- uint64x2_t __rev0_456; __rev0_456 = __builtin_shufflevector(__s0_456, __s0_456, 1, 0); \
- uint32x4_t __rev1_456; __rev1_456 = __builtin_shufflevector(__s1_456, __s1_456, 3, 2, 1, 0); \
- uint32x4_t __rev2_456; __rev2_456 = __builtin_shufflevector(__s2_456, __s2_456, 3, 2, 1, 0); \
- __ret_456 = __rev0_456 + __noswap_vmull_u32(__noswap_vget_high_u32(__rev1_456), __noswap_splat_laneq_u32(__rev2_456, __p3_456)); \
- __ret_456 = __builtin_shufflevector(__ret_456, __ret_456, 1, 0); \
- __ret_456; \
+#define vld2q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2x2_t __ret; \
+ poly64x2x2_t __s1 = __p1; \
+ poly64x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 38); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlal_high_laneq_u16(__p0_457, __p1_457, __p2_457, __p3_457) __extension__ ({ \
- uint32x4_t __ret_457; \
- uint32x4_t __s0_457 = __p0_457; \
- uint16x8_t __s1_457 = __p1_457; \
- uint16x8_t __s2_457 = __p2_457; \
- __ret_457 = __s0_457 + vmull_u16(vget_high_u16(__s1_457), splat_laneq_u16(__s2_457, __p3_457)); \
- __ret_457; \
+#define vld2q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16x2_t __ret; \
+ uint8x16x2_t __s1 = __p1; \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 48); \
+ __ret; \
})
#else
-#define vmlal_high_laneq_u16(__p0_458, __p1_458, __p2_458, __p3_458) __extension__ ({ \
- uint32x4_t __ret_458; \
- uint32x4_t __s0_458 = __p0_458; \
- uint16x8_t __s1_458 = __p1_458; \
- uint16x8_t __s2_458 = __p2_458; \
- uint32x4_t __rev0_458; __rev0_458 = __builtin_shufflevector(__s0_458, __s0_458, 3, 2, 1, 0); \
- uint16x8_t __rev1_458; __rev1_458 = __builtin_shufflevector(__s1_458, __s1_458, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x8_t __rev2_458; __rev2_458 = __builtin_shufflevector(__s2_458, __s2_458, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_458 = __rev0_458 + __noswap_vmull_u16(__noswap_vget_high_u16(__rev1_458), __noswap_splat_laneq_u16(__rev2_458, __p3_458)); \
- __ret_458 = __builtin_shufflevector(__ret_458, __ret_458, 3, 2, 1, 0); \
- __ret_458; \
+#define vld2q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16x2_t __ret; \
+ uint8x16x2_t __s1 = __p1; \
+ uint8x16x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 48); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlal_high_laneq_s32(__p0_459, __p1_459, __p2_459, __p3_459) __extension__ ({ \
- int64x2_t __ret_459; \
- int64x2_t __s0_459 = __p0_459; \
- int32x4_t __s1_459 = __p1_459; \
- int32x4_t __s2_459 = __p2_459; \
- __ret_459 = __s0_459 + vmull_s32(vget_high_s32(__s1_459), splat_laneq_s32(__s2_459, __p3_459)); \
- __ret_459; \
+#define vld2q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2x2_t __ret; \
+ uint64x2x2_t __s1 = __p1; \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 51); \
+ __ret; \
})
#else
-#define vmlal_high_laneq_s32(__p0_460, __p1_460, __p2_460, __p3_460) __extension__ ({ \
- int64x2_t __ret_460; \
- int64x2_t __s0_460 = __p0_460; \
- int32x4_t __s1_460 = __p1_460; \
- int32x4_t __s2_460 = __p2_460; \
- int64x2_t __rev0_460; __rev0_460 = __builtin_shufflevector(__s0_460, __s0_460, 1, 0); \
- int32x4_t __rev1_460; __rev1_460 = __builtin_shufflevector(__s1_460, __s1_460, 3, 2, 1, 0); \
- int32x4_t __rev2_460; __rev2_460 = __builtin_shufflevector(__s2_460, __s2_460, 3, 2, 1, 0); \
- __ret_460 = __rev0_460 + __noswap_vmull_s32(__noswap_vget_high_s32(__rev1_460), __noswap_splat_laneq_s32(__rev2_460, __p3_460)); \
- __ret_460 = __builtin_shufflevector(__ret_460, __ret_460, 1, 0); \
- __ret_460; \
+#define vld2q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2x2_t __ret; \
+ uint64x2x2_t __s1 = __p1; \
+ uint64x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 51); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlal_high_laneq_s16(__p0_461, __p1_461, __p2_461, __p3_461) __extension__ ({ \
- int32x4_t __ret_461; \
- int32x4_t __s0_461 = __p0_461; \
- int16x8_t __s1_461 = __p1_461; \
- int16x8_t __s2_461 = __p2_461; \
- __ret_461 = __s0_461 + vmull_s16(vget_high_s16(__s1_461), splat_laneq_s16(__s2_461, __p3_461)); \
- __ret_461; \
+#define vld2q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16x2_t __ret; \
+ int8x16x2_t __s1 = __p1; \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 32); \
+ __ret; \
})
#else
-#define vmlal_high_laneq_s16(__p0_462, __p1_462, __p2_462, __p3_462) __extension__ ({ \
- int32x4_t __ret_462; \
- int32x4_t __s0_462 = __p0_462; \
- int16x8_t __s1_462 = __p1_462; \
- int16x8_t __s2_462 = __p2_462; \
- int32x4_t __rev0_462; __rev0_462 = __builtin_shufflevector(__s0_462, __s0_462, 3, 2, 1, 0); \
- int16x8_t __rev1_462; __rev1_462 = __builtin_shufflevector(__s1_462, __s1_462, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev2_462; __rev2_462 = __builtin_shufflevector(__s2_462, __s2_462, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_462 = __rev0_462 + __noswap_vmull_s16(__noswap_vget_high_s16(__rev1_462), __noswap_splat_laneq_s16(__rev2_462, __p3_462)); \
- __ret_462 = __builtin_shufflevector(__ret_462, __ret_462, 3, 2, 1, 0); \
- __ret_462; \
+#define vld2q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16x2_t __ret; \
+ int8x16x2_t __s1 = __p1; \
+ int8x16x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 32); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlal_laneq_u32(__p0_463, __p1_463, __p2_463, __p3_463) __extension__ ({ \
- uint64x2_t __ret_463; \
- uint64x2_t __s0_463 = __p0_463; \
- uint32x2_t __s1_463 = __p1_463; \
- uint32x4_t __s2_463 = __p2_463; \
- __ret_463 = __s0_463 + vmull_u32(__s1_463, splat_laneq_u32(__s2_463, __p3_463)); \
- __ret_463; \
+#define vld2q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2x2_t __ret; \
+ float64x2x2_t __s1 = __p1; \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 42); \
+ __ret; \
})
#else
-#define vmlal_laneq_u32(__p0_464, __p1_464, __p2_464, __p3_464) __extension__ ({ \
- uint64x2_t __ret_464; \
- uint64x2_t __s0_464 = __p0_464; \
- uint32x2_t __s1_464 = __p1_464; \
- uint32x4_t __s2_464 = __p2_464; \
- uint64x2_t __rev0_464; __rev0_464 = __builtin_shufflevector(__s0_464, __s0_464, 1, 0); \
- uint32x2_t __rev1_464; __rev1_464 = __builtin_shufflevector(__s1_464, __s1_464, 1, 0); \
- uint32x4_t __rev2_464; __rev2_464 = __builtin_shufflevector(__s2_464, __s2_464, 3, 2, 1, 0); \
- __ret_464 = __rev0_464 + __noswap_vmull_u32(__rev1_464, __noswap_splat_laneq_u32(__rev2_464, __p3_464)); \
- __ret_464 = __builtin_shufflevector(__ret_464, __ret_464, 1, 0); \
- __ret_464; \
+#define vld2q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2x2_t __ret; \
+ float64x2x2_t __s1 = __p1; \
+ float64x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 42); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlal_laneq_u16(__p0_465, __p1_465, __p2_465, __p3_465) __extension__ ({ \
- uint32x4_t __ret_465; \
- uint32x4_t __s0_465 = __p0_465; \
- uint16x4_t __s1_465 = __p1_465; \
- uint16x8_t __s2_465 = __p2_465; \
- __ret_465 = __s0_465 + vmull_u16(__s1_465, splat_laneq_u16(__s2_465, __p3_465)); \
- __ret_465; \
+#define vld2q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2x2_t __ret; \
+ int64x2x2_t __s1 = __p1; \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 35); \
+ __ret; \
})
#else
-#define vmlal_laneq_u16(__p0_466, __p1_466, __p2_466, __p3_466) __extension__ ({ \
- uint32x4_t __ret_466; \
- uint32x4_t __s0_466 = __p0_466; \
- uint16x4_t __s1_466 = __p1_466; \
- uint16x8_t __s2_466 = __p2_466; \
- uint32x4_t __rev0_466; __rev0_466 = __builtin_shufflevector(__s0_466, __s0_466, 3, 2, 1, 0); \
- uint16x4_t __rev1_466; __rev1_466 = __builtin_shufflevector(__s1_466, __s1_466, 3, 2, 1, 0); \
- uint16x8_t __rev2_466; __rev2_466 = __builtin_shufflevector(__s2_466, __s2_466, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_466 = __rev0_466 + __noswap_vmull_u16(__rev1_466, __noswap_splat_laneq_u16(__rev2_466, __p3_466)); \
- __ret_466 = __builtin_shufflevector(__ret_466, __ret_466, 3, 2, 1, 0); \
- __ret_466; \
+#define vld2q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2x2_t __ret; \
+ int64x2x2_t __s1 = __p1; \
+ int64x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 35); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret; \
})
#endif
-#ifdef __LITTLE_ENDIAN__
-#define vmlal_laneq_s32(__p0_467, __p1_467, __p2_467, __p3_467) __extension__ ({ \
- int64x2_t __ret_467; \
- int64x2_t __s0_467 = __p0_467; \
- int32x2_t __s1_467 = __p1_467; \
- int32x4_t __s2_467 = __p2_467; \
- __ret_467 = __s0_467 + vmull_s32(__s1_467, splat_laneq_s32(__s2_467, __p3_467)); \
- __ret_467; \
+#define vld2_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x1x2_t __ret; \
+ uint64x1x2_t __s1 = __p1; \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 19); \
+ __ret; \
})
-#else
-#define vmlal_laneq_s32(__p0_468, __p1_468, __p2_468, __p3_468) __extension__ ({ \
- int64x2_t __ret_468; \
- int64x2_t __s0_468 = __p0_468; \
- int32x2_t __s1_468 = __p1_468; \
- int32x4_t __s2_468 = __p2_468; \
- int64x2_t __rev0_468; __rev0_468 = __builtin_shufflevector(__s0_468, __s0_468, 1, 0); \
- int32x2_t __rev1_468; __rev1_468 = __builtin_shufflevector(__s1_468, __s1_468, 1, 0); \
- int32x4_t __rev2_468; __rev2_468 = __builtin_shufflevector(__s2_468, __s2_468, 3, 2, 1, 0); \
- __ret_468 = __rev0_468 + __noswap_vmull_s32(__rev1_468, __noswap_splat_laneq_s32(__rev2_468, __p3_468)); \
- __ret_468 = __builtin_shufflevector(__ret_468, __ret_468, 1, 0); \
- __ret_468; \
+#define vld2_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x1x2_t __ret; \
+ float64x1x2_t __s1 = __p1; \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 10); \
+ __ret; \
})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vmlal_laneq_s16(__p0_469, __p1_469, __p2_469, __p3_469) __extension__ ({ \
- int32x4_t __ret_469; \
- int32x4_t __s0_469 = __p0_469; \
- int16x4_t __s1_469 = __p1_469; \
- int16x8_t __s2_469 = __p2_469; \
- __ret_469 = __s0_469 + vmull_s16(__s1_469, splat_laneq_s16(__s2_469, __p3_469)); \
- __ret_469; \
+#define vld2_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x1x2_t __ret; \
+ int64x1x2_t __s1 = __p1; \
+ __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 3); \
+ __ret; \
})
-#else
-#define vmlal_laneq_s16(__p0_470, __p1_470, __p2_470, __p3_470) __extension__ ({ \
- int32x4_t __ret_470; \
- int32x4_t __s0_470 = __p0_470; \
- int16x4_t __s1_470 = __p1_470; \
- int16x8_t __s2_470 = __p2_470; \
- int32x4_t __rev0_470; __rev0_470 = __builtin_shufflevector(__s0_470, __s0_470, 3, 2, 1, 0); \
- int16x4_t __rev1_470; __rev1_470 = __builtin_shufflevector(__s1_470, __s1_470, 3, 2, 1, 0); \
- int16x8_t __rev2_470; __rev2_470 = __builtin_shufflevector(__s2_470, __s2_470, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_470 = __rev0_470 + __noswap_vmull_s16(__rev1_470, __noswap_splat_laneq_s16(__rev2_470, __p3_470)); \
- __ret_470 = __builtin_shufflevector(__ret_470, __ret_470, 3, 2, 1, 0); \
- __ret_470; \
+#define vld3_p64(__p0) __extension__ ({ \
+ poly64x1x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 6); \
+ __ret; \
})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vmlsq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
- float64x2_t __ret;
- __ret = __p0 - __p1 * __p2;
- return __ret;
-}
-#else
-__ai float64x2_t vmlsq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- float64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = __rev0 - __rev1 * __rev2;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-__ai float64x1_t vmls_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
- float64x1_t __ret;
- __ret = __p0 - __p1 * __p2;
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-#define vmlsq_laneq_u32(__p0_471, __p1_471, __p2_471, __p3_471) __extension__ ({ \
- uint32x4_t __ret_471; \
- uint32x4_t __s0_471 = __p0_471; \
- uint32x4_t __s1_471 = __p1_471; \
- uint32x4_t __s2_471 = __p2_471; \
- __ret_471 = __s0_471 - __s1_471 * splatq_laneq_u32(__s2_471, __p3_471); \
- __ret_471; \
+#define vld3q_p64(__p0) __extension__ ({ \
+ poly64x2x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 38); \
+ __ret; \
})
#else
-#define vmlsq_laneq_u32(__p0_472, __p1_472, __p2_472, __p3_472) __extension__ ({ \
- uint32x4_t __ret_472; \
- uint32x4_t __s0_472 = __p0_472; \
- uint32x4_t __s1_472 = __p1_472; \
- uint32x4_t __s2_472 = __p2_472; \
- uint32x4_t __rev0_472; __rev0_472 = __builtin_shufflevector(__s0_472, __s0_472, 3, 2, 1, 0); \
- uint32x4_t __rev1_472; __rev1_472 = __builtin_shufflevector(__s1_472, __s1_472, 3, 2, 1, 0); \
- uint32x4_t __rev2_472; __rev2_472 = __builtin_shufflevector(__s2_472, __s2_472, 3, 2, 1, 0); \
- __ret_472 = __rev0_472 - __rev1_472 * __noswap_splatq_laneq_u32(__rev2_472, __p3_472); \
- __ret_472 = __builtin_shufflevector(__ret_472, __ret_472, 3, 2, 1, 0); \
- __ret_472; \
+#define vld3q_p64(__p0) __extension__ ({ \
+ poly64x2x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 38); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsq_laneq_u16(__p0_473, __p1_473, __p2_473, __p3_473) __extension__ ({ \
- uint16x8_t __ret_473; \
- uint16x8_t __s0_473 = __p0_473; \
- uint16x8_t __s1_473 = __p1_473; \
- uint16x8_t __s2_473 = __p2_473; \
- __ret_473 = __s0_473 - __s1_473 * splatq_laneq_u16(__s2_473, __p3_473); \
- __ret_473; \
+#define vld3q_u64(__p0) __extension__ ({ \
+ uint64x2x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 51); \
+ __ret; \
})
#else
-#define vmlsq_laneq_u16(__p0_474, __p1_474, __p2_474, __p3_474) __extension__ ({ \
- uint16x8_t __ret_474; \
- uint16x8_t __s0_474 = __p0_474; \
- uint16x8_t __s1_474 = __p1_474; \
- uint16x8_t __s2_474 = __p2_474; \
- uint16x8_t __rev0_474; __rev0_474 = __builtin_shufflevector(__s0_474, __s0_474, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x8_t __rev1_474; __rev1_474 = __builtin_shufflevector(__s1_474, __s1_474, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x8_t __rev2_474; __rev2_474 = __builtin_shufflevector(__s2_474, __s2_474, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_474 = __rev0_474 - __rev1_474 * __noswap_splatq_laneq_u16(__rev2_474, __p3_474); \
- __ret_474 = __builtin_shufflevector(__ret_474, __ret_474, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_474; \
+#define vld3q_u64(__p0) __extension__ ({ \
+ uint64x2x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 51); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsq_laneq_f32(__p0_475, __p1_475, __p2_475, __p3_475) __extension__ ({ \
- float32x4_t __ret_475; \
- float32x4_t __s0_475 = __p0_475; \
- float32x4_t __s1_475 = __p1_475; \
- float32x4_t __s2_475 = __p2_475; \
- __ret_475 = __s0_475 - __s1_475 * splatq_laneq_f32(__s2_475, __p3_475); \
- __ret_475; \
+#define vld3q_f64(__p0) __extension__ ({ \
+ float64x2x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 42); \
+ __ret; \
})
#else
-#define vmlsq_laneq_f32(__p0_476, __p1_476, __p2_476, __p3_476) __extension__ ({ \
- float32x4_t __ret_476; \
- float32x4_t __s0_476 = __p0_476; \
- float32x4_t __s1_476 = __p1_476; \
- float32x4_t __s2_476 = __p2_476; \
- float32x4_t __rev0_476; __rev0_476 = __builtin_shufflevector(__s0_476, __s0_476, 3, 2, 1, 0); \
- float32x4_t __rev1_476; __rev1_476 = __builtin_shufflevector(__s1_476, __s1_476, 3, 2, 1, 0); \
- float32x4_t __rev2_476; __rev2_476 = __builtin_shufflevector(__s2_476, __s2_476, 3, 2, 1, 0); \
- __ret_476 = __rev0_476 - __rev1_476 * __noswap_splatq_laneq_f32(__rev2_476, __p3_476); \
- __ret_476 = __builtin_shufflevector(__ret_476, __ret_476, 3, 2, 1, 0); \
- __ret_476; \
+#define vld3q_f64(__p0) __extension__ ({ \
+ float64x2x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 42); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsq_laneq_s32(__p0_477, __p1_477, __p2_477, __p3_477) __extension__ ({ \
- int32x4_t __ret_477; \
- int32x4_t __s0_477 = __p0_477; \
- int32x4_t __s1_477 = __p1_477; \
- int32x4_t __s2_477 = __p2_477; \
- __ret_477 = __s0_477 - __s1_477 * splatq_laneq_s32(__s2_477, __p3_477); \
- __ret_477; \
+#define vld3q_s64(__p0) __extension__ ({ \
+ int64x2x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 35); \
+ __ret; \
})
#else
-#define vmlsq_laneq_s32(__p0_478, __p1_478, __p2_478, __p3_478) __extension__ ({ \
- int32x4_t __ret_478; \
- int32x4_t __s0_478 = __p0_478; \
- int32x4_t __s1_478 = __p1_478; \
- int32x4_t __s2_478 = __p2_478; \
- int32x4_t __rev0_478; __rev0_478 = __builtin_shufflevector(__s0_478, __s0_478, 3, 2, 1, 0); \
- int32x4_t __rev1_478; __rev1_478 = __builtin_shufflevector(__s1_478, __s1_478, 3, 2, 1, 0); \
- int32x4_t __rev2_478; __rev2_478 = __builtin_shufflevector(__s2_478, __s2_478, 3, 2, 1, 0); \
- __ret_478 = __rev0_478 - __rev1_478 * __noswap_splatq_laneq_s32(__rev2_478, __p3_478); \
- __ret_478 = __builtin_shufflevector(__ret_478, __ret_478, 3, 2, 1, 0); \
- __ret_478; \
+#define vld3q_s64(__p0) __extension__ ({ \
+ int64x2x3_t __ret; \
+ __builtin_neon_vld3q_v(&__ret, __p0, 35); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
})
#endif
-#ifdef __LITTLE_ENDIAN__
-#define vmlsq_laneq_s16(__p0_479, __p1_479, __p2_479, __p3_479) __extension__ ({ \
- int16x8_t __ret_479; \
- int16x8_t __s0_479 = __p0_479; \
- int16x8_t __s1_479 = __p1_479; \
- int16x8_t __s2_479 = __p2_479; \
- __ret_479 = __s0_479 - __s1_479 * splatq_laneq_s16(__s2_479, __p3_479); \
- __ret_479; \
+#define vld3_f64(__p0) __extension__ ({ \
+ float64x1x3_t __ret; \
+ __builtin_neon_vld3_v(&__ret, __p0, 10); \
+ __ret; \
})
-#else
-#define vmlsq_laneq_s16(__p0_480, __p1_480, __p2_480, __p3_480) __extension__ ({ \
- int16x8_t __ret_480; \
- int16x8_t __s0_480 = __p0_480; \
- int16x8_t __s1_480 = __p1_480; \
- int16x8_t __s2_480 = __p2_480; \
- int16x8_t __rev0_480; __rev0_480 = __builtin_shufflevector(__s0_480, __s0_480, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1_480; __rev1_480 = __builtin_shufflevector(__s1_480, __s1_480, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev2_480; __rev2_480 = __builtin_shufflevector(__s2_480, __s2_480, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_480 = __rev0_480 - __rev1_480 * __noswap_splatq_laneq_s16(__rev2_480, __p3_480); \
- __ret_480 = __builtin_shufflevector(__ret_480, __ret_480, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_480; \
+#define vld3_dup_p64(__p0) __extension__ ({ \
+ poly64x1x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 6); \
+ __ret; \
})
-#endif
-
#ifdef __LITTLE_ENDIAN__
-#define vmls_laneq_u32(__p0_481, __p1_481, __p2_481, __p3_481) __extension__ ({ \
- uint32x2_t __ret_481; \
- uint32x2_t __s0_481 = __p0_481; \
- uint32x2_t __s1_481 = __p1_481; \
- uint32x4_t __s2_481 = __p2_481; \
- __ret_481 = __s0_481 - __s1_481 * splat_laneq_u32(__s2_481, __p3_481); \
- __ret_481; \
+#define vld3q_dup_p64(__p0) __extension__ ({ \
+ poly64x2x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 38); \
+ __ret; \
})
#else
-#define vmls_laneq_u32(__p0_482, __p1_482, __p2_482, __p3_482) __extension__ ({ \
- uint32x2_t __ret_482; \
- uint32x2_t __s0_482 = __p0_482; \
- uint32x2_t __s1_482 = __p1_482; \
- uint32x4_t __s2_482 = __p2_482; \
- uint32x2_t __rev0_482; __rev0_482 = __builtin_shufflevector(__s0_482, __s0_482, 1, 0); \
- uint32x2_t __rev1_482; __rev1_482 = __builtin_shufflevector(__s1_482, __s1_482, 1, 0); \
- uint32x4_t __rev2_482; __rev2_482 = __builtin_shufflevector(__s2_482, __s2_482, 3, 2, 1, 0); \
- __ret_482 = __rev0_482 - __rev1_482 * __noswap_splat_laneq_u32(__rev2_482, __p3_482); \
- __ret_482 = __builtin_shufflevector(__ret_482, __ret_482, 1, 0); \
- __ret_482; \
+#define vld3q_dup_p64(__p0) __extension__ ({ \
+ poly64x2x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 38); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmls_laneq_u16(__p0_483, __p1_483, __p2_483, __p3_483) __extension__ ({ \
- uint16x4_t __ret_483; \
- uint16x4_t __s0_483 = __p0_483; \
- uint16x4_t __s1_483 = __p1_483; \
- uint16x8_t __s2_483 = __p2_483; \
- __ret_483 = __s0_483 - __s1_483 * splat_laneq_u16(__s2_483, __p3_483); \
- __ret_483; \
+#define vld3q_dup_f64(__p0) __extension__ ({ \
+ float64x2x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 42); \
+ __ret; \
})
#else
-#define vmls_laneq_u16(__p0_484, __p1_484, __p2_484, __p3_484) __extension__ ({ \
- uint16x4_t __ret_484; \
- uint16x4_t __s0_484 = __p0_484; \
- uint16x4_t __s1_484 = __p1_484; \
- uint16x8_t __s2_484 = __p2_484; \
- uint16x4_t __rev0_484; __rev0_484 = __builtin_shufflevector(__s0_484, __s0_484, 3, 2, 1, 0); \
- uint16x4_t __rev1_484; __rev1_484 = __builtin_shufflevector(__s1_484, __s1_484, 3, 2, 1, 0); \
- uint16x8_t __rev2_484; __rev2_484 = __builtin_shufflevector(__s2_484, __s2_484, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_484 = __rev0_484 - __rev1_484 * __noswap_splat_laneq_u16(__rev2_484, __p3_484); \
- __ret_484 = __builtin_shufflevector(__ret_484, __ret_484, 3, 2, 1, 0); \
- __ret_484; \
+#define vld3q_dup_f64(__p0) __extension__ ({ \
+ float64x2x3_t __ret; \
+ __builtin_neon_vld3q_dup_v(&__ret, __p0, 42); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
})
#endif
-#ifdef __LITTLE_ENDIAN__
-#define vmls_laneq_f32(__p0_485, __p1_485, __p2_485, __p3_485) __extension__ ({ \
- float32x2_t __ret_485; \
- float32x2_t __s0_485 = __p0_485; \
- float32x2_t __s1_485 = __p1_485; \
- float32x4_t __s2_485 = __p2_485; \
- __ret_485 = __s0_485 - __s1_485 * splat_laneq_f32(__s2_485, __p3_485); \
- __ret_485; \
+#define vld3_dup_f64(__p0) __extension__ ({ \
+ float64x1x3_t __ret; \
+ __builtin_neon_vld3_dup_v(&__ret, __p0, 10); \
+ __ret; \
})
-#else
-#define vmls_laneq_f32(__p0_486, __p1_486, __p2_486, __p3_486) __extension__ ({ \
- float32x2_t __ret_486; \
- float32x2_t __s0_486 = __p0_486; \
- float32x2_t __s1_486 = __p1_486; \
- float32x4_t __s2_486 = __p2_486; \
- float32x2_t __rev0_486; __rev0_486 = __builtin_shufflevector(__s0_486, __s0_486, 1, 0); \
- float32x2_t __rev1_486; __rev1_486 = __builtin_shufflevector(__s1_486, __s1_486, 1, 0); \
- float32x4_t __rev2_486; __rev2_486 = __builtin_shufflevector(__s2_486, __s2_486, 3, 2, 1, 0); \
- __ret_486 = __rev0_486 - __rev1_486 * __noswap_splat_laneq_f32(__rev2_486, __p3_486); \
- __ret_486 = __builtin_shufflevector(__ret_486, __ret_486, 1, 0); \
- __ret_486; \
+#define vld3_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x1x3_t __ret; \
+ poly64x1x3_t __s1 = __p1; \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 6); \
+ __ret; \
})
-#endif
-
#ifdef __LITTLE_ENDIAN__
-#define vmls_laneq_s32(__p0_487, __p1_487, __p2_487, __p3_487) __extension__ ({ \
- int32x2_t __ret_487; \
- int32x2_t __s0_487 = __p0_487; \
- int32x2_t __s1_487 = __p1_487; \
- int32x4_t __s2_487 = __p2_487; \
- __ret_487 = __s0_487 - __s1_487 * splat_laneq_s32(__s2_487, __p3_487); \
- __ret_487; \
+#define vld3q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16x3_t __ret; \
+ poly8x16x3_t __s1 = __p1; \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 36); \
+ __ret; \
})
#else
-#define vmls_laneq_s32(__p0_488, __p1_488, __p2_488, __p3_488) __extension__ ({ \
- int32x2_t __ret_488; \
- int32x2_t __s0_488 = __p0_488; \
- int32x2_t __s1_488 = __p1_488; \
- int32x4_t __s2_488 = __p2_488; \
- int32x2_t __rev0_488; __rev0_488 = __builtin_shufflevector(__s0_488, __s0_488, 1, 0); \
- int32x2_t __rev1_488; __rev1_488 = __builtin_shufflevector(__s1_488, __s1_488, 1, 0); \
- int32x4_t __rev2_488; __rev2_488 = __builtin_shufflevector(__s2_488, __s2_488, 3, 2, 1, 0); \
- __ret_488 = __rev0_488 - __rev1_488 * __noswap_splat_laneq_s32(__rev2_488, __p3_488); \
- __ret_488 = __builtin_shufflevector(__ret_488, __ret_488, 1, 0); \
- __ret_488; \
+#define vld3q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16x3_t __ret; \
+ poly8x16x3_t __s1 = __p1; \
+ poly8x16x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 36); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmls_laneq_s16(__p0_489, __p1_489, __p2_489, __p3_489) __extension__ ({ \
- int16x4_t __ret_489; \
- int16x4_t __s0_489 = __p0_489; \
- int16x4_t __s1_489 = __p1_489; \
- int16x8_t __s2_489 = __p2_489; \
- __ret_489 = __s0_489 - __s1_489 * splat_laneq_s16(__s2_489, __p3_489); \
- __ret_489; \
+#define vld3q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2x3_t __ret; \
+ poly64x2x3_t __s1 = __p1; \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 38); \
+ __ret; \
})
#else
-#define vmls_laneq_s16(__p0_490, __p1_490, __p2_490, __p3_490) __extension__ ({ \
- int16x4_t __ret_490; \
- int16x4_t __s0_490 = __p0_490; \
- int16x4_t __s1_490 = __p1_490; \
- int16x8_t __s2_490 = __p2_490; \
- int16x4_t __rev0_490; __rev0_490 = __builtin_shufflevector(__s0_490, __s0_490, 3, 2, 1, 0); \
- int16x4_t __rev1_490; __rev1_490 = __builtin_shufflevector(__s1_490, __s1_490, 3, 2, 1, 0); \
- int16x8_t __rev2_490; __rev2_490 = __builtin_shufflevector(__s2_490, __s2_490, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_490 = __rev0_490 - __rev1_490 * __noswap_splat_laneq_s16(__rev2_490, __p3_490); \
- __ret_490 = __builtin_shufflevector(__ret_490, __ret_490, 3, 2, 1, 0); \
- __ret_490; \
+#define vld3q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2x3_t __ret; \
+ poly64x2x3_t __s1 = __p1; \
+ poly64x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 38); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsl_high_lane_u32(__p0_491, __p1_491, __p2_491, __p3_491) __extension__ ({ \
- uint64x2_t __ret_491; \
- uint64x2_t __s0_491 = __p0_491; \
- uint32x4_t __s1_491 = __p1_491; \
- uint32x2_t __s2_491 = __p2_491; \
- __ret_491 = __s0_491 - vmull_u32(vget_high_u32(__s1_491), splat_lane_u32(__s2_491, __p3_491)); \
- __ret_491; \
+#define vld3q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16x3_t __ret; \
+ uint8x16x3_t __s1 = __p1; \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 48); \
+ __ret; \
})
#else
-#define vmlsl_high_lane_u32(__p0_492, __p1_492, __p2_492, __p3_492) __extension__ ({ \
- uint64x2_t __ret_492; \
- uint64x2_t __s0_492 = __p0_492; \
- uint32x4_t __s1_492 = __p1_492; \
- uint32x2_t __s2_492 = __p2_492; \
- uint64x2_t __rev0_492; __rev0_492 = __builtin_shufflevector(__s0_492, __s0_492, 1, 0); \
- uint32x4_t __rev1_492; __rev1_492 = __builtin_shufflevector(__s1_492, __s1_492, 3, 2, 1, 0); \
- uint32x2_t __rev2_492; __rev2_492 = __builtin_shufflevector(__s2_492, __s2_492, 1, 0); \
- __ret_492 = __rev0_492 - __noswap_vmull_u32(__noswap_vget_high_u32(__rev1_492), __noswap_splat_lane_u32(__rev2_492, __p3_492)); \
- __ret_492 = __builtin_shufflevector(__ret_492, __ret_492, 1, 0); \
- __ret_492; \
+#define vld3q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16x3_t __ret; \
+ uint8x16x3_t __s1 = __p1; \
+ uint8x16x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 48); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsl_high_lane_u16(__p0_493, __p1_493, __p2_493, __p3_493) __extension__ ({ \
- uint32x4_t __ret_493; \
- uint32x4_t __s0_493 = __p0_493; \
- uint16x8_t __s1_493 = __p1_493; \
- uint16x4_t __s2_493 = __p2_493; \
- __ret_493 = __s0_493 - vmull_u16(vget_high_u16(__s1_493), splat_lane_u16(__s2_493, __p3_493)); \
- __ret_493; \
+#define vld3q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2x3_t __ret; \
+ uint64x2x3_t __s1 = __p1; \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 51); \
+ __ret; \
})
#else
-#define vmlsl_high_lane_u16(__p0_494, __p1_494, __p2_494, __p3_494) __extension__ ({ \
- uint32x4_t __ret_494; \
- uint32x4_t __s0_494 = __p0_494; \
- uint16x8_t __s1_494 = __p1_494; \
- uint16x4_t __s2_494 = __p2_494; \
- uint32x4_t __rev0_494; __rev0_494 = __builtin_shufflevector(__s0_494, __s0_494, 3, 2, 1, 0); \
- uint16x8_t __rev1_494; __rev1_494 = __builtin_shufflevector(__s1_494, __s1_494, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x4_t __rev2_494; __rev2_494 = __builtin_shufflevector(__s2_494, __s2_494, 3, 2, 1, 0); \
- __ret_494 = __rev0_494 - __noswap_vmull_u16(__noswap_vget_high_u16(__rev1_494), __noswap_splat_lane_u16(__rev2_494, __p3_494)); \
- __ret_494 = __builtin_shufflevector(__ret_494, __ret_494, 3, 2, 1, 0); \
- __ret_494; \
+#define vld3q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2x3_t __ret; \
+ uint64x2x3_t __s1 = __p1; \
+ uint64x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 51); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsl_high_lane_s32(__p0_495, __p1_495, __p2_495, __p3_495) __extension__ ({ \
- int64x2_t __ret_495; \
- int64x2_t __s0_495 = __p0_495; \
- int32x4_t __s1_495 = __p1_495; \
- int32x2_t __s2_495 = __p2_495; \
- __ret_495 = __s0_495 - vmull_s32(vget_high_s32(__s1_495), splat_lane_s32(__s2_495, __p3_495)); \
- __ret_495; \
+#define vld3q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16x3_t __ret; \
+ int8x16x3_t __s1 = __p1; \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 32); \
+ __ret; \
})
#else
-#define vmlsl_high_lane_s32(__p0_496, __p1_496, __p2_496, __p3_496) __extension__ ({ \
- int64x2_t __ret_496; \
- int64x2_t __s0_496 = __p0_496; \
- int32x4_t __s1_496 = __p1_496; \
- int32x2_t __s2_496 = __p2_496; \
- int64x2_t __rev0_496; __rev0_496 = __builtin_shufflevector(__s0_496, __s0_496, 1, 0); \
- int32x4_t __rev1_496; __rev1_496 = __builtin_shufflevector(__s1_496, __s1_496, 3, 2, 1, 0); \
- int32x2_t __rev2_496; __rev2_496 = __builtin_shufflevector(__s2_496, __s2_496, 1, 0); \
- __ret_496 = __rev0_496 - __noswap_vmull_s32(__noswap_vget_high_s32(__rev1_496), __noswap_splat_lane_s32(__rev2_496, __p3_496)); \
- __ret_496 = __builtin_shufflevector(__ret_496, __ret_496, 1, 0); \
- __ret_496; \
+#define vld3q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16x3_t __ret; \
+ int8x16x3_t __s1 = __p1; \
+ int8x16x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 32); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsl_high_lane_s16(__p0_497, __p1_497, __p2_497, __p3_497) __extension__ ({ \
- int32x4_t __ret_497; \
- int32x4_t __s0_497 = __p0_497; \
- int16x8_t __s1_497 = __p1_497; \
- int16x4_t __s2_497 = __p2_497; \
- __ret_497 = __s0_497 - vmull_s16(vget_high_s16(__s1_497), splat_lane_s16(__s2_497, __p3_497)); \
- __ret_497; \
+#define vld3q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2x3_t __ret; \
+ float64x2x3_t __s1 = __p1; \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 42); \
+ __ret; \
})
#else
-#define vmlsl_high_lane_s16(__p0_498, __p1_498, __p2_498, __p3_498) __extension__ ({ \
- int32x4_t __ret_498; \
- int32x4_t __s0_498 = __p0_498; \
- int16x8_t __s1_498 = __p1_498; \
- int16x4_t __s2_498 = __p2_498; \
- int32x4_t __rev0_498; __rev0_498 = __builtin_shufflevector(__s0_498, __s0_498, 3, 2, 1, 0); \
- int16x8_t __rev1_498; __rev1_498 = __builtin_shufflevector(__s1_498, __s1_498, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x4_t __rev2_498; __rev2_498 = __builtin_shufflevector(__s2_498, __s2_498, 3, 2, 1, 0); \
- __ret_498 = __rev0_498 - __noswap_vmull_s16(__noswap_vget_high_s16(__rev1_498), __noswap_splat_lane_s16(__rev2_498, __p3_498)); \
- __ret_498 = __builtin_shufflevector(__ret_498, __ret_498, 3, 2, 1, 0); \
- __ret_498; \
+#define vld3q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2x3_t __ret; \
+ float64x2x3_t __s1 = __p1; \
+ float64x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 42); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsl_high_laneq_u32(__p0_499, __p1_499, __p2_499, __p3_499) __extension__ ({ \
- uint64x2_t __ret_499; \
- uint64x2_t __s0_499 = __p0_499; \
- uint32x4_t __s1_499 = __p1_499; \
- uint32x4_t __s2_499 = __p2_499; \
- __ret_499 = __s0_499 - vmull_u32(vget_high_u32(__s1_499), splat_laneq_u32(__s2_499, __p3_499)); \
- __ret_499; \
+#define vld3q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2x3_t __ret; \
+ int64x2x3_t __s1 = __p1; \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 35); \
+ __ret; \
})
#else
-#define vmlsl_high_laneq_u32(__p0_500, __p1_500, __p2_500, __p3_500) __extension__ ({ \
- uint64x2_t __ret_500; \
- uint64x2_t __s0_500 = __p0_500; \
- uint32x4_t __s1_500 = __p1_500; \
- uint32x4_t __s2_500 = __p2_500; \
- uint64x2_t __rev0_500; __rev0_500 = __builtin_shufflevector(__s0_500, __s0_500, 1, 0); \
- uint32x4_t __rev1_500; __rev1_500 = __builtin_shufflevector(__s1_500, __s1_500, 3, 2, 1, 0); \
- uint32x4_t __rev2_500; __rev2_500 = __builtin_shufflevector(__s2_500, __s2_500, 3, 2, 1, 0); \
- __ret_500 = __rev0_500 - __noswap_vmull_u32(__noswap_vget_high_u32(__rev1_500), __noswap_splat_laneq_u32(__rev2_500, __p3_500)); \
- __ret_500 = __builtin_shufflevector(__ret_500, __ret_500, 1, 0); \
- __ret_500; \
+#define vld3q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2x3_t __ret; \
+ int64x2x3_t __s1 = __p1; \
+ int64x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 35); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret; \
})
#endif
-#ifdef __LITTLE_ENDIAN__
-#define vmlsl_high_laneq_u16(__p0_501, __p1_501, __p2_501, __p3_501) __extension__ ({ \
- uint32x4_t __ret_501; \
- uint32x4_t __s0_501 = __p0_501; \
- uint16x8_t __s1_501 = __p1_501; \
- uint16x8_t __s2_501 = __p2_501; \
- __ret_501 = __s0_501 - vmull_u16(vget_high_u16(__s1_501), splat_laneq_u16(__s2_501, __p3_501)); \
- __ret_501; \
+#define vld3_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x1x3_t __ret; \
+ uint64x1x3_t __s1 = __p1; \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 19); \
+ __ret; \
})
-#else
-#define vmlsl_high_laneq_u16(__p0_502, __p1_502, __p2_502, __p3_502) __extension__ ({ \
- uint32x4_t __ret_502; \
- uint32x4_t __s0_502 = __p0_502; \
- uint16x8_t __s1_502 = __p1_502; \
- uint16x8_t __s2_502 = __p2_502; \
- uint32x4_t __rev0_502; __rev0_502 = __builtin_shufflevector(__s0_502, __s0_502, 3, 2, 1, 0); \
- uint16x8_t __rev1_502; __rev1_502 = __builtin_shufflevector(__s1_502, __s1_502, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x8_t __rev2_502; __rev2_502 = __builtin_shufflevector(__s2_502, __s2_502, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_502 = __rev0_502 - __noswap_vmull_u16(__noswap_vget_high_u16(__rev1_502), __noswap_splat_laneq_u16(__rev2_502, __p3_502)); \
- __ret_502 = __builtin_shufflevector(__ret_502, __ret_502, 3, 2, 1, 0); \
- __ret_502; \
+#define vld3_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x1x3_t __ret; \
+ float64x1x3_t __s1 = __p1; \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 10); \
+ __ret; \
+})
+#define vld3_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x1x3_t __ret; \
+ int64x1x3_t __s1 = __p1; \
+ __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 3); \
+ __ret; \
+})
+#define vld4_p64(__p0) __extension__ ({ \
+ poly64x1x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 6); \
+ __ret; \
})
-#endif
-
#ifdef __LITTLE_ENDIAN__
-#define vmlsl_high_laneq_s32(__p0_503, __p1_503, __p2_503, __p3_503) __extension__ ({ \
- int64x2_t __ret_503; \
- int64x2_t __s0_503 = __p0_503; \
- int32x4_t __s1_503 = __p1_503; \
- int32x4_t __s2_503 = __p2_503; \
- __ret_503 = __s0_503 - vmull_s32(vget_high_s32(__s1_503), splat_laneq_s32(__s2_503, __p3_503)); \
- __ret_503; \
+#define vld4q_p64(__p0) __extension__ ({ \
+ poly64x2x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 38); \
+ __ret; \
})
#else
-#define vmlsl_high_laneq_s32(__p0_504, __p1_504, __p2_504, __p3_504) __extension__ ({ \
- int64x2_t __ret_504; \
- int64x2_t __s0_504 = __p0_504; \
- int32x4_t __s1_504 = __p1_504; \
- int32x4_t __s2_504 = __p2_504; \
- int64x2_t __rev0_504; __rev0_504 = __builtin_shufflevector(__s0_504, __s0_504, 1, 0); \
- int32x4_t __rev1_504; __rev1_504 = __builtin_shufflevector(__s1_504, __s1_504, 3, 2, 1, 0); \
- int32x4_t __rev2_504; __rev2_504 = __builtin_shufflevector(__s2_504, __s2_504, 3, 2, 1, 0); \
- __ret_504 = __rev0_504 - __noswap_vmull_s32(__noswap_vget_high_s32(__rev1_504), __noswap_splat_laneq_s32(__rev2_504, __p3_504)); \
- __ret_504 = __builtin_shufflevector(__ret_504, __ret_504, 1, 0); \
- __ret_504; \
+#define vld4q_p64(__p0) __extension__ ({ \
+ poly64x2x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 38); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsl_high_laneq_s16(__p0_505, __p1_505, __p2_505, __p3_505) __extension__ ({ \
- int32x4_t __ret_505; \
- int32x4_t __s0_505 = __p0_505; \
- int16x8_t __s1_505 = __p1_505; \
- int16x8_t __s2_505 = __p2_505; \
- __ret_505 = __s0_505 - vmull_s16(vget_high_s16(__s1_505), splat_laneq_s16(__s2_505, __p3_505)); \
- __ret_505; \
+#define vld4q_u64(__p0) __extension__ ({ \
+ uint64x2x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 51); \
+ __ret; \
})
#else
-#define vmlsl_high_laneq_s16(__p0_506, __p1_506, __p2_506, __p3_506) __extension__ ({ \
- int32x4_t __ret_506; \
- int32x4_t __s0_506 = __p0_506; \
- int16x8_t __s1_506 = __p1_506; \
- int16x8_t __s2_506 = __p2_506; \
- int32x4_t __rev0_506; __rev0_506 = __builtin_shufflevector(__s0_506, __s0_506, 3, 2, 1, 0); \
- int16x8_t __rev1_506; __rev1_506 = __builtin_shufflevector(__s1_506, __s1_506, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev2_506; __rev2_506 = __builtin_shufflevector(__s2_506, __s2_506, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_506 = __rev0_506 - __noswap_vmull_s16(__noswap_vget_high_s16(__rev1_506), __noswap_splat_laneq_s16(__rev2_506, __p3_506)); \
- __ret_506 = __builtin_shufflevector(__ret_506, __ret_506, 3, 2, 1, 0); \
- __ret_506; \
+#define vld4q_u64(__p0) __extension__ ({ \
+ uint64x2x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 51); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsl_laneq_u32(__p0_507, __p1_507, __p2_507, __p3_507) __extension__ ({ \
- uint64x2_t __ret_507; \
- uint64x2_t __s0_507 = __p0_507; \
- uint32x2_t __s1_507 = __p1_507; \
- uint32x4_t __s2_507 = __p2_507; \
- __ret_507 = __s0_507 - vmull_u32(__s1_507, splat_laneq_u32(__s2_507, __p3_507)); \
- __ret_507; \
+#define vld4q_f64(__p0) __extension__ ({ \
+ float64x2x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 42); \
+ __ret; \
})
#else
-#define vmlsl_laneq_u32(__p0_508, __p1_508, __p2_508, __p3_508) __extension__ ({ \
- uint64x2_t __ret_508; \
- uint64x2_t __s0_508 = __p0_508; \
- uint32x2_t __s1_508 = __p1_508; \
- uint32x4_t __s2_508 = __p2_508; \
- uint64x2_t __rev0_508; __rev0_508 = __builtin_shufflevector(__s0_508, __s0_508, 1, 0); \
- uint32x2_t __rev1_508; __rev1_508 = __builtin_shufflevector(__s1_508, __s1_508, 1, 0); \
- uint32x4_t __rev2_508; __rev2_508 = __builtin_shufflevector(__s2_508, __s2_508, 3, 2, 1, 0); \
- __ret_508 = __rev0_508 - __noswap_vmull_u32(__rev1_508, __noswap_splat_laneq_u32(__rev2_508, __p3_508)); \
- __ret_508 = __builtin_shufflevector(__ret_508, __ret_508, 1, 0); \
- __ret_508; \
+#define vld4q_f64(__p0) __extension__ ({ \
+ float64x2x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 42); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsl_laneq_u16(__p0_509, __p1_509, __p2_509, __p3_509) __extension__ ({ \
- uint32x4_t __ret_509; \
- uint32x4_t __s0_509 = __p0_509; \
- uint16x4_t __s1_509 = __p1_509; \
- uint16x8_t __s2_509 = __p2_509; \
- __ret_509 = __s0_509 - vmull_u16(__s1_509, splat_laneq_u16(__s2_509, __p3_509)); \
- __ret_509; \
+#define vld4q_s64(__p0) __extension__ ({ \
+ int64x2x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 35); \
+ __ret; \
})
#else
-#define vmlsl_laneq_u16(__p0_510, __p1_510, __p2_510, __p3_510) __extension__ ({ \
- uint32x4_t __ret_510; \
- uint32x4_t __s0_510 = __p0_510; \
- uint16x4_t __s1_510 = __p1_510; \
- uint16x8_t __s2_510 = __p2_510; \
- uint32x4_t __rev0_510; __rev0_510 = __builtin_shufflevector(__s0_510, __s0_510, 3, 2, 1, 0); \
- uint16x4_t __rev1_510; __rev1_510 = __builtin_shufflevector(__s1_510, __s1_510, 3, 2, 1, 0); \
- uint16x8_t __rev2_510; __rev2_510 = __builtin_shufflevector(__s2_510, __s2_510, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_510 = __rev0_510 - __noswap_vmull_u16(__rev1_510, __noswap_splat_laneq_u16(__rev2_510, __p3_510)); \
- __ret_510 = __builtin_shufflevector(__ret_510, __ret_510, 3, 2, 1, 0); \
- __ret_510; \
+#define vld4q_s64(__p0) __extension__ ({ \
+ int64x2x4_t __ret; \
+ __builtin_neon_vld4q_v(&__ret, __p0, 35); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
})
#endif
+#define vld4_f64(__p0) __extension__ ({ \
+ float64x1x4_t __ret; \
+ __builtin_neon_vld4_v(&__ret, __p0, 10); \
+ __ret; \
+})
+#define vld4_dup_p64(__p0) __extension__ ({ \
+ poly64x1x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 6); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vmlsl_laneq_s32(__p0_511, __p1_511, __p2_511, __p3_511) __extension__ ({ \
- int64x2_t __ret_511; \
- int64x2_t __s0_511 = __p0_511; \
- int32x2_t __s1_511 = __p1_511; \
- int32x4_t __s2_511 = __p2_511; \
- __ret_511 = __s0_511 - vmull_s32(__s1_511, splat_laneq_s32(__s2_511, __p3_511)); \
- __ret_511; \
+#define vld4q_dup_p64(__p0) __extension__ ({ \
+ poly64x2x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 38); \
+ __ret; \
})
#else
-#define vmlsl_laneq_s32(__p0_512, __p1_512, __p2_512, __p3_512) __extension__ ({ \
- int64x2_t __ret_512; \
- int64x2_t __s0_512 = __p0_512; \
- int32x2_t __s1_512 = __p1_512; \
- int32x4_t __s2_512 = __p2_512; \
- int64x2_t __rev0_512; __rev0_512 = __builtin_shufflevector(__s0_512, __s0_512, 1, 0); \
- int32x2_t __rev1_512; __rev1_512 = __builtin_shufflevector(__s1_512, __s1_512, 1, 0); \
- int32x4_t __rev2_512; __rev2_512 = __builtin_shufflevector(__s2_512, __s2_512, 3, 2, 1, 0); \
- __ret_512 = __rev0_512 - __noswap_vmull_s32(__rev1_512, __noswap_splat_laneq_s32(__rev2_512, __p3_512)); \
- __ret_512 = __builtin_shufflevector(__ret_512, __ret_512, 1, 0); \
- __ret_512; \
+#define vld4q_dup_p64(__p0) __extension__ ({ \
+ poly64x2x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 38); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsl_laneq_s16(__p0_513, __p1_513, __p2_513, __p3_513) __extension__ ({ \
- int32x4_t __ret_513; \
- int32x4_t __s0_513 = __p0_513; \
- int16x4_t __s1_513 = __p1_513; \
- int16x8_t __s2_513 = __p2_513; \
- __ret_513 = __s0_513 - vmull_s16(__s1_513, splat_laneq_s16(__s2_513, __p3_513)); \
- __ret_513; \
+#define vld4q_dup_f64(__p0) __extension__ ({ \
+ float64x2x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 42); \
+ __ret; \
})
#else
-#define vmlsl_laneq_s16(__p0_514, __p1_514, __p2_514, __p3_514) __extension__ ({ \
- int32x4_t __ret_514; \
- int32x4_t __s0_514 = __p0_514; \
- int16x4_t __s1_514 = __p1_514; \
- int16x8_t __s2_514 = __p2_514; \
- int32x4_t __rev0_514; __rev0_514 = __builtin_shufflevector(__s0_514, __s0_514, 3, 2, 1, 0); \
- int16x4_t __rev1_514; __rev1_514 = __builtin_shufflevector(__s1_514, __s1_514, 3, 2, 1, 0); \
- int16x8_t __rev2_514; __rev2_514 = __builtin_shufflevector(__s2_514, __s2_514, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_514 = __rev0_514 - __noswap_vmull_s16(__rev1_514, __noswap_splat_laneq_s16(__rev2_514, __p3_514)); \
- __ret_514 = __builtin_shufflevector(__ret_514, __ret_514, 3, 2, 1, 0); \
- __ret_514; \
+#define vld4q_dup_f64(__p0) __extension__ ({ \
+ float64x2x4_t __ret; \
+ __builtin_neon_vld4q_dup_v(&__ret, __p0, 42); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
})
#endif
-__ai poly64x1_t vmov_n_p64(poly64_t __p0) {
- poly64x1_t __ret;
- __ret = (poly64x1_t) {__p0};
- return __ret;
-}
+#define vld4_dup_f64(__p0) __extension__ ({ \
+ float64x1x4_t __ret; \
+ __builtin_neon_vld4_dup_v(&__ret, __p0, 10); \
+ __ret; \
+})
+#define vld4_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x1x4_t __ret; \
+ poly64x1x4_t __s1 = __p1; \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 6); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai poly64x2_t vmovq_n_p64(poly64_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t) {__p0, __p0};
- return __ret;
-}
+#define vld4q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16x4_t __ret; \
+ poly8x16x4_t __s1 = __p1; \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 36); \
+ __ret; \
+})
#else
-__ai poly64x2_t vmovq_n_p64(poly64_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t) {__p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld4q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16x4_t __ret; \
+ poly8x16x4_t __s1 = __p1; \
+ poly8x16x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 36); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vmovq_n_f64(float64_t __p0) {
- float64x2_t __ret;
- __ret = (float64x2_t) {__p0, __p0};
- return __ret;
-}
+#define vld4q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2x4_t __ret; \
+ poly64x2x4_t __s1 = __p1; \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 38); \
+ __ret; \
+})
#else
-__ai float64x2_t vmovq_n_f64(float64_t __p0) {
- float64x2_t __ret;
- __ret = (float64x2_t) {__p0, __p0};
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vld4q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2x4_t __ret; \
+ poly64x2x4_t __s1 = __p1; \
+ poly64x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 38); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
+})
#endif
-__ai float64x1_t vmov_n_f64(float64_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t) {__p0};
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vmovl_high_u8(uint8x16_t __p0_515) {
- uint16x8_t __ret_515;
- uint8x8_t __a1_515 = vget_high_u8(__p0_515);
- __ret_515 = (uint16x8_t)(vshll_n_u8(__a1_515, 0));
- return __ret_515;
-}
+#define vld4q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16x4_t __ret; \
+ uint8x16x4_t __s1 = __p1; \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 48); \
+ __ret; \
+})
#else
-__ai uint16x8_t vmovl_high_u8(uint8x16_t __p0_516) {
- uint16x8_t __ret_516;
- uint8x16_t __rev0_516; __rev0_516 = __builtin_shufflevector(__p0_516, __p0_516, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __a1_516 = __noswap_vget_high_u8(__rev0_516);
- __ret_516 = (uint16x8_t)(__noswap_vshll_n_u8(__a1_516, 0));
- __ret_516 = __builtin_shufflevector(__ret_516, __ret_516, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret_516;
-}
-__ai uint16x8_t __noswap_vmovl_high_u8(uint8x16_t __p0_517) {
- uint16x8_t __ret_517;
- uint8x8_t __a1_517 = __noswap_vget_high_u8(__p0_517);
- __ret_517 = (uint16x8_t)(__noswap_vshll_n_u8(__a1_517, 0));
- return __ret_517;
-}
+#define vld4q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16x4_t __ret; \
+ uint8x16x4_t __s1 = __p1; \
+ uint8x16x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 48); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vmovl_high_u32(uint32x4_t __p0_518) {
- uint64x2_t __ret_518;
- uint32x2_t __a1_518 = vget_high_u32(__p0_518);
- __ret_518 = (uint64x2_t)(vshll_n_u32(__a1_518, 0));
- return __ret_518;
-}
+#define vld4q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2x4_t __ret; \
+ uint64x2x4_t __s1 = __p1; \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 51); \
+ __ret; \
+})
#else
-__ai uint64x2_t vmovl_high_u32(uint32x4_t __p0_519) {
- uint64x2_t __ret_519;
- uint32x4_t __rev0_519; __rev0_519 = __builtin_shufflevector(__p0_519, __p0_519, 3, 2, 1, 0);
- uint32x2_t __a1_519 = __noswap_vget_high_u32(__rev0_519);
- __ret_519 = (uint64x2_t)(__noswap_vshll_n_u32(__a1_519, 0));
- __ret_519 = __builtin_shufflevector(__ret_519, __ret_519, 1, 0);
- return __ret_519;
-}
-__ai uint64x2_t __noswap_vmovl_high_u32(uint32x4_t __p0_520) {
- uint64x2_t __ret_520;
- uint32x2_t __a1_520 = __noswap_vget_high_u32(__p0_520);
- __ret_520 = (uint64x2_t)(__noswap_vshll_n_u32(__a1_520, 0));
- return __ret_520;
-}
+#define vld4q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2x4_t __ret; \
+ uint64x2x4_t __s1 = __p1; \
+ uint64x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 51); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmovl_high_u16(uint16x8_t __p0_521) {
- uint32x4_t __ret_521;
- uint16x4_t __a1_521 = vget_high_u16(__p0_521);
- __ret_521 = (uint32x4_t)(vshll_n_u16(__a1_521, 0));
- return __ret_521;
-}
+#define vld4q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16x4_t __ret; \
+ int8x16x4_t __s1 = __p1; \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 32); \
+ __ret; \
+})
#else
-__ai uint32x4_t vmovl_high_u16(uint16x8_t __p0_522) {
- uint32x4_t __ret_522;
- uint16x8_t __rev0_522; __rev0_522 = __builtin_shufflevector(__p0_522, __p0_522, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x4_t __a1_522 = __noswap_vget_high_u16(__rev0_522);
- __ret_522 = (uint32x4_t)(__noswap_vshll_n_u16(__a1_522, 0));
- __ret_522 = __builtin_shufflevector(__ret_522, __ret_522, 3, 2, 1, 0);
- return __ret_522;
-}
-__ai uint32x4_t __noswap_vmovl_high_u16(uint16x8_t __p0_523) {
- uint32x4_t __ret_523;
- uint16x4_t __a1_523 = __noswap_vget_high_u16(__p0_523);
- __ret_523 = (uint32x4_t)(__noswap_vshll_n_u16(__a1_523, 0));
- return __ret_523;
-}
+#define vld4q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16x4_t __ret; \
+ int8x16x4_t __s1 = __p1; \
+ int8x16x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 32); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vmovl_high_s8(int8x16_t __p0_524) {
- int16x8_t __ret_524;
- int8x8_t __a1_524 = vget_high_s8(__p0_524);
- __ret_524 = (int16x8_t)(vshll_n_s8(__a1_524, 0));
- return __ret_524;
-}
+#define vld4q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2x4_t __ret; \
+ float64x2x4_t __s1 = __p1; \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 42); \
+ __ret; \
+})
#else
-__ai int16x8_t vmovl_high_s8(int8x16_t __p0_525) {
- int16x8_t __ret_525;
- int8x16_t __rev0_525; __rev0_525 = __builtin_shufflevector(__p0_525, __p0_525, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __a1_525 = __noswap_vget_high_s8(__rev0_525);
- __ret_525 = (int16x8_t)(__noswap_vshll_n_s8(__a1_525, 0));
- __ret_525 = __builtin_shufflevector(__ret_525, __ret_525, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret_525;
-}
-__ai int16x8_t __noswap_vmovl_high_s8(int8x16_t __p0_526) {
- int16x8_t __ret_526;
- int8x8_t __a1_526 = __noswap_vget_high_s8(__p0_526);
- __ret_526 = (int16x8_t)(__noswap_vshll_n_s8(__a1_526, 0));
- return __ret_526;
-}
+#define vld4q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2x4_t __ret; \
+ float64x2x4_t __s1 = __p1; \
+ float64x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 42); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vmovl_high_s32(int32x4_t __p0_527) {
- int64x2_t __ret_527;
- int32x2_t __a1_527 = vget_high_s32(__p0_527);
- __ret_527 = (int64x2_t)(vshll_n_s32(__a1_527, 0));
- return __ret_527;
-}
+#define vld4q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2x4_t __ret; \
+ int64x2x4_t __s1 = __p1; \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 35); \
+ __ret; \
+})
#else
-__ai int64x2_t vmovl_high_s32(int32x4_t __p0_528) {
- int64x2_t __ret_528;
- int32x4_t __rev0_528; __rev0_528 = __builtin_shufflevector(__p0_528, __p0_528, 3, 2, 1, 0);
- int32x2_t __a1_528 = __noswap_vget_high_s32(__rev0_528);
- __ret_528 = (int64x2_t)(__noswap_vshll_n_s32(__a1_528, 0));
- __ret_528 = __builtin_shufflevector(__ret_528, __ret_528, 1, 0);
- return __ret_528;
-}
-__ai int64x2_t __noswap_vmovl_high_s32(int32x4_t __p0_529) {
- int64x2_t __ret_529;
- int32x2_t __a1_529 = __noswap_vget_high_s32(__p0_529);
- __ret_529 = (int64x2_t)(__noswap_vshll_n_s32(__a1_529, 0));
- return __ret_529;
-}
+#define vld4q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2x4_t __ret; \
+ int64x2x4_t __s1 = __p1; \
+ int64x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 35); \
+ \
+ __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+ __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+ __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+ __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+ __ret; \
+})
#endif
+#define vld4_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x1x4_t __ret; \
+ uint64x1x4_t __s1 = __p1; \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 19); \
+ __ret; \
+})
+#define vld4_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x1x4_t __ret; \
+ float64x1x4_t __s1 = __p1; \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 10); \
+ __ret; \
+})
+#define vld4_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x1x4_t __ret; \
+ int64x1x4_t __s1 = __p1; \
+ __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 3); \
+ __ret; \
+})
+#define vldrq_p128(__p0) __extension__ ({ \
+ poly128_t __ret; \
+ __ret = (poly128_t) __builtin_neon_vldrq_p128(__p0); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmovl_high_s16(int16x8_t __p0_530) {
- int32x4_t __ret_530;
- int16x4_t __a1_530 = vget_high_s16(__p0_530);
- __ret_530 = (int32x4_t)(vshll_n_s16(__a1_530, 0));
- return __ret_530;
+__ai __attribute__((target("neon"))) float64x2_t vmaxq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+ return __ret;
}
#else
-__ai int32x4_t vmovl_high_s16(int16x8_t __p0_531) {
- int32x4_t __ret_531;
- int16x8_t __rev0_531; __rev0_531 = __builtin_shufflevector(__p0_531, __p0_531, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x4_t __a1_531 = __noswap_vget_high_s16(__rev0_531);
- __ret_531 = (int32x4_t)(__noswap_vshll_n_s16(__a1_531, 0));
- __ret_531 = __builtin_shufflevector(__ret_531, __ret_531, 3, 2, 1, 0);
- return __ret_531;
-}
-__ai int32x4_t __noswap_vmovl_high_s16(int16x8_t __p0_532) {
- int32x4_t __ret_532;
- int16x4_t __a1_532 = __noswap_vget_high_s16(__p0_532);
- __ret_532 = (int32x4_t)(__noswap_vshll_n_s16(__a1_532, 0));
- return __ret_532;
+__ai __attribute__((target("neon"))) float64x2_t vmaxq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
}
#endif
+__ai __attribute__((target("neon"))) float64x1_t vmax_f64(float64x1_t __p0, float64x1_t __p1) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vmovn_high_u32(uint16x4_t __p0, uint32x4_t __p1) {
- uint16x8_t __ret;
- __ret = vcombine_u16(__p0, vmovn_u32(__p1));
+__ai __attribute__((target("neon"))) float64_t vmaxnmvq_f64(float64x2_t __p0) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vmaxnmvq_f64(__p0);
return __ret;
}
#else
-__ai uint16x8_t vmovn_high_u32(uint16x4_t __p0, uint32x4_t __p1) {
- uint16x8_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vcombine_u16(__rev0, __noswap_vmovn_u32(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float64_t vmaxnmvq_f64(float64x2_t __p0) {
+ float64_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64_t) __builtin_neon_vmaxnmvq_f64(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmovn_high_u64(uint32x2_t __p0, uint64x2_t __p1) {
- uint32x4_t __ret;
- __ret = vcombine_u32(__p0, vmovn_u64(__p1));
+__ai __attribute__((target("neon"))) float32_t vmaxnmvq_f32(float32x4_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vmaxnmvq_f32(__p0);
return __ret;
}
#else
-__ai uint32x4_t vmovn_high_u64(uint32x2_t __p0, uint64x2_t __p1) {
- uint32x4_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __noswap_vcombine_u32(__rev0, __noswap_vmovn_u64(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32_t vmaxnmvq_f32(float32x4_t __p0) {
+ float32_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float32_t) __builtin_neon_vmaxnmvq_f32(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vmovn_high_u16(uint8x8_t __p0, uint16x8_t __p1) {
- uint8x16_t __ret;
- __ret = vcombine_u8(__p0, vmovn_u16(__p1));
+__ai __attribute__((target("neon"))) float32_t vmaxnmv_f32(float32x2_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vmaxnmv_f32(__p0);
return __ret;
}
#else
-__ai uint8x16_t vmovn_high_u16(uint8x8_t __p0, uint16x8_t __p1) {
- uint8x16_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vcombine_u8(__rev0, __noswap_vmovn_u16(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32_t vmaxnmv_f32(float32x2_t __p0) {
+ float32_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float32_t) __builtin_neon_vmaxnmv_f32(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vmovn_high_s32(int16x4_t __p0, int32x4_t __p1) {
- int16x8_t __ret;
- __ret = vcombine_s16(__p0, vmovn_s32(__p1));
+__ai __attribute__((target("neon"))) uint8_t vmaxvq_u8(uint8x16_t __p0) {
+ uint8_t __ret;
+ __ret = (uint8_t) __builtin_neon_vmaxvq_u8(__p0);
return __ret;
}
#else
-__ai int16x8_t vmovn_high_s32(int16x4_t __p0, int32x4_t __p1) {
- int16x8_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vcombine_s16(__rev0, __noswap_vmovn_s32(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8_t vmaxvq_u8(uint8x16_t __p0) {
+ uint8_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8_t) __builtin_neon_vmaxvq_u8(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmovn_high_s64(int32x2_t __p0, int64x2_t __p1) {
- int32x4_t __ret;
- __ret = vcombine_s32(__p0, vmovn_s64(__p1));
+__ai __attribute__((target("neon"))) uint32_t vmaxvq_u32(uint32x4_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vmaxvq_u32(__p0);
return __ret;
}
#else
-__ai int32x4_t vmovn_high_s64(int32x2_t __p0, int64x2_t __p1) {
- int32x4_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __noswap_vcombine_s32(__rev0, __noswap_vmovn_s64(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32_t vmaxvq_u32(uint32x4_t __p0) {
+ uint32_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint32_t) __builtin_neon_vmaxvq_u32(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vmovn_high_s16(int8x8_t __p0, int16x8_t __p1) {
- int8x16_t __ret;
- __ret = vcombine_s8(__p0, vmovn_s16(__p1));
+__ai __attribute__((target("neon"))) uint16_t vmaxvq_u16(uint16x8_t __p0) {
+ uint16_t __ret;
+ __ret = (uint16_t) __builtin_neon_vmaxvq_u16(__p0);
return __ret;
}
#else
-__ai int8x16_t vmovn_high_s16(int8x8_t __p0, int16x8_t __p1) {
- int8x16_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vcombine_s8(__rev0, __noswap_vmovn_s16(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint16_t vmaxvq_u16(uint16x8_t __p0) {
+ uint16_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16_t) __builtin_neon_vmaxvq_u16(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vmulq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = __p0 * __p1;
+__ai __attribute__((target("neon"))) int8_t vmaxvq_s8(int8x16_t __p0) {
+ int8_t __ret;
+ __ret = (int8_t) __builtin_neon_vmaxvq_s8(__p0);
return __ret;
}
#else
-__ai float64x2_t vmulq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 * __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int8_t vmaxvq_s8(int8x16_t __p0) {
+ int8_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8_t) __builtin_neon_vmaxvq_s8(__rev0);
return __ret;
}
#endif
-__ai float64x1_t vmul_f64(float64x1_t __p0, float64x1_t __p1) {
- float64x1_t __ret;
- __ret = __p0 * __p1;
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64_t vmaxvq_f64(float64x2_t __p0) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vmaxvq_f64(__p0);
return __ret;
}
-#define vmuld_lane_f64(__p0_533, __p1_533, __p2_533) __extension__ ({ \
- float64_t __ret_533; \
- float64_t __s0_533 = __p0_533; \
- float64x1_t __s1_533 = __p1_533; \
- __ret_533 = __s0_533 * vget_lane_f64(__s1_533, __p2_533); \
- __ret_533; \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vmuls_lane_f32(__p0_534, __p1_534, __p2_534) __extension__ ({ \
- float32_t __ret_534; \
- float32_t __s0_534 = __p0_534; \
- float32x2_t __s1_534 = __p1_534; \
- __ret_534 = __s0_534 * vget_lane_f32(__s1_534, __p2_534); \
- __ret_534; \
-})
-#else
-#define vmuls_lane_f32(__p0_535, __p1_535, __p2_535) __extension__ ({ \
- float32_t __ret_535; \
- float32_t __s0_535 = __p0_535; \
- float32x2_t __s1_535 = __p1_535; \
- float32x2_t __rev1_535; __rev1_535 = __builtin_shufflevector(__s1_535, __s1_535, 1, 0); \
- __ret_535 = __s0_535 * __noswap_vget_lane_f32(__rev1_535, __p2_535); \
- __ret_535; \
-})
-#endif
-
-#define vmul_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x1_t __ret; \
- float64x1_t __s0 = __p0; \
- float64x1_t __s1 = __p1; \
- __ret = (float64x1_t) __builtin_neon_vmul_lane_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 10); \
- __ret; \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vmulq_lane_f64(__p0_536, __p1_536, __p2_536) __extension__ ({ \
- float64x2_t __ret_536; \
- float64x2_t __s0_536 = __p0_536; \
- float64x1_t __s1_536 = __p1_536; \
- __ret_536 = __s0_536 * splatq_lane_f64(__s1_536, __p2_536); \
- __ret_536; \
-})
-#else
-#define vmulq_lane_f64(__p0_537, __p1_537, __p2_537) __extension__ ({ \
- float64x2_t __ret_537; \
- float64x2_t __s0_537 = __p0_537; \
- float64x1_t __s1_537 = __p1_537; \
- float64x2_t __rev0_537; __rev0_537 = __builtin_shufflevector(__s0_537, __s0_537, 1, 0); \
- __ret_537 = __rev0_537 * __noswap_splatq_lane_f64(__s1_537, __p2_537); \
- __ret_537 = __builtin_shufflevector(__ret_537, __ret_537, 1, 0); \
- __ret_537; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vmuld_laneq_f64(__p0_538, __p1_538, __p2_538) __extension__ ({ \
- float64_t __ret_538; \
- float64_t __s0_538 = __p0_538; \
- float64x2_t __s1_538 = __p1_538; \
- __ret_538 = __s0_538 * vgetq_lane_f64(__s1_538, __p2_538); \
- __ret_538; \
-})
-#else
-#define vmuld_laneq_f64(__p0_539, __p1_539, __p2_539) __extension__ ({ \
- float64_t __ret_539; \
- float64_t __s0_539 = __p0_539; \
- float64x2_t __s1_539 = __p1_539; \
- float64x2_t __rev1_539; __rev1_539 = __builtin_shufflevector(__s1_539, __s1_539, 1, 0); \
- __ret_539 = __s0_539 * __noswap_vgetq_lane_f64(__rev1_539, __p2_539); \
- __ret_539; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vmuls_laneq_f32(__p0_540, __p1_540, __p2_540) __extension__ ({ \
- float32_t __ret_540; \
- float32_t __s0_540 = __p0_540; \
- float32x4_t __s1_540 = __p1_540; \
- __ret_540 = __s0_540 * vgetq_lane_f32(__s1_540, __p2_540); \
- __ret_540; \
-})
-#else
-#define vmuls_laneq_f32(__p0_541, __p1_541, __p2_541) __extension__ ({ \
- float32_t __ret_541; \
- float32_t __s0_541 = __p0_541; \
- float32x4_t __s1_541 = __p1_541; \
- float32x4_t __rev1_541; __rev1_541 = __builtin_shufflevector(__s1_541, __s1_541, 3, 2, 1, 0); \
- __ret_541 = __s0_541 * __noswap_vgetq_lane_f32(__rev1_541, __p2_541); \
- __ret_541; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vmul_laneq_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x1_t __ret; \
- float64x1_t __s0 = __p0; \
- float64x2_t __s1 = __p1; \
- __ret = (float64x1_t) __builtin_neon_vmul_laneq_v((int8x8_t)__s0, (int8x16_t)__s1, __p2, 10); \
- __ret; \
-})
#else
-#define vmul_laneq_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x1_t __ret; \
- float64x1_t __s0 = __p0; \
- float64x2_t __s1 = __p1; \
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (float64x1_t) __builtin_neon_vmul_laneq_v((int8x8_t)__s0, (int8x16_t)__rev1, __p2, 10); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float64_t vmaxvq_f64(float64x2_t __p0) {
+ float64_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64_t) __builtin_neon_vmaxvq_f64(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulq_laneq_u32(__p0_542, __p1_542, __p2_542) __extension__ ({ \
- uint32x4_t __ret_542; \
- uint32x4_t __s0_542 = __p0_542; \
- uint32x4_t __s1_542 = __p1_542; \
- __ret_542 = __s0_542 * splatq_laneq_u32(__s1_542, __p2_542); \
- __ret_542; \
-})
+__ai __attribute__((target("neon"))) float32_t vmaxvq_f32(float32x4_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vmaxvq_f32(__p0);
+ return __ret;
+}
#else
-#define vmulq_laneq_u32(__p0_543, __p1_543, __p2_543) __extension__ ({ \
- uint32x4_t __ret_543; \
- uint32x4_t __s0_543 = __p0_543; \
- uint32x4_t __s1_543 = __p1_543; \
- uint32x4_t __rev0_543; __rev0_543 = __builtin_shufflevector(__s0_543, __s0_543, 3, 2, 1, 0); \
- uint32x4_t __rev1_543; __rev1_543 = __builtin_shufflevector(__s1_543, __s1_543, 3, 2, 1, 0); \
- __ret_543 = __rev0_543 * __noswap_splatq_laneq_u32(__rev1_543, __p2_543); \
- __ret_543 = __builtin_shufflevector(__ret_543, __ret_543, 3, 2, 1, 0); \
- __ret_543; \
-})
+__ai __attribute__((target("neon"))) float32_t vmaxvq_f32(float32x4_t __p0) {
+ float32_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float32_t) __builtin_neon_vmaxvq_f32(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulq_laneq_u16(__p0_544, __p1_544, __p2_544) __extension__ ({ \
- uint16x8_t __ret_544; \
- uint16x8_t __s0_544 = __p0_544; \
- uint16x8_t __s1_544 = __p1_544; \
- __ret_544 = __s0_544 * splatq_laneq_u16(__s1_544, __p2_544); \
- __ret_544; \
-})
+__ai __attribute__((target("neon"))) int32_t vmaxvq_s32(int32x4_t __p0) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vmaxvq_s32(__p0);
+ return __ret;
+}
#else
-#define vmulq_laneq_u16(__p0_545, __p1_545, __p2_545) __extension__ ({ \
- uint16x8_t __ret_545; \
- uint16x8_t __s0_545 = __p0_545; \
- uint16x8_t __s1_545 = __p1_545; \
- uint16x8_t __rev0_545; __rev0_545 = __builtin_shufflevector(__s0_545, __s0_545, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x8_t __rev1_545; __rev1_545 = __builtin_shufflevector(__s1_545, __s1_545, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_545 = __rev0_545 * __noswap_splatq_laneq_u16(__rev1_545, __p2_545); \
- __ret_545 = __builtin_shufflevector(__ret_545, __ret_545, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_545; \
-})
+__ai __attribute__((target("neon"))) int32_t vmaxvq_s32(int32x4_t __p0) {
+ int32_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int32_t) __builtin_neon_vmaxvq_s32(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulq_laneq_f64(__p0_546, __p1_546, __p2_546) __extension__ ({ \
- float64x2_t __ret_546; \
- float64x2_t __s0_546 = __p0_546; \
- float64x2_t __s1_546 = __p1_546; \
- __ret_546 = __s0_546 * splatq_laneq_f64(__s1_546, __p2_546); \
- __ret_546; \
-})
+__ai __attribute__((target("neon"))) int16_t vmaxvq_s16(int16x8_t __p0) {
+ int16_t __ret;
+ __ret = (int16_t) __builtin_neon_vmaxvq_s16(__p0);
+ return __ret;
+}
#else
-#define vmulq_laneq_f64(__p0_547, __p1_547, __p2_547) __extension__ ({ \
- float64x2_t __ret_547; \
- float64x2_t __s0_547 = __p0_547; \
- float64x2_t __s1_547 = __p1_547; \
- float64x2_t __rev0_547; __rev0_547 = __builtin_shufflevector(__s0_547, __s0_547, 1, 0); \
- float64x2_t __rev1_547; __rev1_547 = __builtin_shufflevector(__s1_547, __s1_547, 1, 0); \
- __ret_547 = __rev0_547 * __noswap_splatq_laneq_f64(__rev1_547, __p2_547); \
- __ret_547 = __builtin_shufflevector(__ret_547, __ret_547, 1, 0); \
- __ret_547; \
-})
+__ai __attribute__((target("neon"))) int16_t vmaxvq_s16(int16x8_t __p0) {
+ int16_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16_t) __builtin_neon_vmaxvq_s16(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulq_laneq_f32(__p0_548, __p1_548, __p2_548) __extension__ ({ \
- float32x4_t __ret_548; \
- float32x4_t __s0_548 = __p0_548; \
- float32x4_t __s1_548 = __p1_548; \
- __ret_548 = __s0_548 * splatq_laneq_f32(__s1_548, __p2_548); \
- __ret_548; \
-})
+__ai __attribute__((target("neon"))) uint8_t vmaxv_u8(uint8x8_t __p0) {
+ uint8_t __ret;
+ __ret = (uint8_t) __builtin_neon_vmaxv_u8(__p0);
+ return __ret;
+}
#else
-#define vmulq_laneq_f32(__p0_549, __p1_549, __p2_549) __extension__ ({ \
- float32x4_t __ret_549; \
- float32x4_t __s0_549 = __p0_549; \
- float32x4_t __s1_549 = __p1_549; \
- float32x4_t __rev0_549; __rev0_549 = __builtin_shufflevector(__s0_549, __s0_549, 3, 2, 1, 0); \
- float32x4_t __rev1_549; __rev1_549 = __builtin_shufflevector(__s1_549, __s1_549, 3, 2, 1, 0); \
- __ret_549 = __rev0_549 * __noswap_splatq_laneq_f32(__rev1_549, __p2_549); \
- __ret_549 = __builtin_shufflevector(__ret_549, __ret_549, 3, 2, 1, 0); \
- __ret_549; \
-})
+__ai __attribute__((target("neon"))) uint8_t vmaxv_u8(uint8x8_t __p0) {
+ uint8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8_t) __builtin_neon_vmaxv_u8(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulq_laneq_s32(__p0_550, __p1_550, __p2_550) __extension__ ({ \
- int32x4_t __ret_550; \
- int32x4_t __s0_550 = __p0_550; \
- int32x4_t __s1_550 = __p1_550; \
- __ret_550 = __s0_550 * splatq_laneq_s32(__s1_550, __p2_550); \
- __ret_550; \
-})
+__ai __attribute__((target("neon"))) uint32_t vmaxv_u32(uint32x2_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vmaxv_u32(__p0);
+ return __ret;
+}
#else
-#define vmulq_laneq_s32(__p0_551, __p1_551, __p2_551) __extension__ ({ \
- int32x4_t __ret_551; \
- int32x4_t __s0_551 = __p0_551; \
- int32x4_t __s1_551 = __p1_551; \
- int32x4_t __rev0_551; __rev0_551 = __builtin_shufflevector(__s0_551, __s0_551, 3, 2, 1, 0); \
- int32x4_t __rev1_551; __rev1_551 = __builtin_shufflevector(__s1_551, __s1_551, 3, 2, 1, 0); \
- __ret_551 = __rev0_551 * __noswap_splatq_laneq_s32(__rev1_551, __p2_551); \
- __ret_551 = __builtin_shufflevector(__ret_551, __ret_551, 3, 2, 1, 0); \
- __ret_551; \
-})
+__ai __attribute__((target("neon"))) uint32_t vmaxv_u32(uint32x2_t __p0) {
+ uint32_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32_t) __builtin_neon_vmaxv_u32(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulq_laneq_s16(__p0_552, __p1_552, __p2_552) __extension__ ({ \
- int16x8_t __ret_552; \
- int16x8_t __s0_552 = __p0_552; \
- int16x8_t __s1_552 = __p1_552; \
- __ret_552 = __s0_552 * splatq_laneq_s16(__s1_552, __p2_552); \
- __ret_552; \
-})
+__ai __attribute__((target("neon"))) uint16_t vmaxv_u16(uint16x4_t __p0) {
+ uint16_t __ret;
+ __ret = (uint16_t) __builtin_neon_vmaxv_u16(__p0);
+ return __ret;
+}
#else
-#define vmulq_laneq_s16(__p0_553, __p1_553, __p2_553) __extension__ ({ \
- int16x8_t __ret_553; \
- int16x8_t __s0_553 = __p0_553; \
- int16x8_t __s1_553 = __p1_553; \
- int16x8_t __rev0_553; __rev0_553 = __builtin_shufflevector(__s0_553, __s0_553, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1_553; __rev1_553 = __builtin_shufflevector(__s1_553, __s1_553, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_553 = __rev0_553 * __noswap_splatq_laneq_s16(__rev1_553, __p2_553); \
- __ret_553 = __builtin_shufflevector(__ret_553, __ret_553, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_553; \
-})
+__ai __attribute__((target("neon"))) uint16_t vmaxv_u16(uint16x4_t __p0) {
+ uint16_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16_t) __builtin_neon_vmaxv_u16(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmul_laneq_u32(__p0_554, __p1_554, __p2_554) __extension__ ({ \
- uint32x2_t __ret_554; \
- uint32x2_t __s0_554 = __p0_554; \
- uint32x4_t __s1_554 = __p1_554; \
- __ret_554 = __s0_554 * splat_laneq_u32(__s1_554, __p2_554); \
- __ret_554; \
-})
+__ai __attribute__((target("neon"))) int8_t vmaxv_s8(int8x8_t __p0) {
+ int8_t __ret;
+ __ret = (int8_t) __builtin_neon_vmaxv_s8(__p0);
+ return __ret;
+}
#else
-#define vmul_laneq_u32(__p0_555, __p1_555, __p2_555) __extension__ ({ \
- uint32x2_t __ret_555; \
- uint32x2_t __s0_555 = __p0_555; \
- uint32x4_t __s1_555 = __p1_555; \
- uint32x2_t __rev0_555; __rev0_555 = __builtin_shufflevector(__s0_555, __s0_555, 1, 0); \
- uint32x4_t __rev1_555; __rev1_555 = __builtin_shufflevector(__s1_555, __s1_555, 3, 2, 1, 0); \
- __ret_555 = __rev0_555 * __noswap_splat_laneq_u32(__rev1_555, __p2_555); \
- __ret_555 = __builtin_shufflevector(__ret_555, __ret_555, 1, 0); \
- __ret_555; \
-})
+__ai __attribute__((target("neon"))) int8_t vmaxv_s8(int8x8_t __p0) {
+ int8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8_t) __builtin_neon_vmaxv_s8(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmul_laneq_u16(__p0_556, __p1_556, __p2_556) __extension__ ({ \
- uint16x4_t __ret_556; \
- uint16x4_t __s0_556 = __p0_556; \
- uint16x8_t __s1_556 = __p1_556; \
- __ret_556 = __s0_556 * splat_laneq_u16(__s1_556, __p2_556); \
- __ret_556; \
-})
+__ai __attribute__((target("neon"))) float32_t vmaxv_f32(float32x2_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vmaxv_f32(__p0);
+ return __ret;
+}
#else
-#define vmul_laneq_u16(__p0_557, __p1_557, __p2_557) __extension__ ({ \
- uint16x4_t __ret_557; \
- uint16x4_t __s0_557 = __p0_557; \
- uint16x8_t __s1_557 = __p1_557; \
- uint16x4_t __rev0_557; __rev0_557 = __builtin_shufflevector(__s0_557, __s0_557, 3, 2, 1, 0); \
- uint16x8_t __rev1_557; __rev1_557 = __builtin_shufflevector(__s1_557, __s1_557, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_557 = __rev0_557 * __noswap_splat_laneq_u16(__rev1_557, __p2_557); \
- __ret_557 = __builtin_shufflevector(__ret_557, __ret_557, 3, 2, 1, 0); \
- __ret_557; \
-})
+__ai __attribute__((target("neon"))) float32_t vmaxv_f32(float32x2_t __p0) {
+ float32_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float32_t) __builtin_neon_vmaxv_f32(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmul_laneq_f32(__p0_558, __p1_558, __p2_558) __extension__ ({ \
- float32x2_t __ret_558; \
- float32x2_t __s0_558 = __p0_558; \
- float32x4_t __s1_558 = __p1_558; \
- __ret_558 = __s0_558 * splat_laneq_f32(__s1_558, __p2_558); \
- __ret_558; \
-})
+__ai __attribute__((target("neon"))) int32_t vmaxv_s32(int32x2_t __p0) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vmaxv_s32(__p0);
+ return __ret;
+}
#else
-#define vmul_laneq_f32(__p0_559, __p1_559, __p2_559) __extension__ ({ \
- float32x2_t __ret_559; \
- float32x2_t __s0_559 = __p0_559; \
- float32x4_t __s1_559 = __p1_559; \
- float32x2_t __rev0_559; __rev0_559 = __builtin_shufflevector(__s0_559, __s0_559, 1, 0); \
- float32x4_t __rev1_559; __rev1_559 = __builtin_shufflevector(__s1_559, __s1_559, 3, 2, 1, 0); \
- __ret_559 = __rev0_559 * __noswap_splat_laneq_f32(__rev1_559, __p2_559); \
- __ret_559 = __builtin_shufflevector(__ret_559, __ret_559, 1, 0); \
- __ret_559; \
-})
+__ai __attribute__((target("neon"))) int32_t vmaxv_s32(int32x2_t __p0) {
+ int32_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int32_t) __builtin_neon_vmaxv_s32(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmul_laneq_s32(__p0_560, __p1_560, __p2_560) __extension__ ({ \
- int32x2_t __ret_560; \
- int32x2_t __s0_560 = __p0_560; \
- int32x4_t __s1_560 = __p1_560; \
- __ret_560 = __s0_560 * splat_laneq_s32(__s1_560, __p2_560); \
- __ret_560; \
-})
+__ai __attribute__((target("neon"))) int16_t vmaxv_s16(int16x4_t __p0) {
+ int16_t __ret;
+ __ret = (int16_t) __builtin_neon_vmaxv_s16(__p0);
+ return __ret;
+}
#else
-#define vmul_laneq_s32(__p0_561, __p1_561, __p2_561) __extension__ ({ \
- int32x2_t __ret_561; \
- int32x2_t __s0_561 = __p0_561; \
- int32x4_t __s1_561 = __p1_561; \
- int32x2_t __rev0_561; __rev0_561 = __builtin_shufflevector(__s0_561, __s0_561, 1, 0); \
- int32x4_t __rev1_561; __rev1_561 = __builtin_shufflevector(__s1_561, __s1_561, 3, 2, 1, 0); \
- __ret_561 = __rev0_561 * __noswap_splat_laneq_s32(__rev1_561, __p2_561); \
- __ret_561 = __builtin_shufflevector(__ret_561, __ret_561, 1, 0); \
- __ret_561; \
-})
+__ai __attribute__((target("neon"))) int16_t vmaxv_s16(int16x4_t __p0) {
+ int16_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int16_t) __builtin_neon_vmaxv_s16(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmul_laneq_s16(__p0_562, __p1_562, __p2_562) __extension__ ({ \
- int16x4_t __ret_562; \
- int16x4_t __s0_562 = __p0_562; \
- int16x8_t __s1_562 = __p1_562; \
- __ret_562 = __s0_562 * splat_laneq_s16(__s1_562, __p2_562); \
- __ret_562; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vminq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+ return __ret;
+}
#else
-#define vmul_laneq_s16(__p0_563, __p1_563, __p2_563) __extension__ ({ \
- int16x4_t __ret_563; \
- int16x4_t __s0_563 = __p0_563; \
- int16x8_t __s1_563 = __p1_563; \
- int16x4_t __rev0_563; __rev0_563 = __builtin_shufflevector(__s0_563, __s0_563, 3, 2, 1, 0); \
- int16x8_t __rev1_563; __rev1_563 = __builtin_shufflevector(__s1_563, __s1_563, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_563 = __rev0_563 * __noswap_splat_laneq_s16(__rev1_563, __p2_563); \
- __ret_563 = __builtin_shufflevector(__ret_563, __ret_563, 3, 2, 1, 0); \
- __ret_563; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vminq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
-__ai float64x1_t vmul_n_f64(float64x1_t __p0, float64_t __p1) {
+__ai __attribute__((target("neon"))) float64x1_t vmin_f64(float64x1_t __p0, float64x1_t __p1) {
float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vmul_n_f64((float64x1_t)__p0, __p1);
+ __ret = (float64x1_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vmulq_n_f64(float64x2_t __p0, float64_t __p1) {
- float64x2_t __ret;
- __ret = __p0 * (float64x2_t) {__p1, __p1};
+__ai __attribute__((target("neon"))) float64_t vminnmvq_f64(float64x2_t __p0) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vminnmvq_f64(__p0);
return __ret;
}
#else
-__ai float64x2_t vmulq_n_f64(float64x2_t __p0, float64_t __p1) {
- float64x2_t __ret;
+__ai __attribute__((target("neon"))) float64_t vminnmvq_f64(float64x2_t __p0) {
+ float64_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = __rev0 * (float64x2_t) {__p1, __p1};
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ __ret = (float64_t) __builtin_neon_vminnmvq_f64(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x8_t vmull_high_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly16x8_t __ret;
- __ret = vmull_p8(vget_high_p8(__p0), vget_high_p8(__p1));
+__ai __attribute__((target("neon"))) float32_t vminnmvq_f32(float32x4_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vminnmvq_f32(__p0);
return __ret;
}
#else
-__ai poly16x8_t vmull_high_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly16x8_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vmull_p8(__noswap_vget_high_p8(__rev0), __noswap_vget_high_p8(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32_t vminnmvq_f32(float32x4_t __p0) {
+ float32_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float32_t) __builtin_neon_vminnmvq_f32(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vmull_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint16x8_t __ret;
- __ret = vmull_u8(vget_high_u8(__p0), vget_high_u8(__p1));
+__ai __attribute__((target("neon"))) float32_t vminnmv_f32(float32x2_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vminnmv_f32(__p0);
return __ret;
}
#else
-__ai uint16x8_t vmull_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint16x8_t __ret;
+__ai __attribute__((target("neon"))) float32_t vminnmv_f32(float32x2_t __p0) {
+ float32_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float32_t) __builtin_neon_vminnmv_f32(__rev0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8_t vminvq_u8(uint8x16_t __p0) {
+ uint8_t __ret;
+ __ret = (uint8_t) __builtin_neon_vminvq_u8(__p0);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8_t vminvq_u8(uint8x16_t __p0) {
+ uint8_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vmull_u8(__noswap_vget_high_u8(__rev0), __noswap_vget_high_u8(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8_t) __builtin_neon_vminvq_u8(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vmull_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint64x2_t __ret;
- __ret = vmull_u32(vget_high_u32(__p0), vget_high_u32(__p1));
+__ai __attribute__((target("neon"))) uint32_t vminvq_u32(uint32x4_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vminvq_u32(__p0);
return __ret;
}
#else
-__ai uint64x2_t vmull_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint64x2_t __ret;
+__ai __attribute__((target("neon"))) uint32_t vminvq_u32(uint32x4_t __p0) {
+ uint32_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vmull_u32(__noswap_vget_high_u32(__rev0), __noswap_vget_high_u32(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ __ret = (uint32_t) __builtin_neon_vminvq_u32(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmull_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint32x4_t __ret;
- __ret = vmull_u16(vget_high_u16(__p0), vget_high_u16(__p1));
+__ai __attribute__((target("neon"))) uint16_t vminvq_u16(uint16x8_t __p0) {
+ uint16_t __ret;
+ __ret = (uint16_t) __builtin_neon_vminvq_u16(__p0);
return __ret;
}
#else
-__ai uint32x4_t vmull_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint32x4_t __ret;
+__ai __attribute__((target("neon"))) uint16_t vminvq_u16(uint16x8_t __p0) {
+ uint16_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vmull_u16(__noswap_vget_high_u16(__rev0), __noswap_vget_high_u16(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ __ret = (uint16_t) __builtin_neon_vminvq_u16(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vmull_high_s8(int8x16_t __p0, int8x16_t __p1) {
- int16x8_t __ret;
- __ret = vmull_s8(vget_high_s8(__p0), vget_high_s8(__p1));
+__ai __attribute__((target("neon"))) int8_t vminvq_s8(int8x16_t __p0) {
+ int8_t __ret;
+ __ret = (int8_t) __builtin_neon_vminvq_s8(__p0);
return __ret;
}
#else
-__ai int16x8_t vmull_high_s8(int8x16_t __p0, int8x16_t __p1) {
- int16x8_t __ret;
+__ai __attribute__((target("neon"))) int8_t vminvq_s8(int8x16_t __p0) {
+ int8_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vmull_s8(__noswap_vget_high_s8(__rev0), __noswap_vget_high_s8(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8_t) __builtin_neon_vminvq_s8(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vmull_high_s32(int32x4_t __p0, int32x4_t __p1) {
- int64x2_t __ret;
- __ret = vmull_s32(vget_high_s32(__p0), vget_high_s32(__p1));
+__ai __attribute__((target("neon"))) float64_t vminvq_f64(float64x2_t __p0) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vminvq_f64(__p0);
return __ret;
}
#else
-__ai int64x2_t vmull_high_s32(int32x4_t __p0, int32x4_t __p1) {
- int64x2_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vmull_s32(__noswap_vget_high_s32(__rev0), __noswap_vget_high_s32(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) float64_t vminvq_f64(float64x2_t __p0) {
+ float64_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64_t) __builtin_neon_vminvq_f64(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmull_high_s16(int16x8_t __p0, int16x8_t __p1) {
- int32x4_t __ret;
- __ret = vmull_s16(vget_high_s16(__p0), vget_high_s16(__p1));
+__ai __attribute__((target("neon"))) float32_t vminvq_f32(float32x4_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vminvq_f32(__p0);
return __ret;
}
#else
-__ai int32x4_t vmull_high_s16(int16x8_t __p0, int16x8_t __p1) {
- int32x4_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vmull_s16(__noswap_vget_high_s16(__rev0), __noswap_vget_high_s16(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32_t vminvq_f32(float32x4_t __p0) {
+ float32_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float32_t) __builtin_neon_vminvq_f32(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmull_high_lane_u32(__p0_564, __p1_564, __p2_564) __extension__ ({ \
- uint64x2_t __ret_564; \
- uint32x4_t __s0_564 = __p0_564; \
- uint32x2_t __s1_564 = __p1_564; \
- __ret_564 = vmull_u32(vget_high_u32(__s0_564), splat_lane_u32(__s1_564, __p2_564)); \
- __ret_564; \
-})
+__ai __attribute__((target("neon"))) int32_t vminvq_s32(int32x4_t __p0) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vminvq_s32(__p0);
+ return __ret;
+}
#else
-#define vmull_high_lane_u32(__p0_565, __p1_565, __p2_565) __extension__ ({ \
- uint64x2_t __ret_565; \
- uint32x4_t __s0_565 = __p0_565; \
- uint32x2_t __s1_565 = __p1_565; \
- uint32x4_t __rev0_565; __rev0_565 = __builtin_shufflevector(__s0_565, __s0_565, 3, 2, 1, 0); \
- uint32x2_t __rev1_565; __rev1_565 = __builtin_shufflevector(__s1_565, __s1_565, 1, 0); \
- __ret_565 = __noswap_vmull_u32(__noswap_vget_high_u32(__rev0_565), __noswap_splat_lane_u32(__rev1_565, __p2_565)); \
- __ret_565 = __builtin_shufflevector(__ret_565, __ret_565, 1, 0); \
- __ret_565; \
-})
+__ai __attribute__((target("neon"))) int32_t vminvq_s32(int32x4_t __p0) {
+ int32_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int32_t) __builtin_neon_vminvq_s32(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmull_high_lane_u16(__p0_566, __p1_566, __p2_566) __extension__ ({ \
- uint32x4_t __ret_566; \
- uint16x8_t __s0_566 = __p0_566; \
- uint16x4_t __s1_566 = __p1_566; \
- __ret_566 = vmull_u16(vget_high_u16(__s0_566), splat_lane_u16(__s1_566, __p2_566)); \
- __ret_566; \
-})
+__ai __attribute__((target("neon"))) int16_t vminvq_s16(int16x8_t __p0) {
+ int16_t __ret;
+ __ret = (int16_t) __builtin_neon_vminvq_s16(__p0);
+ return __ret;
+}
#else
-#define vmull_high_lane_u16(__p0_567, __p1_567, __p2_567) __extension__ ({ \
- uint32x4_t __ret_567; \
- uint16x8_t __s0_567 = __p0_567; \
- uint16x4_t __s1_567 = __p1_567; \
- uint16x8_t __rev0_567; __rev0_567 = __builtin_shufflevector(__s0_567, __s0_567, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x4_t __rev1_567; __rev1_567 = __builtin_shufflevector(__s1_567, __s1_567, 3, 2, 1, 0); \
- __ret_567 = __noswap_vmull_u16(__noswap_vget_high_u16(__rev0_567), __noswap_splat_lane_u16(__rev1_567, __p2_567)); \
- __ret_567 = __builtin_shufflevector(__ret_567, __ret_567, 3, 2, 1, 0); \
- __ret_567; \
-})
+__ai __attribute__((target("neon"))) int16_t vminvq_s16(int16x8_t __p0) {
+ int16_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16_t) __builtin_neon_vminvq_s16(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmull_high_lane_s32(__p0_568, __p1_568, __p2_568) __extension__ ({ \
- int64x2_t __ret_568; \
- int32x4_t __s0_568 = __p0_568; \
- int32x2_t __s1_568 = __p1_568; \
- __ret_568 = vmull_s32(vget_high_s32(__s0_568), splat_lane_s32(__s1_568, __p2_568)); \
- __ret_568; \
-})
+__ai __attribute__((target("neon"))) uint8_t vminv_u8(uint8x8_t __p0) {
+ uint8_t __ret;
+ __ret = (uint8_t) __builtin_neon_vminv_u8(__p0);
+ return __ret;
+}
#else
-#define vmull_high_lane_s32(__p0_569, __p1_569, __p2_569) __extension__ ({ \
- int64x2_t __ret_569; \
- int32x4_t __s0_569 = __p0_569; \
- int32x2_t __s1_569 = __p1_569; \
- int32x4_t __rev0_569; __rev0_569 = __builtin_shufflevector(__s0_569, __s0_569, 3, 2, 1, 0); \
- int32x2_t __rev1_569; __rev1_569 = __builtin_shufflevector(__s1_569, __s1_569, 1, 0); \
- __ret_569 = __noswap_vmull_s32(__noswap_vget_high_s32(__rev0_569), __noswap_splat_lane_s32(__rev1_569, __p2_569)); \
- __ret_569 = __builtin_shufflevector(__ret_569, __ret_569, 1, 0); \
- __ret_569; \
-})
+__ai __attribute__((target("neon"))) uint8_t vminv_u8(uint8x8_t __p0) {
+ uint8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8_t) __builtin_neon_vminv_u8(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmull_high_lane_s16(__p0_570, __p1_570, __p2_570) __extension__ ({ \
- int32x4_t __ret_570; \
- int16x8_t __s0_570 = __p0_570; \
- int16x4_t __s1_570 = __p1_570; \
- __ret_570 = vmull_s16(vget_high_s16(__s0_570), splat_lane_s16(__s1_570, __p2_570)); \
- __ret_570; \
-})
+__ai __attribute__((target("neon"))) uint32_t vminv_u32(uint32x2_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vminv_u32(__p0);
+ return __ret;
+}
#else
-#define vmull_high_lane_s16(__p0_571, __p1_571, __p2_571) __extension__ ({ \
- int32x4_t __ret_571; \
- int16x8_t __s0_571 = __p0_571; \
- int16x4_t __s1_571 = __p1_571; \
- int16x8_t __rev0_571; __rev0_571 = __builtin_shufflevector(__s0_571, __s0_571, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x4_t __rev1_571; __rev1_571 = __builtin_shufflevector(__s1_571, __s1_571, 3, 2, 1, 0); \
- __ret_571 = __noswap_vmull_s16(__noswap_vget_high_s16(__rev0_571), __noswap_splat_lane_s16(__rev1_571, __p2_571)); \
- __ret_571 = __builtin_shufflevector(__ret_571, __ret_571, 3, 2, 1, 0); \
- __ret_571; \
-})
+__ai __attribute__((target("neon"))) uint32_t vminv_u32(uint32x2_t __p0) {
+ uint32_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint32_t) __builtin_neon_vminv_u32(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmull_high_laneq_u32(__p0_572, __p1_572, __p2_572) __extension__ ({ \
- uint64x2_t __ret_572; \
- uint32x4_t __s0_572 = __p0_572; \
- uint32x4_t __s1_572 = __p1_572; \
- __ret_572 = vmull_u32(vget_high_u32(__s0_572), splat_laneq_u32(__s1_572, __p2_572)); \
- __ret_572; \
-})
+__ai __attribute__((target("neon"))) uint16_t vminv_u16(uint16x4_t __p0) {
+ uint16_t __ret;
+ __ret = (uint16_t) __builtin_neon_vminv_u16(__p0);
+ return __ret;
+}
#else
-#define vmull_high_laneq_u32(__p0_573, __p1_573, __p2_573) __extension__ ({ \
- uint64x2_t __ret_573; \
- uint32x4_t __s0_573 = __p0_573; \
- uint32x4_t __s1_573 = __p1_573; \
- uint32x4_t __rev0_573; __rev0_573 = __builtin_shufflevector(__s0_573, __s0_573, 3, 2, 1, 0); \
- uint32x4_t __rev1_573; __rev1_573 = __builtin_shufflevector(__s1_573, __s1_573, 3, 2, 1, 0); \
- __ret_573 = __noswap_vmull_u32(__noswap_vget_high_u32(__rev0_573), __noswap_splat_laneq_u32(__rev1_573, __p2_573)); \
- __ret_573 = __builtin_shufflevector(__ret_573, __ret_573, 1, 0); \
- __ret_573; \
-})
+__ai __attribute__((target("neon"))) uint16_t vminv_u16(uint16x4_t __p0) {
+ uint16_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (uint16_t) __builtin_neon_vminv_u16(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmull_high_laneq_u16(__p0_574, __p1_574, __p2_574) __extension__ ({ \
- uint32x4_t __ret_574; \
- uint16x8_t __s0_574 = __p0_574; \
- uint16x8_t __s1_574 = __p1_574; \
- __ret_574 = vmull_u16(vget_high_u16(__s0_574), splat_laneq_u16(__s1_574, __p2_574)); \
- __ret_574; \
-})
+__ai __attribute__((target("neon"))) int8_t vminv_s8(int8x8_t __p0) {
+ int8_t __ret;
+ __ret = (int8_t) __builtin_neon_vminv_s8(__p0);
+ return __ret;
+}
#else
-#define vmull_high_laneq_u16(__p0_575, __p1_575, __p2_575) __extension__ ({ \
- uint32x4_t __ret_575; \
- uint16x8_t __s0_575 = __p0_575; \
- uint16x8_t __s1_575 = __p1_575; \
- uint16x8_t __rev0_575; __rev0_575 = __builtin_shufflevector(__s0_575, __s0_575, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x8_t __rev1_575; __rev1_575 = __builtin_shufflevector(__s1_575, __s1_575, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_575 = __noswap_vmull_u16(__noswap_vget_high_u16(__rev0_575), __noswap_splat_laneq_u16(__rev1_575, __p2_575)); \
- __ret_575 = __builtin_shufflevector(__ret_575, __ret_575, 3, 2, 1, 0); \
- __ret_575; \
-})
+__ai __attribute__((target("neon"))) int8_t vminv_s8(int8x8_t __p0) {
+ int8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8_t) __builtin_neon_vminv_s8(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmull_high_laneq_s32(__p0_576, __p1_576, __p2_576) __extension__ ({ \
- int64x2_t __ret_576; \
- int32x4_t __s0_576 = __p0_576; \
- int32x4_t __s1_576 = __p1_576; \
- __ret_576 = vmull_s32(vget_high_s32(__s0_576), splat_laneq_s32(__s1_576, __p2_576)); \
- __ret_576; \
-})
-#else
-#define vmull_high_laneq_s32(__p0_577, __p1_577, __p2_577) __extension__ ({ \
- int64x2_t __ret_577; \
- int32x4_t __s0_577 = __p0_577; \
- int32x4_t __s1_577 = __p1_577; \
- int32x4_t __rev0_577; __rev0_577 = __builtin_shufflevector(__s0_577, __s0_577, 3, 2, 1, 0); \
- int32x4_t __rev1_577; __rev1_577 = __builtin_shufflevector(__s1_577, __s1_577, 3, 2, 1, 0); \
- __ret_577 = __noswap_vmull_s32(__noswap_vget_high_s32(__rev0_577), __noswap_splat_laneq_s32(__rev1_577, __p2_577)); \
- __ret_577 = __builtin_shufflevector(__ret_577, __ret_577, 1, 0); \
- __ret_577; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vmull_high_laneq_s16(__p0_578, __p1_578, __p2_578) __extension__ ({ \
- int32x4_t __ret_578; \
- int16x8_t __s0_578 = __p0_578; \
- int16x8_t __s1_578 = __p1_578; \
- __ret_578 = vmull_s16(vget_high_s16(__s0_578), splat_laneq_s16(__s1_578, __p2_578)); \
- __ret_578; \
-})
-#else
-#define vmull_high_laneq_s16(__p0_579, __p1_579, __p2_579) __extension__ ({ \
- int32x4_t __ret_579; \
- int16x8_t __s0_579 = __p0_579; \
- int16x8_t __s1_579 = __p1_579; \
- int16x8_t __rev0_579; __rev0_579 = __builtin_shufflevector(__s0_579, __s0_579, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1_579; __rev1_579 = __builtin_shufflevector(__s1_579, __s1_579, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_579 = __noswap_vmull_s16(__noswap_vget_high_s16(__rev0_579), __noswap_splat_laneq_s16(__rev1_579, __p2_579)); \
- __ret_579 = __builtin_shufflevector(__ret_579, __ret_579, 3, 2, 1, 0); \
- __ret_579; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vmull_high_n_u32(uint32x4_t __p0, uint32_t __p1) {
- uint64x2_t __ret;
- __ret = vmull_n_u32(vget_high_u32(__p0), __p1);
+__ai __attribute__((target("neon"))) float32_t vminv_f32(float32x2_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vminv_f32(__p0);
return __ret;
}
#else
-__ai uint64x2_t vmull_high_n_u32(uint32x4_t __p0, uint32_t __p1) {
- uint64x2_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __noswap_vmull_n_u32(__noswap_vget_high_u32(__rev0), __p1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) float32_t vminv_f32(float32x2_t __p0) {
+ float32_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float32_t) __builtin_neon_vminv_f32(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmull_high_n_u16(uint16x8_t __p0, uint16_t __p1) {
- uint32x4_t __ret;
- __ret = vmull_n_u16(vget_high_u16(__p0), __p1);
+__ai __attribute__((target("neon"))) int32_t vminv_s32(int32x2_t __p0) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vminv_s32(__p0);
return __ret;
}
#else
-__ai uint32x4_t vmull_high_n_u16(uint16x8_t __p0, uint16_t __p1) {
- uint32x4_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vmull_n_u16(__noswap_vget_high_u16(__rev0), __p1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32_t vminv_s32(int32x2_t __p0) {
+ int32_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int32_t) __builtin_neon_vminv_s32(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vmull_high_n_s32(int32x4_t __p0, int32_t __p1) {
- int64x2_t __ret;
- __ret = vmull_n_s32(vget_high_s32(__p0), __p1);
+__ai __attribute__((target("neon"))) int16_t vminv_s16(int16x4_t __p0) {
+ int16_t __ret;
+ __ret = (int16_t) __builtin_neon_vminv_s16(__p0);
return __ret;
}
#else
-__ai int64x2_t vmull_high_n_s32(int32x4_t __p0, int32_t __p1) {
- int64x2_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __noswap_vmull_n_s32(__noswap_vget_high_s32(__rev0), __p1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int16_t vminv_s16(int16x4_t __p0) {
+ int16_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (int16_t) __builtin_neon_vminv_s16(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmull_high_n_s16(int16x8_t __p0, int16_t __p1) {
- int32x4_t __ret;
- __ret = vmull_n_s16(vget_high_s16(__p0), __p1);
+__ai __attribute__((target("neon"))) float64x2_t vmlaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+ float64x2_t __ret;
+ __ret = __p0 + __p1 * __p2;
return __ret;
}
#else
-__ai int32x4_t vmull_high_n_s16(int16x8_t __p0, int16_t __p1) {
- int32x4_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vmull_n_s16(__noswap_vget_high_s16(__rev0), __p1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float64x2_t vmlaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ float64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = __rev0 + __rev1 * __rev2;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
+__ai __attribute__((target("neon"))) float64x1_t vmla_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
+ float64x1_t __ret;
+ __ret = __p0 + __p1 * __p2;
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vmull_laneq_u32(__p0_580, __p1_580, __p2_580) __extension__ ({ \
- uint64x2_t __ret_580; \
- uint32x2_t __s0_580 = __p0_580; \
- uint32x4_t __s1_580 = __p1_580; \
- __ret_580 = vmull_u32(__s0_580, splat_laneq_u32(__s1_580, __p2_580)); \
- __ret_580; \
+#define vmlaq_laneq_u32(__p0_448, __p1_448, __p2_448, __p3_448) __extension__ ({ \
+ uint32x4_t __ret_448; \
+ uint32x4_t __s0_448 = __p0_448; \
+ uint32x4_t __s1_448 = __p1_448; \
+ uint32x4_t __s2_448 = __p2_448; \
+ __ret_448 = __s0_448 + __s1_448 * splatq_laneq_u32(__s2_448, __p3_448); \
+ __ret_448; \
})
#else
-#define vmull_laneq_u32(__p0_581, __p1_581, __p2_581) __extension__ ({ \
- uint64x2_t __ret_581; \
- uint32x2_t __s0_581 = __p0_581; \
- uint32x4_t __s1_581 = __p1_581; \
- uint32x2_t __rev0_581; __rev0_581 = __builtin_shufflevector(__s0_581, __s0_581, 1, 0); \
- uint32x4_t __rev1_581; __rev1_581 = __builtin_shufflevector(__s1_581, __s1_581, 3, 2, 1, 0); \
- __ret_581 = __noswap_vmull_u32(__rev0_581, __noswap_splat_laneq_u32(__rev1_581, __p2_581)); \
- __ret_581 = __builtin_shufflevector(__ret_581, __ret_581, 1, 0); \
- __ret_581; \
+#define vmlaq_laneq_u32(__p0_449, __p1_449, __p2_449, __p3_449) __extension__ ({ \
+ uint32x4_t __ret_449; \
+ uint32x4_t __s0_449 = __p0_449; \
+ uint32x4_t __s1_449 = __p1_449; \
+ uint32x4_t __s2_449 = __p2_449; \
+ uint32x4_t __rev0_449; __rev0_449 = __builtin_shufflevector(__s0_449, __s0_449, 3, 2, 1, 0); \
+ uint32x4_t __rev1_449; __rev1_449 = __builtin_shufflevector(__s1_449, __s1_449, 3, 2, 1, 0); \
+ uint32x4_t __rev2_449; __rev2_449 = __builtin_shufflevector(__s2_449, __s2_449, 3, 2, 1, 0); \
+ __ret_449 = __rev0_449 + __rev1_449 * __noswap_splatq_laneq_u32(__rev2_449, __p3_449); \
+ __ret_449 = __builtin_shufflevector(__ret_449, __ret_449, 3, 2, 1, 0); \
+ __ret_449; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmull_laneq_u16(__p0_582, __p1_582, __p2_582) __extension__ ({ \
- uint32x4_t __ret_582; \
- uint16x4_t __s0_582 = __p0_582; \
- uint16x8_t __s1_582 = __p1_582; \
- __ret_582 = vmull_u16(__s0_582, splat_laneq_u16(__s1_582, __p2_582)); \
- __ret_582; \
+#define vmlaq_laneq_u16(__p0_450, __p1_450, __p2_450, __p3_450) __extension__ ({ \
+ uint16x8_t __ret_450; \
+ uint16x8_t __s0_450 = __p0_450; \
+ uint16x8_t __s1_450 = __p1_450; \
+ uint16x8_t __s2_450 = __p2_450; \
+ __ret_450 = __s0_450 + __s1_450 * splatq_laneq_u16(__s2_450, __p3_450); \
+ __ret_450; \
})
#else
-#define vmull_laneq_u16(__p0_583, __p1_583, __p2_583) __extension__ ({ \
- uint32x4_t __ret_583; \
- uint16x4_t __s0_583 = __p0_583; \
- uint16x8_t __s1_583 = __p1_583; \
- uint16x4_t __rev0_583; __rev0_583 = __builtin_shufflevector(__s0_583, __s0_583, 3, 2, 1, 0); \
- uint16x8_t __rev1_583; __rev1_583 = __builtin_shufflevector(__s1_583, __s1_583, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_583 = __noswap_vmull_u16(__rev0_583, __noswap_splat_laneq_u16(__rev1_583, __p2_583)); \
- __ret_583 = __builtin_shufflevector(__ret_583, __ret_583, 3, 2, 1, 0); \
- __ret_583; \
+#define vmlaq_laneq_u16(__p0_451, __p1_451, __p2_451, __p3_451) __extension__ ({ \
+ uint16x8_t __ret_451; \
+ uint16x8_t __s0_451 = __p0_451; \
+ uint16x8_t __s1_451 = __p1_451; \
+ uint16x8_t __s2_451 = __p2_451; \
+ uint16x8_t __rev0_451; __rev0_451 = __builtin_shufflevector(__s0_451, __s0_451, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev1_451; __rev1_451 = __builtin_shufflevector(__s1_451, __s1_451, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev2_451; __rev2_451 = __builtin_shufflevector(__s2_451, __s2_451, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_451 = __rev0_451 + __rev1_451 * __noswap_splatq_laneq_u16(__rev2_451, __p3_451); \
+ __ret_451 = __builtin_shufflevector(__ret_451, __ret_451, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_451; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmull_laneq_s32(__p0_584, __p1_584, __p2_584) __extension__ ({ \
- int64x2_t __ret_584; \
- int32x2_t __s0_584 = __p0_584; \
- int32x4_t __s1_584 = __p1_584; \
- __ret_584 = vmull_s32(__s0_584, splat_laneq_s32(__s1_584, __p2_584)); \
- __ret_584; \
+#define vmlaq_laneq_f32(__p0_452, __p1_452, __p2_452, __p3_452) __extension__ ({ \
+ float32x4_t __ret_452; \
+ float32x4_t __s0_452 = __p0_452; \
+ float32x4_t __s1_452 = __p1_452; \
+ float32x4_t __s2_452 = __p2_452; \
+ __ret_452 = __s0_452 + __s1_452 * splatq_laneq_f32(__s2_452, __p3_452); \
+ __ret_452; \
})
#else
-#define vmull_laneq_s32(__p0_585, __p1_585, __p2_585) __extension__ ({ \
- int64x2_t __ret_585; \
- int32x2_t __s0_585 = __p0_585; \
- int32x4_t __s1_585 = __p1_585; \
- int32x2_t __rev0_585; __rev0_585 = __builtin_shufflevector(__s0_585, __s0_585, 1, 0); \
- int32x4_t __rev1_585; __rev1_585 = __builtin_shufflevector(__s1_585, __s1_585, 3, 2, 1, 0); \
- __ret_585 = __noswap_vmull_s32(__rev0_585, __noswap_splat_laneq_s32(__rev1_585, __p2_585)); \
- __ret_585 = __builtin_shufflevector(__ret_585, __ret_585, 1, 0); \
- __ret_585; \
+#define vmlaq_laneq_f32(__p0_453, __p1_453, __p2_453, __p3_453) __extension__ ({ \
+ float32x4_t __ret_453; \
+ float32x4_t __s0_453 = __p0_453; \
+ float32x4_t __s1_453 = __p1_453; \
+ float32x4_t __s2_453 = __p2_453; \
+ float32x4_t __rev0_453; __rev0_453 = __builtin_shufflevector(__s0_453, __s0_453, 3, 2, 1, 0); \
+ float32x4_t __rev1_453; __rev1_453 = __builtin_shufflevector(__s1_453, __s1_453, 3, 2, 1, 0); \
+ float32x4_t __rev2_453; __rev2_453 = __builtin_shufflevector(__s2_453, __s2_453, 3, 2, 1, 0); \
+ __ret_453 = __rev0_453 + __rev1_453 * __noswap_splatq_laneq_f32(__rev2_453, __p3_453); \
+ __ret_453 = __builtin_shufflevector(__ret_453, __ret_453, 3, 2, 1, 0); \
+ __ret_453; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmull_laneq_s16(__p0_586, __p1_586, __p2_586) __extension__ ({ \
- int32x4_t __ret_586; \
- int16x4_t __s0_586 = __p0_586; \
- int16x8_t __s1_586 = __p1_586; \
- __ret_586 = vmull_s16(__s0_586, splat_laneq_s16(__s1_586, __p2_586)); \
- __ret_586; \
+#define vmlaq_laneq_s32(__p0_454, __p1_454, __p2_454, __p3_454) __extension__ ({ \
+ int32x4_t __ret_454; \
+ int32x4_t __s0_454 = __p0_454; \
+ int32x4_t __s1_454 = __p1_454; \
+ int32x4_t __s2_454 = __p2_454; \
+ __ret_454 = __s0_454 + __s1_454 * splatq_laneq_s32(__s2_454, __p3_454); \
+ __ret_454; \
})
#else
-#define vmull_laneq_s16(__p0_587, __p1_587, __p2_587) __extension__ ({ \
- int32x4_t __ret_587; \
- int16x4_t __s0_587 = __p0_587; \
- int16x8_t __s1_587 = __p1_587; \
- int16x4_t __rev0_587; __rev0_587 = __builtin_shufflevector(__s0_587, __s0_587, 3, 2, 1, 0); \
- int16x8_t __rev1_587; __rev1_587 = __builtin_shufflevector(__s1_587, __s1_587, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_587 = __noswap_vmull_s16(__rev0_587, __noswap_splat_laneq_s16(__rev1_587, __p2_587)); \
- __ret_587 = __builtin_shufflevector(__ret_587, __ret_587, 3, 2, 1, 0); \
- __ret_587; \
+#define vmlaq_laneq_s32(__p0_455, __p1_455, __p2_455, __p3_455) __extension__ ({ \
+ int32x4_t __ret_455; \
+ int32x4_t __s0_455 = __p0_455; \
+ int32x4_t __s1_455 = __p1_455; \
+ int32x4_t __s2_455 = __p2_455; \
+ int32x4_t __rev0_455; __rev0_455 = __builtin_shufflevector(__s0_455, __s0_455, 3, 2, 1, 0); \
+ int32x4_t __rev1_455; __rev1_455 = __builtin_shufflevector(__s1_455, __s1_455, 3, 2, 1, 0); \
+ int32x4_t __rev2_455; __rev2_455 = __builtin_shufflevector(__s2_455, __s2_455, 3, 2, 1, 0); \
+ __ret_455 = __rev0_455 + __rev1_455 * __noswap_splatq_laneq_s32(__rev2_455, __p3_455); \
+ __ret_455 = __builtin_shufflevector(__ret_455, __ret_455, 3, 2, 1, 0); \
+ __ret_455; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vmulxq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vmulxq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
- return __ret;
-}
-#else
-__ai float64x2_t vmulxq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vmulxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai float64x2_t __noswap_vmulxq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vmulxq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vmulxq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vmulxq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
- return __ret;
-}
+#define vmlaq_laneq_s16(__p0_456, __p1_456, __p2_456, __p3_456) __extension__ ({ \
+ int16x8_t __ret_456; \
+ int16x8_t __s0_456 = __p0_456; \
+ int16x8_t __s1_456 = __p1_456; \
+ int16x8_t __s2_456 = __p2_456; \
+ __ret_456 = __s0_456 + __s1_456 * splatq_laneq_s16(__s2_456, __p3_456); \
+ __ret_456; \
+})
#else
-__ai float32x4_t vmulxq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vmulxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai float32x4_t __noswap_vmulxq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vmulxq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
- return __ret;
-}
+#define vmlaq_laneq_s16(__p0_457, __p1_457, __p2_457, __p3_457) __extension__ ({ \
+ int16x8_t __ret_457; \
+ int16x8_t __s0_457 = __p0_457; \
+ int16x8_t __s1_457 = __p1_457; \
+ int16x8_t __s2_457 = __p2_457; \
+ int16x8_t __rev0_457; __rev0_457 = __builtin_shufflevector(__s0_457, __s0_457, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1_457; __rev1_457 = __builtin_shufflevector(__s1_457, __s1_457, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev2_457; __rev2_457 = __builtin_shufflevector(__s2_457, __s2_457, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_457 = __rev0_457 + __rev1_457 * __noswap_splatq_laneq_s16(__rev2_457, __p3_457); \
+ __ret_457 = __builtin_shufflevector(__ret_457, __ret_457, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_457; \
+})
#endif
-__ai float64x1_t vmulx_f64(float64x1_t __p0, float64x1_t __p1) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vmulx_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vmulx_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vmulx_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
- return __ret;
-}
+#define vmla_laneq_u32(__p0_458, __p1_458, __p2_458, __p3_458) __extension__ ({ \
+ uint32x2_t __ret_458; \
+ uint32x2_t __s0_458 = __p0_458; \
+ uint32x2_t __s1_458 = __p1_458; \
+ uint32x4_t __s2_458 = __p2_458; \
+ __ret_458 = __s0_458 + __s1_458 * splat_laneq_u32(__s2_458, __p3_458); \
+ __ret_458; \
+})
#else
-__ai float32x2_t vmulx_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vmulx_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai float32x2_t __noswap_vmulx_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vmulx_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
- return __ret;
-}
+#define vmla_laneq_u32(__p0_459, __p1_459, __p2_459, __p3_459) __extension__ ({ \
+ uint32x2_t __ret_459; \
+ uint32x2_t __s0_459 = __p0_459; \
+ uint32x2_t __s1_459 = __p1_459; \
+ uint32x4_t __s2_459 = __p2_459; \
+ uint32x2_t __rev0_459; __rev0_459 = __builtin_shufflevector(__s0_459, __s0_459, 1, 0); \
+ uint32x2_t __rev1_459; __rev1_459 = __builtin_shufflevector(__s1_459, __s1_459, 1, 0); \
+ uint32x4_t __rev2_459; __rev2_459 = __builtin_shufflevector(__s2_459, __s2_459, 3, 2, 1, 0); \
+ __ret_459 = __rev0_459 + __rev1_459 * __noswap_splat_laneq_u32(__rev2_459, __p3_459); \
+ __ret_459 = __builtin_shufflevector(__ret_459, __ret_459, 1, 0); \
+ __ret_459; \
+})
#endif
-__ai float64_t vmulxd_f64(float64_t __p0, float64_t __p1) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vmulxd_f64(__p0, __p1);
- return __ret;
-}
-__ai float32_t vmulxs_f32(float32_t __p0, float32_t __p1) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vmulxs_f32(__p0, __p1);
- return __ret;
-}
-#define vmulxd_lane_f64(__p0_588, __p1_588, __p2_588) __extension__ ({ \
- float64_t __ret_588; \
- float64_t __s0_588 = __p0_588; \
- float64x1_t __s1_588 = __p1_588; \
- __ret_588 = vmulxd_f64(__s0_588, vget_lane_f64(__s1_588, __p2_588)); \
- __ret_588; \
-})
#ifdef __LITTLE_ENDIAN__
-#define vmulxs_lane_f32(__p0_589, __p1_589, __p2_589) __extension__ ({ \
- float32_t __ret_589; \
- float32_t __s0_589 = __p0_589; \
- float32x2_t __s1_589 = __p1_589; \
- __ret_589 = vmulxs_f32(__s0_589, vget_lane_f32(__s1_589, __p2_589)); \
- __ret_589; \
+#define vmla_laneq_u16(__p0_460, __p1_460, __p2_460, __p3_460) __extension__ ({ \
+ uint16x4_t __ret_460; \
+ uint16x4_t __s0_460 = __p0_460; \
+ uint16x4_t __s1_460 = __p1_460; \
+ uint16x8_t __s2_460 = __p2_460; \
+ __ret_460 = __s0_460 + __s1_460 * splat_laneq_u16(__s2_460, __p3_460); \
+ __ret_460; \
})
#else
-#define vmulxs_lane_f32(__p0_590, __p1_590, __p2_590) __extension__ ({ \
- float32_t __ret_590; \
- float32_t __s0_590 = __p0_590; \
- float32x2_t __s1_590 = __p1_590; \
- float32x2_t __rev1_590; __rev1_590 = __builtin_shufflevector(__s1_590, __s1_590, 1, 0); \
- __ret_590 = vmulxs_f32(__s0_590, __noswap_vget_lane_f32(__rev1_590, __p2_590)); \
- __ret_590; \
+#define vmla_laneq_u16(__p0_461, __p1_461, __p2_461, __p3_461) __extension__ ({ \
+ uint16x4_t __ret_461; \
+ uint16x4_t __s0_461 = __p0_461; \
+ uint16x4_t __s1_461 = __p1_461; \
+ uint16x8_t __s2_461 = __p2_461; \
+ uint16x4_t __rev0_461; __rev0_461 = __builtin_shufflevector(__s0_461, __s0_461, 3, 2, 1, 0); \
+ uint16x4_t __rev1_461; __rev1_461 = __builtin_shufflevector(__s1_461, __s1_461, 3, 2, 1, 0); \
+ uint16x8_t __rev2_461; __rev2_461 = __builtin_shufflevector(__s2_461, __s2_461, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_461 = __rev0_461 + __rev1_461 * __noswap_splat_laneq_u16(__rev2_461, __p3_461); \
+ __ret_461 = __builtin_shufflevector(__ret_461, __ret_461, 3, 2, 1, 0); \
+ __ret_461; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulxq_lane_f64(__p0_591, __p1_591, __p2_591) __extension__ ({ \
- float64x2_t __ret_591; \
- float64x2_t __s0_591 = __p0_591; \
- float64x1_t __s1_591 = __p1_591; \
- __ret_591 = vmulxq_f64(__s0_591, splatq_lane_f64(__s1_591, __p2_591)); \
- __ret_591; \
+#define vmla_laneq_f32(__p0_462, __p1_462, __p2_462, __p3_462) __extension__ ({ \
+ float32x2_t __ret_462; \
+ float32x2_t __s0_462 = __p0_462; \
+ float32x2_t __s1_462 = __p1_462; \
+ float32x4_t __s2_462 = __p2_462; \
+ __ret_462 = __s0_462 + __s1_462 * splat_laneq_f32(__s2_462, __p3_462); \
+ __ret_462; \
})
#else
-#define vmulxq_lane_f64(__p0_592, __p1_592, __p2_592) __extension__ ({ \
- float64x2_t __ret_592; \
- float64x2_t __s0_592 = __p0_592; \
- float64x1_t __s1_592 = __p1_592; \
- float64x2_t __rev0_592; __rev0_592 = __builtin_shufflevector(__s0_592, __s0_592, 1, 0); \
- __ret_592 = __noswap_vmulxq_f64(__rev0_592, __noswap_splatq_lane_f64(__s1_592, __p2_592)); \
- __ret_592 = __builtin_shufflevector(__ret_592, __ret_592, 1, 0); \
- __ret_592; \
+#define vmla_laneq_f32(__p0_463, __p1_463, __p2_463, __p3_463) __extension__ ({ \
+ float32x2_t __ret_463; \
+ float32x2_t __s0_463 = __p0_463; \
+ float32x2_t __s1_463 = __p1_463; \
+ float32x4_t __s2_463 = __p2_463; \
+ float32x2_t __rev0_463; __rev0_463 = __builtin_shufflevector(__s0_463, __s0_463, 1, 0); \
+ float32x2_t __rev1_463; __rev1_463 = __builtin_shufflevector(__s1_463, __s1_463, 1, 0); \
+ float32x4_t __rev2_463; __rev2_463 = __builtin_shufflevector(__s2_463, __s2_463, 3, 2, 1, 0); \
+ __ret_463 = __rev0_463 + __rev1_463 * __noswap_splat_laneq_f32(__rev2_463, __p3_463); \
+ __ret_463 = __builtin_shufflevector(__ret_463, __ret_463, 1, 0); \
+ __ret_463; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulxq_lane_f32(__p0_593, __p1_593, __p2_593) __extension__ ({ \
- float32x4_t __ret_593; \
- float32x4_t __s0_593 = __p0_593; \
- float32x2_t __s1_593 = __p1_593; \
- __ret_593 = vmulxq_f32(__s0_593, splatq_lane_f32(__s1_593, __p2_593)); \
- __ret_593; \
+#define vmla_laneq_s32(__p0_464, __p1_464, __p2_464, __p3_464) __extension__ ({ \
+ int32x2_t __ret_464; \
+ int32x2_t __s0_464 = __p0_464; \
+ int32x2_t __s1_464 = __p1_464; \
+ int32x4_t __s2_464 = __p2_464; \
+ __ret_464 = __s0_464 + __s1_464 * splat_laneq_s32(__s2_464, __p3_464); \
+ __ret_464; \
})
#else
-#define vmulxq_lane_f32(__p0_594, __p1_594, __p2_594) __extension__ ({ \
- float32x4_t __ret_594; \
- float32x4_t __s0_594 = __p0_594; \
- float32x2_t __s1_594 = __p1_594; \
- float32x4_t __rev0_594; __rev0_594 = __builtin_shufflevector(__s0_594, __s0_594, 3, 2, 1, 0); \
- float32x2_t __rev1_594; __rev1_594 = __builtin_shufflevector(__s1_594, __s1_594, 1, 0); \
- __ret_594 = __noswap_vmulxq_f32(__rev0_594, __noswap_splatq_lane_f32(__rev1_594, __p2_594)); \
- __ret_594 = __builtin_shufflevector(__ret_594, __ret_594, 3, 2, 1, 0); \
- __ret_594; \
+#define vmla_laneq_s32(__p0_465, __p1_465, __p2_465, __p3_465) __extension__ ({ \
+ int32x2_t __ret_465; \
+ int32x2_t __s0_465 = __p0_465; \
+ int32x2_t __s1_465 = __p1_465; \
+ int32x4_t __s2_465 = __p2_465; \
+ int32x2_t __rev0_465; __rev0_465 = __builtin_shufflevector(__s0_465, __s0_465, 1, 0); \
+ int32x2_t __rev1_465; __rev1_465 = __builtin_shufflevector(__s1_465, __s1_465, 1, 0); \
+ int32x4_t __rev2_465; __rev2_465 = __builtin_shufflevector(__s2_465, __s2_465, 3, 2, 1, 0); \
+ __ret_465 = __rev0_465 + __rev1_465 * __noswap_splat_laneq_s32(__rev2_465, __p3_465); \
+ __ret_465 = __builtin_shufflevector(__ret_465, __ret_465, 1, 0); \
+ __ret_465; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulx_lane_f32(__p0_595, __p1_595, __p2_595) __extension__ ({ \
- float32x2_t __ret_595; \
- float32x2_t __s0_595 = __p0_595; \
- float32x2_t __s1_595 = __p1_595; \
- __ret_595 = vmulx_f32(__s0_595, splat_lane_f32(__s1_595, __p2_595)); \
- __ret_595; \
+#define vmla_laneq_s16(__p0_466, __p1_466, __p2_466, __p3_466) __extension__ ({ \
+ int16x4_t __ret_466; \
+ int16x4_t __s0_466 = __p0_466; \
+ int16x4_t __s1_466 = __p1_466; \
+ int16x8_t __s2_466 = __p2_466; \
+ __ret_466 = __s0_466 + __s1_466 * splat_laneq_s16(__s2_466, __p3_466); \
+ __ret_466; \
})
#else
-#define vmulx_lane_f32(__p0_596, __p1_596, __p2_596) __extension__ ({ \
- float32x2_t __ret_596; \
- float32x2_t __s0_596 = __p0_596; \
- float32x2_t __s1_596 = __p1_596; \
- float32x2_t __rev0_596; __rev0_596 = __builtin_shufflevector(__s0_596, __s0_596, 1, 0); \
- float32x2_t __rev1_596; __rev1_596 = __builtin_shufflevector(__s1_596, __s1_596, 1, 0); \
- __ret_596 = __noswap_vmulx_f32(__rev0_596, __noswap_splat_lane_f32(__rev1_596, __p2_596)); \
- __ret_596 = __builtin_shufflevector(__ret_596, __ret_596, 1, 0); \
- __ret_596; \
+#define vmla_laneq_s16(__p0_467, __p1_467, __p2_467, __p3_467) __extension__ ({ \
+ int16x4_t __ret_467; \
+ int16x4_t __s0_467 = __p0_467; \
+ int16x4_t __s1_467 = __p1_467; \
+ int16x8_t __s2_467 = __p2_467; \
+ int16x4_t __rev0_467; __rev0_467 = __builtin_shufflevector(__s0_467, __s0_467, 3, 2, 1, 0); \
+ int16x4_t __rev1_467; __rev1_467 = __builtin_shufflevector(__s1_467, __s1_467, 3, 2, 1, 0); \
+ int16x8_t __rev2_467; __rev2_467 = __builtin_shufflevector(__s2_467, __s2_467, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_467 = __rev0_467 + __rev1_467 * __noswap_splat_laneq_s16(__rev2_467, __p3_467); \
+ __ret_467 = __builtin_shufflevector(__ret_467, __ret_467, 3, 2, 1, 0); \
+ __ret_467; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulxd_laneq_f64(__p0_597, __p1_597, __p2_597) __extension__ ({ \
- float64_t __ret_597; \
- float64_t __s0_597 = __p0_597; \
- float64x2_t __s1_597 = __p1_597; \
- __ret_597 = vmulxd_f64(__s0_597, vgetq_lane_f64(__s1_597, __p2_597)); \
- __ret_597; \
+#define vmlal_high_lane_u32(__p0_468, __p1_468, __p2_468, __p3_468) __extension__ ({ \
+ uint64x2_t __ret_468; \
+ uint64x2_t __s0_468 = __p0_468; \
+ uint32x4_t __s1_468 = __p1_468; \
+ uint32x2_t __s2_468 = __p2_468; \
+ __ret_468 = __s0_468 + vmull_u32(vget_high_u32(__s1_468), splat_lane_u32(__s2_468, __p3_468)); \
+ __ret_468; \
})
#else
-#define vmulxd_laneq_f64(__p0_598, __p1_598, __p2_598) __extension__ ({ \
- float64_t __ret_598; \
- float64_t __s0_598 = __p0_598; \
- float64x2_t __s1_598 = __p1_598; \
- float64x2_t __rev1_598; __rev1_598 = __builtin_shufflevector(__s1_598, __s1_598, 1, 0); \
- __ret_598 = vmulxd_f64(__s0_598, __noswap_vgetq_lane_f64(__rev1_598, __p2_598)); \
- __ret_598; \
+#define vmlal_high_lane_u32(__p0_469, __p1_469, __p2_469, __p3_469) __extension__ ({ \
+ uint64x2_t __ret_469; \
+ uint64x2_t __s0_469 = __p0_469; \
+ uint32x4_t __s1_469 = __p1_469; \
+ uint32x2_t __s2_469 = __p2_469; \
+ uint64x2_t __rev0_469; __rev0_469 = __builtin_shufflevector(__s0_469, __s0_469, 1, 0); \
+ uint32x4_t __rev1_469; __rev1_469 = __builtin_shufflevector(__s1_469, __s1_469, 3, 2, 1, 0); \
+ uint32x2_t __rev2_469; __rev2_469 = __builtin_shufflevector(__s2_469, __s2_469, 1, 0); \
+ __ret_469 = __rev0_469 + __noswap_vmull_u32(__noswap_vget_high_u32(__rev1_469), __noswap_splat_lane_u32(__rev2_469, __p3_469)); \
+ __ret_469 = __builtin_shufflevector(__ret_469, __ret_469, 1, 0); \
+ __ret_469; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulxs_laneq_f32(__p0_599, __p1_599, __p2_599) __extension__ ({ \
- float32_t __ret_599; \
- float32_t __s0_599 = __p0_599; \
- float32x4_t __s1_599 = __p1_599; \
- __ret_599 = vmulxs_f32(__s0_599, vgetq_lane_f32(__s1_599, __p2_599)); \
- __ret_599; \
+#define vmlal_high_lane_u16(__p0_470, __p1_470, __p2_470, __p3_470) __extension__ ({ \
+ uint32x4_t __ret_470; \
+ uint32x4_t __s0_470 = __p0_470; \
+ uint16x8_t __s1_470 = __p1_470; \
+ uint16x4_t __s2_470 = __p2_470; \
+ __ret_470 = __s0_470 + vmull_u16(vget_high_u16(__s1_470), splat_lane_u16(__s2_470, __p3_470)); \
+ __ret_470; \
})
#else
-#define vmulxs_laneq_f32(__p0_600, __p1_600, __p2_600) __extension__ ({ \
- float32_t __ret_600; \
- float32_t __s0_600 = __p0_600; \
- float32x4_t __s1_600 = __p1_600; \
- float32x4_t __rev1_600; __rev1_600 = __builtin_shufflevector(__s1_600, __s1_600, 3, 2, 1, 0); \
- __ret_600 = vmulxs_f32(__s0_600, __noswap_vgetq_lane_f32(__rev1_600, __p2_600)); \
- __ret_600; \
+#define vmlal_high_lane_u16(__p0_471, __p1_471, __p2_471, __p3_471) __extension__ ({ \
+ uint32x4_t __ret_471; \
+ uint32x4_t __s0_471 = __p0_471; \
+ uint16x8_t __s1_471 = __p1_471; \
+ uint16x4_t __s2_471 = __p2_471; \
+ uint32x4_t __rev0_471; __rev0_471 = __builtin_shufflevector(__s0_471, __s0_471, 3, 2, 1, 0); \
+ uint16x8_t __rev1_471; __rev1_471 = __builtin_shufflevector(__s1_471, __s1_471, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x4_t __rev2_471; __rev2_471 = __builtin_shufflevector(__s2_471, __s2_471, 3, 2, 1, 0); \
+ __ret_471 = __rev0_471 + __noswap_vmull_u16(__noswap_vget_high_u16(__rev1_471), __noswap_splat_lane_u16(__rev2_471, __p3_471)); \
+ __ret_471 = __builtin_shufflevector(__ret_471, __ret_471, 3, 2, 1, 0); \
+ __ret_471; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulxq_laneq_f64(__p0_601, __p1_601, __p2_601) __extension__ ({ \
- float64x2_t __ret_601; \
- float64x2_t __s0_601 = __p0_601; \
- float64x2_t __s1_601 = __p1_601; \
- __ret_601 = vmulxq_f64(__s0_601, splatq_laneq_f64(__s1_601, __p2_601)); \
- __ret_601; \
+#define vmlal_high_lane_s32(__p0_472, __p1_472, __p2_472, __p3_472) __extension__ ({ \
+ int64x2_t __ret_472; \
+ int64x2_t __s0_472 = __p0_472; \
+ int32x4_t __s1_472 = __p1_472; \
+ int32x2_t __s2_472 = __p2_472; \
+ __ret_472 = __s0_472 + vmull_s32(vget_high_s32(__s1_472), splat_lane_s32(__s2_472, __p3_472)); \
+ __ret_472; \
})
#else
-#define vmulxq_laneq_f64(__p0_602, __p1_602, __p2_602) __extension__ ({ \
- float64x2_t __ret_602; \
- float64x2_t __s0_602 = __p0_602; \
- float64x2_t __s1_602 = __p1_602; \
- float64x2_t __rev0_602; __rev0_602 = __builtin_shufflevector(__s0_602, __s0_602, 1, 0); \
- float64x2_t __rev1_602; __rev1_602 = __builtin_shufflevector(__s1_602, __s1_602, 1, 0); \
- __ret_602 = __noswap_vmulxq_f64(__rev0_602, __noswap_splatq_laneq_f64(__rev1_602, __p2_602)); \
- __ret_602 = __builtin_shufflevector(__ret_602, __ret_602, 1, 0); \
- __ret_602; \
+#define vmlal_high_lane_s32(__p0_473, __p1_473, __p2_473, __p3_473) __extension__ ({ \
+ int64x2_t __ret_473; \
+ int64x2_t __s0_473 = __p0_473; \
+ int32x4_t __s1_473 = __p1_473; \
+ int32x2_t __s2_473 = __p2_473; \
+ int64x2_t __rev0_473; __rev0_473 = __builtin_shufflevector(__s0_473, __s0_473, 1, 0); \
+ int32x4_t __rev1_473; __rev1_473 = __builtin_shufflevector(__s1_473, __s1_473, 3, 2, 1, 0); \
+ int32x2_t __rev2_473; __rev2_473 = __builtin_shufflevector(__s2_473, __s2_473, 1, 0); \
+ __ret_473 = __rev0_473 + __noswap_vmull_s32(__noswap_vget_high_s32(__rev1_473), __noswap_splat_lane_s32(__rev2_473, __p3_473)); \
+ __ret_473 = __builtin_shufflevector(__ret_473, __ret_473, 1, 0); \
+ __ret_473; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulxq_laneq_f32(__p0_603, __p1_603, __p2_603) __extension__ ({ \
- float32x4_t __ret_603; \
- float32x4_t __s0_603 = __p0_603; \
- float32x4_t __s1_603 = __p1_603; \
- __ret_603 = vmulxq_f32(__s0_603, splatq_laneq_f32(__s1_603, __p2_603)); \
- __ret_603; \
+#define vmlal_high_lane_s16(__p0_474, __p1_474, __p2_474, __p3_474) __extension__ ({ \
+ int32x4_t __ret_474; \
+ int32x4_t __s0_474 = __p0_474; \
+ int16x8_t __s1_474 = __p1_474; \
+ int16x4_t __s2_474 = __p2_474; \
+ __ret_474 = __s0_474 + vmull_s16(vget_high_s16(__s1_474), splat_lane_s16(__s2_474, __p3_474)); \
+ __ret_474; \
})
#else
-#define vmulxq_laneq_f32(__p0_604, __p1_604, __p2_604) __extension__ ({ \
- float32x4_t __ret_604; \
- float32x4_t __s0_604 = __p0_604; \
- float32x4_t __s1_604 = __p1_604; \
- float32x4_t __rev0_604; __rev0_604 = __builtin_shufflevector(__s0_604, __s0_604, 3, 2, 1, 0); \
- float32x4_t __rev1_604; __rev1_604 = __builtin_shufflevector(__s1_604, __s1_604, 3, 2, 1, 0); \
- __ret_604 = __noswap_vmulxq_f32(__rev0_604, __noswap_splatq_laneq_f32(__rev1_604, __p2_604)); \
- __ret_604 = __builtin_shufflevector(__ret_604, __ret_604, 3, 2, 1, 0); \
- __ret_604; \
+#define vmlal_high_lane_s16(__p0_475, __p1_475, __p2_475, __p3_475) __extension__ ({ \
+ int32x4_t __ret_475; \
+ int32x4_t __s0_475 = __p0_475; \
+ int16x8_t __s1_475 = __p1_475; \
+ int16x4_t __s2_475 = __p2_475; \
+ int32x4_t __rev0_475; __rev0_475 = __builtin_shufflevector(__s0_475, __s0_475, 3, 2, 1, 0); \
+ int16x8_t __rev1_475; __rev1_475 = __builtin_shufflevector(__s1_475, __s1_475, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x4_t __rev2_475; __rev2_475 = __builtin_shufflevector(__s2_475, __s2_475, 3, 2, 1, 0); \
+ __ret_475 = __rev0_475 + __noswap_vmull_s16(__noswap_vget_high_s16(__rev1_475), __noswap_splat_lane_s16(__rev2_475, __p3_475)); \
+ __ret_475 = __builtin_shufflevector(__ret_475, __ret_475, 3, 2, 1, 0); \
+ __ret_475; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulx_laneq_f32(__p0_605, __p1_605, __p2_605) __extension__ ({ \
- float32x2_t __ret_605; \
- float32x2_t __s0_605 = __p0_605; \
- float32x4_t __s1_605 = __p1_605; \
- __ret_605 = vmulx_f32(__s0_605, splat_laneq_f32(__s1_605, __p2_605)); \
- __ret_605; \
+#define vmlal_high_laneq_u32(__p0_476, __p1_476, __p2_476, __p3_476) __extension__ ({ \
+ uint64x2_t __ret_476; \
+ uint64x2_t __s0_476 = __p0_476; \
+ uint32x4_t __s1_476 = __p1_476; \
+ uint32x4_t __s2_476 = __p2_476; \
+ __ret_476 = __s0_476 + vmull_u32(vget_high_u32(__s1_476), splat_laneq_u32(__s2_476, __p3_476)); \
+ __ret_476; \
})
#else
-#define vmulx_laneq_f32(__p0_606, __p1_606, __p2_606) __extension__ ({ \
- float32x2_t __ret_606; \
- float32x2_t __s0_606 = __p0_606; \
- float32x4_t __s1_606 = __p1_606; \
- float32x2_t __rev0_606; __rev0_606 = __builtin_shufflevector(__s0_606, __s0_606, 1, 0); \
- float32x4_t __rev1_606; __rev1_606 = __builtin_shufflevector(__s1_606, __s1_606, 3, 2, 1, 0); \
- __ret_606 = __noswap_vmulx_f32(__rev0_606, __noswap_splat_laneq_f32(__rev1_606, __p2_606)); \
- __ret_606 = __builtin_shufflevector(__ret_606, __ret_606, 1, 0); \
- __ret_606; \
+#define vmlal_high_laneq_u32(__p0_477, __p1_477, __p2_477, __p3_477) __extension__ ({ \
+ uint64x2_t __ret_477; \
+ uint64x2_t __s0_477 = __p0_477; \
+ uint32x4_t __s1_477 = __p1_477; \
+ uint32x4_t __s2_477 = __p2_477; \
+ uint64x2_t __rev0_477; __rev0_477 = __builtin_shufflevector(__s0_477, __s0_477, 1, 0); \
+ uint32x4_t __rev1_477; __rev1_477 = __builtin_shufflevector(__s1_477, __s1_477, 3, 2, 1, 0); \
+ uint32x4_t __rev2_477; __rev2_477 = __builtin_shufflevector(__s2_477, __s2_477, 3, 2, 1, 0); \
+ __ret_477 = __rev0_477 + __noswap_vmull_u32(__noswap_vget_high_u32(__rev1_477), __noswap_splat_laneq_u32(__rev2_477, __p3_477)); \
+ __ret_477 = __builtin_shufflevector(__ret_477, __ret_477, 1, 0); \
+ __ret_477; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vnegq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- __ret = -__p0;
- return __ret;
-}
+#define vmlal_high_laneq_u16(__p0_478, __p1_478, __p2_478, __p3_478) __extension__ ({ \
+ uint32x4_t __ret_478; \
+ uint32x4_t __s0_478 = __p0_478; \
+ uint16x8_t __s1_478 = __p1_478; \
+ uint16x8_t __s2_478 = __p2_478; \
+ __ret_478 = __s0_478 + vmull_u16(vget_high_u16(__s1_478), splat_laneq_u16(__s2_478, __p3_478)); \
+ __ret_478; \
+})
#else
-__ai float64x2_t vnegq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = -__rev0;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vmlal_high_laneq_u16(__p0_479, __p1_479, __p2_479, __p3_479) __extension__ ({ \
+ uint32x4_t __ret_479; \
+ uint32x4_t __s0_479 = __p0_479; \
+ uint16x8_t __s1_479 = __p1_479; \
+ uint16x8_t __s2_479 = __p2_479; \
+ uint32x4_t __rev0_479; __rev0_479 = __builtin_shufflevector(__s0_479, __s0_479, 3, 2, 1, 0); \
+ uint16x8_t __rev1_479; __rev1_479 = __builtin_shufflevector(__s1_479, __s1_479, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev2_479; __rev2_479 = __builtin_shufflevector(__s2_479, __s2_479, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_479 = __rev0_479 + __noswap_vmull_u16(__noswap_vget_high_u16(__rev1_479), __noswap_splat_laneq_u16(__rev2_479, __p3_479)); \
+ __ret_479 = __builtin_shufflevector(__ret_479, __ret_479, 3, 2, 1, 0); \
+ __ret_479; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vnegq_s64(int64x2_t __p0) {
- int64x2_t __ret;
- __ret = -__p0;
- return __ret;
-}
+#define vmlal_high_laneq_s32(__p0_480, __p1_480, __p2_480, __p3_480) __extension__ ({ \
+ int64x2_t __ret_480; \
+ int64x2_t __s0_480 = __p0_480; \
+ int32x4_t __s1_480 = __p1_480; \
+ int32x4_t __s2_480 = __p2_480; \
+ __ret_480 = __s0_480 + vmull_s32(vget_high_s32(__s1_480), splat_laneq_s32(__s2_480, __p3_480)); \
+ __ret_480; \
+})
#else
-__ai int64x2_t vnegq_s64(int64x2_t __p0) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = -__rev0;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vmlal_high_laneq_s32(__p0_481, __p1_481, __p2_481, __p3_481) __extension__ ({ \
+ int64x2_t __ret_481; \
+ int64x2_t __s0_481 = __p0_481; \
+ int32x4_t __s1_481 = __p1_481; \
+ int32x4_t __s2_481 = __p2_481; \
+ int64x2_t __rev0_481; __rev0_481 = __builtin_shufflevector(__s0_481, __s0_481, 1, 0); \
+ int32x4_t __rev1_481; __rev1_481 = __builtin_shufflevector(__s1_481, __s1_481, 3, 2, 1, 0); \
+ int32x4_t __rev2_481; __rev2_481 = __builtin_shufflevector(__s2_481, __s2_481, 3, 2, 1, 0); \
+ __ret_481 = __rev0_481 + __noswap_vmull_s32(__noswap_vget_high_s32(__rev1_481), __noswap_splat_laneq_s32(__rev2_481, __p3_481)); \
+ __ret_481 = __builtin_shufflevector(__ret_481, __ret_481, 1, 0); \
+ __ret_481; \
+})
#endif
-__ai float64x1_t vneg_f64(float64x1_t __p0) {
- float64x1_t __ret;
- __ret = -__p0;
- return __ret;
-}
-__ai int64x1_t vneg_s64(int64x1_t __p0) {
- int64x1_t __ret;
- __ret = -__p0;
- return __ret;
-}
-__ai int64_t vnegd_s64(int64_t __p0) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vnegd_s64(__p0);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vpaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
- return __ret;
-}
+#define vmlal_high_laneq_s16(__p0_482, __p1_482, __p2_482, __p3_482) __extension__ ({ \
+ int32x4_t __ret_482; \
+ int32x4_t __s0_482 = __p0_482; \
+ int16x8_t __s1_482 = __p1_482; \
+ int16x8_t __s2_482 = __p2_482; \
+ __ret_482 = __s0_482 + vmull_s16(vget_high_s16(__s1_482), splat_laneq_s16(__s2_482, __p3_482)); \
+ __ret_482; \
+})
#else
-__ai uint8x16_t vpaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vmlal_high_laneq_s16(__p0_483, __p1_483, __p2_483, __p3_483) __extension__ ({ \
+ int32x4_t __ret_483; \
+ int32x4_t __s0_483 = __p0_483; \
+ int16x8_t __s1_483 = __p1_483; \
+ int16x8_t __s2_483 = __p2_483; \
+ int32x4_t __rev0_483; __rev0_483 = __builtin_shufflevector(__s0_483, __s0_483, 3, 2, 1, 0); \
+ int16x8_t __rev1_483; __rev1_483 = __builtin_shufflevector(__s1_483, __s1_483, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev2_483; __rev2_483 = __builtin_shufflevector(__s2_483, __s2_483, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_483 = __rev0_483 + __noswap_vmull_s16(__noswap_vget_high_s16(__rev1_483), __noswap_splat_laneq_s16(__rev2_483, __p3_483)); \
+ __ret_483 = __builtin_shufflevector(__ret_483, __ret_483, 3, 2, 1, 0); \
+ __ret_483; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vpaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
- return __ret;
-}
+#define vmlal_laneq_u32(__p0_484, __p1_484, __p2_484, __p3_484) __extension__ ({ \
+ uint64x2_t __ret_484; \
+ uint64x2_t __s0_484 = __p0_484; \
+ uint32x2_t __s1_484 = __p1_484; \
+ uint32x4_t __s2_484 = __p2_484; \
+ __ret_484 = __s0_484 + vmull_u32(__s1_484, splat_laneq_u32(__s2_484, __p3_484)); \
+ __ret_484; \
+})
#else
-__ai uint32x4_t vpaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vmlal_laneq_u32(__p0_485, __p1_485, __p2_485, __p3_485) __extension__ ({ \
+ uint64x2_t __ret_485; \
+ uint64x2_t __s0_485 = __p0_485; \
+ uint32x2_t __s1_485 = __p1_485; \
+ uint32x4_t __s2_485 = __p2_485; \
+ uint64x2_t __rev0_485; __rev0_485 = __builtin_shufflevector(__s0_485, __s0_485, 1, 0); \
+ uint32x2_t __rev1_485; __rev1_485 = __builtin_shufflevector(__s1_485, __s1_485, 1, 0); \
+ uint32x4_t __rev2_485; __rev2_485 = __builtin_shufflevector(__s2_485, __s2_485, 3, 2, 1, 0); \
+ __ret_485 = __rev0_485 + __noswap_vmull_u32(__rev1_485, __noswap_splat_laneq_u32(__rev2_485, __p3_485)); \
+ __ret_485 = __builtin_shufflevector(__ret_485, __ret_485, 1, 0); \
+ __ret_485; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vpaddq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
- return __ret;
-}
+#define vmlal_laneq_u16(__p0_486, __p1_486, __p2_486, __p3_486) __extension__ ({ \
+ uint32x4_t __ret_486; \
+ uint32x4_t __s0_486 = __p0_486; \
+ uint16x4_t __s1_486 = __p1_486; \
+ uint16x8_t __s2_486 = __p2_486; \
+ __ret_486 = __s0_486 + vmull_u16(__s1_486, splat_laneq_u16(__s2_486, __p3_486)); \
+ __ret_486; \
+})
#else
-__ai uint64x2_t vpaddq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vmlal_laneq_u16(__p0_487, __p1_487, __p2_487, __p3_487) __extension__ ({ \
+ uint32x4_t __ret_487; \
+ uint32x4_t __s0_487 = __p0_487; \
+ uint16x4_t __s1_487 = __p1_487; \
+ uint16x8_t __s2_487 = __p2_487; \
+ uint32x4_t __rev0_487; __rev0_487 = __builtin_shufflevector(__s0_487, __s0_487, 3, 2, 1, 0); \
+ uint16x4_t __rev1_487; __rev1_487 = __builtin_shufflevector(__s1_487, __s1_487, 3, 2, 1, 0); \
+ uint16x8_t __rev2_487; __rev2_487 = __builtin_shufflevector(__s2_487, __s2_487, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_487 = __rev0_487 + __noswap_vmull_u16(__rev1_487, __noswap_splat_laneq_u16(__rev2_487, __p3_487)); \
+ __ret_487 = __builtin_shufflevector(__ret_487, __ret_487, 3, 2, 1, 0); \
+ __ret_487; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vpaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
- return __ret;
-}
+#define vmlal_laneq_s32(__p0_488, __p1_488, __p2_488, __p3_488) __extension__ ({ \
+ int64x2_t __ret_488; \
+ int64x2_t __s0_488 = __p0_488; \
+ int32x2_t __s1_488 = __p1_488; \
+ int32x4_t __s2_488 = __p2_488; \
+ __ret_488 = __s0_488 + vmull_s32(__s1_488, splat_laneq_s32(__s2_488, __p3_488)); \
+ __ret_488; \
+})
#else
-__ai uint16x8_t vpaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vmlal_laneq_s32(__p0_489, __p1_489, __p2_489, __p3_489) __extension__ ({ \
+ int64x2_t __ret_489; \
+ int64x2_t __s0_489 = __p0_489; \
+ int32x2_t __s1_489 = __p1_489; \
+ int32x4_t __s2_489 = __p2_489; \
+ int64x2_t __rev0_489; __rev0_489 = __builtin_shufflevector(__s0_489, __s0_489, 1, 0); \
+ int32x2_t __rev1_489; __rev1_489 = __builtin_shufflevector(__s1_489, __s1_489, 1, 0); \
+ int32x4_t __rev2_489; __rev2_489 = __builtin_shufflevector(__s2_489, __s2_489, 3, 2, 1, 0); \
+ __ret_489 = __rev0_489 + __noswap_vmull_s32(__rev1_489, __noswap_splat_laneq_s32(__rev2_489, __p3_489)); \
+ __ret_489 = __builtin_shufflevector(__ret_489, __ret_489, 1, 0); \
+ __ret_489; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vpaddq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
- return __ret;
-}
+#define vmlal_laneq_s16(__p0_490, __p1_490, __p2_490, __p3_490) __extension__ ({ \
+ int32x4_t __ret_490; \
+ int32x4_t __s0_490 = __p0_490; \
+ int16x4_t __s1_490 = __p1_490; \
+ int16x8_t __s2_490 = __p2_490; \
+ __ret_490 = __s0_490 + vmull_s16(__s1_490, splat_laneq_s16(__s2_490, __p3_490)); \
+ __ret_490; \
+})
#else
-__ai int8x16_t vpaddq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vmlal_laneq_s16(__p0_491, __p1_491, __p2_491, __p3_491) __extension__ ({ \
+ int32x4_t __ret_491; \
+ int32x4_t __s0_491 = __p0_491; \
+ int16x4_t __s1_491 = __p1_491; \
+ int16x8_t __s2_491 = __p2_491; \
+ int32x4_t __rev0_491; __rev0_491 = __builtin_shufflevector(__s0_491, __s0_491, 3, 2, 1, 0); \
+ int16x4_t __rev1_491; __rev1_491 = __builtin_shufflevector(__s1_491, __s1_491, 3, 2, 1, 0); \
+ int16x8_t __rev2_491; __rev2_491 = __builtin_shufflevector(__s2_491, __s2_491, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_491 = __rev0_491 + __noswap_vmull_s16(__rev1_491, __noswap_splat_laneq_s16(__rev2_491, __p3_491)); \
+ __ret_491 = __builtin_shufflevector(__ret_491, __ret_491, 3, 2, 1, 0); \
+ __ret_491; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vpaddq_f64(float64x2_t __p0, float64x2_t __p1) {
+__ai __attribute__((target("neon"))) float64x2_t vmlsq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+ __ret = __p0 - __p1 * __p2;
return __ret;
}
#else
-__ai float64x2_t vpaddq_f64(float64x2_t __p0, float64x2_t __p1) {
+__ai __attribute__((target("neon"))) float64x2_t vmlsq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
float64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+ float64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = __rev0 - __rev1 * __rev2;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vpaddq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+__ai __attribute__((target("neon"))) float64x1_t vmls_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
+ float64x1_t __ret;
+ __ret = __p0 - __p1 * __p2;
return __ret;
}
+#ifdef __LITTLE_ENDIAN__
+#define vmlsq_laneq_u32(__p0_492, __p1_492, __p2_492, __p3_492) __extension__ ({ \
+ uint32x4_t __ret_492; \
+ uint32x4_t __s0_492 = __p0_492; \
+ uint32x4_t __s1_492 = __p1_492; \
+ uint32x4_t __s2_492 = __p2_492; \
+ __ret_492 = __s0_492 - __s1_492 * splatq_laneq_u32(__s2_492, __p3_492); \
+ __ret_492; \
+})
#else
-__ai float32x4_t vpaddq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vmlsq_laneq_u32(__p0_493, __p1_493, __p2_493, __p3_493) __extension__ ({ \
+ uint32x4_t __ret_493; \
+ uint32x4_t __s0_493 = __p0_493; \
+ uint32x4_t __s1_493 = __p1_493; \
+ uint32x4_t __s2_493 = __p2_493; \
+ uint32x4_t __rev0_493; __rev0_493 = __builtin_shufflevector(__s0_493, __s0_493, 3, 2, 1, 0); \
+ uint32x4_t __rev1_493; __rev1_493 = __builtin_shufflevector(__s1_493, __s1_493, 3, 2, 1, 0); \
+ uint32x4_t __rev2_493; __rev2_493 = __builtin_shufflevector(__s2_493, __s2_493, 3, 2, 1, 0); \
+ __ret_493 = __rev0_493 - __rev1_493 * __noswap_splatq_laneq_u32(__rev2_493, __p3_493); \
+ __ret_493 = __builtin_shufflevector(__ret_493, __ret_493, 3, 2, 1, 0); \
+ __ret_493; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vpaddq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
- return __ret;
-}
+#define vmlsq_laneq_u16(__p0_494, __p1_494, __p2_494, __p3_494) __extension__ ({ \
+ uint16x8_t __ret_494; \
+ uint16x8_t __s0_494 = __p0_494; \
+ uint16x8_t __s1_494 = __p1_494; \
+ uint16x8_t __s2_494 = __p2_494; \
+ __ret_494 = __s0_494 - __s1_494 * splatq_laneq_u16(__s2_494, __p3_494); \
+ __ret_494; \
+})
#else
-__ai int32x4_t vpaddq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vmlsq_laneq_u16(__p0_495, __p1_495, __p2_495, __p3_495) __extension__ ({ \
+ uint16x8_t __ret_495; \
+ uint16x8_t __s0_495 = __p0_495; \
+ uint16x8_t __s1_495 = __p1_495; \
+ uint16x8_t __s2_495 = __p2_495; \
+ uint16x8_t __rev0_495; __rev0_495 = __builtin_shufflevector(__s0_495, __s0_495, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev1_495; __rev1_495 = __builtin_shufflevector(__s1_495, __s1_495, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev2_495; __rev2_495 = __builtin_shufflevector(__s2_495, __s2_495, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_495 = __rev0_495 - __rev1_495 * __noswap_splatq_laneq_u16(__rev2_495, __p3_495); \
+ __ret_495 = __builtin_shufflevector(__ret_495, __ret_495, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_495; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vpaddq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
- return __ret;
-}
+#define vmlsq_laneq_f32(__p0_496, __p1_496, __p2_496, __p3_496) __extension__ ({ \
+ float32x4_t __ret_496; \
+ float32x4_t __s0_496 = __p0_496; \
+ float32x4_t __s1_496 = __p1_496; \
+ float32x4_t __s2_496 = __p2_496; \
+ __ret_496 = __s0_496 - __s1_496 * splatq_laneq_f32(__s2_496, __p3_496); \
+ __ret_496; \
+})
#else
-__ai int64x2_t vpaddq_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vmlsq_laneq_f32(__p0_497, __p1_497, __p2_497, __p3_497) __extension__ ({ \
+ float32x4_t __ret_497; \
+ float32x4_t __s0_497 = __p0_497; \
+ float32x4_t __s1_497 = __p1_497; \
+ float32x4_t __s2_497 = __p2_497; \
+ float32x4_t __rev0_497; __rev0_497 = __builtin_shufflevector(__s0_497, __s0_497, 3, 2, 1, 0); \
+ float32x4_t __rev1_497; __rev1_497 = __builtin_shufflevector(__s1_497, __s1_497, 3, 2, 1, 0); \
+ float32x4_t __rev2_497; __rev2_497 = __builtin_shufflevector(__s2_497, __s2_497, 3, 2, 1, 0); \
+ __ret_497 = __rev0_497 - __rev1_497 * __noswap_splatq_laneq_f32(__rev2_497, __p3_497); \
+ __ret_497 = __builtin_shufflevector(__ret_497, __ret_497, 3, 2, 1, 0); \
+ __ret_497; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vpaddq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
- return __ret;
-}
+#define vmlsq_laneq_s32(__p0_498, __p1_498, __p2_498, __p3_498) __extension__ ({ \
+ int32x4_t __ret_498; \
+ int32x4_t __s0_498 = __p0_498; \
+ int32x4_t __s1_498 = __p1_498; \
+ int32x4_t __s2_498 = __p2_498; \
+ __ret_498 = __s0_498 - __s1_498 * splatq_laneq_s32(__s2_498, __p3_498); \
+ __ret_498; \
+})
#else
-__ai int16x8_t vpaddq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vmlsq_laneq_s32(__p0_499, __p1_499, __p2_499, __p3_499) __extension__ ({ \
+ int32x4_t __ret_499; \
+ int32x4_t __s0_499 = __p0_499; \
+ int32x4_t __s1_499 = __p1_499; \
+ int32x4_t __s2_499 = __p2_499; \
+ int32x4_t __rev0_499; __rev0_499 = __builtin_shufflevector(__s0_499, __s0_499, 3, 2, 1, 0); \
+ int32x4_t __rev1_499; __rev1_499 = __builtin_shufflevector(__s1_499, __s1_499, 3, 2, 1, 0); \
+ int32x4_t __rev2_499; __rev2_499 = __builtin_shufflevector(__s2_499, __s2_499, 3, 2, 1, 0); \
+ __ret_499 = __rev0_499 - __rev1_499 * __noswap_splatq_laneq_s32(__rev2_499, __p3_499); \
+ __ret_499 = __builtin_shufflevector(__ret_499, __ret_499, 3, 2, 1, 0); \
+ __ret_499; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64_t vpaddd_u64(uint64x2_t __p0) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vpaddd_u64(__p0);
- return __ret;
-}
+#define vmlsq_laneq_s16(__p0_500, __p1_500, __p2_500, __p3_500) __extension__ ({ \
+ int16x8_t __ret_500; \
+ int16x8_t __s0_500 = __p0_500; \
+ int16x8_t __s1_500 = __p1_500; \
+ int16x8_t __s2_500 = __p2_500; \
+ __ret_500 = __s0_500 - __s1_500 * splatq_laneq_s16(__s2_500, __p3_500); \
+ __ret_500; \
+})
#else
-__ai uint64_t vpaddd_u64(uint64x2_t __p0) {
- uint64_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (uint64_t) __builtin_neon_vpaddd_u64(__rev0);
- return __ret;
-}
+#define vmlsq_laneq_s16(__p0_501, __p1_501, __p2_501, __p3_501) __extension__ ({ \
+ int16x8_t __ret_501; \
+ int16x8_t __s0_501 = __p0_501; \
+ int16x8_t __s1_501 = __p1_501; \
+ int16x8_t __s2_501 = __p2_501; \
+ int16x8_t __rev0_501; __rev0_501 = __builtin_shufflevector(__s0_501, __s0_501, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1_501; __rev1_501 = __builtin_shufflevector(__s1_501, __s1_501, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev2_501; __rev2_501 = __builtin_shufflevector(__s2_501, __s2_501, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_501 = __rev0_501 - __rev1_501 * __noswap_splatq_laneq_s16(__rev2_501, __p3_501); \
+ __ret_501 = __builtin_shufflevector(__ret_501, __ret_501, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_501; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64_t vpaddd_f64(float64x2_t __p0) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vpaddd_f64(__p0);
- return __ret;
-}
+#define vmls_laneq_u32(__p0_502, __p1_502, __p2_502, __p3_502) __extension__ ({ \
+ uint32x2_t __ret_502; \
+ uint32x2_t __s0_502 = __p0_502; \
+ uint32x2_t __s1_502 = __p1_502; \
+ uint32x4_t __s2_502 = __p2_502; \
+ __ret_502 = __s0_502 - __s1_502 * splat_laneq_u32(__s2_502, __p3_502); \
+ __ret_502; \
+})
#else
-__ai float64_t vpaddd_f64(float64x2_t __p0) {
- float64_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64_t) __builtin_neon_vpaddd_f64(__rev0);
- return __ret;
-}
+#define vmls_laneq_u32(__p0_503, __p1_503, __p2_503, __p3_503) __extension__ ({ \
+ uint32x2_t __ret_503; \
+ uint32x2_t __s0_503 = __p0_503; \
+ uint32x2_t __s1_503 = __p1_503; \
+ uint32x4_t __s2_503 = __p2_503; \
+ uint32x2_t __rev0_503; __rev0_503 = __builtin_shufflevector(__s0_503, __s0_503, 1, 0); \
+ uint32x2_t __rev1_503; __rev1_503 = __builtin_shufflevector(__s1_503, __s1_503, 1, 0); \
+ uint32x4_t __rev2_503; __rev2_503 = __builtin_shufflevector(__s2_503, __s2_503, 3, 2, 1, 0); \
+ __ret_503 = __rev0_503 - __rev1_503 * __noswap_splat_laneq_u32(__rev2_503, __p3_503); \
+ __ret_503 = __builtin_shufflevector(__ret_503, __ret_503, 1, 0); \
+ __ret_503; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64_t vpaddd_s64(int64x2_t __p0) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vpaddd_s64(__p0);
- return __ret;
-}
+#define vmls_laneq_u16(__p0_504, __p1_504, __p2_504, __p3_504) __extension__ ({ \
+ uint16x4_t __ret_504; \
+ uint16x4_t __s0_504 = __p0_504; \
+ uint16x4_t __s1_504 = __p1_504; \
+ uint16x8_t __s2_504 = __p2_504; \
+ __ret_504 = __s0_504 - __s1_504 * splat_laneq_u16(__s2_504, __p3_504); \
+ __ret_504; \
+})
#else
-__ai int64_t vpaddd_s64(int64x2_t __p0) {
- int64_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int64_t) __builtin_neon_vpaddd_s64(__rev0);
- return __ret;
-}
+#define vmls_laneq_u16(__p0_505, __p1_505, __p2_505, __p3_505) __extension__ ({ \
+ uint16x4_t __ret_505; \
+ uint16x4_t __s0_505 = __p0_505; \
+ uint16x4_t __s1_505 = __p1_505; \
+ uint16x8_t __s2_505 = __p2_505; \
+ uint16x4_t __rev0_505; __rev0_505 = __builtin_shufflevector(__s0_505, __s0_505, 3, 2, 1, 0); \
+ uint16x4_t __rev1_505; __rev1_505 = __builtin_shufflevector(__s1_505, __s1_505, 3, 2, 1, 0); \
+ uint16x8_t __rev2_505; __rev2_505 = __builtin_shufflevector(__s2_505, __s2_505, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_505 = __rev0_505 - __rev1_505 * __noswap_splat_laneq_u16(__rev2_505, __p3_505); \
+ __ret_505 = __builtin_shufflevector(__ret_505, __ret_505, 3, 2, 1, 0); \
+ __ret_505; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32_t vpadds_f32(float32x2_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vpadds_f32(__p0);
- return __ret;
-}
+#define vmls_laneq_f32(__p0_506, __p1_506, __p2_506, __p3_506) __extension__ ({ \
+ float32x2_t __ret_506; \
+ float32x2_t __s0_506 = __p0_506; \
+ float32x2_t __s1_506 = __p1_506; \
+ float32x4_t __s2_506 = __p2_506; \
+ __ret_506 = __s0_506 - __s1_506 * splat_laneq_f32(__s2_506, __p3_506); \
+ __ret_506; \
+})
#else
-__ai float32_t vpadds_f32(float32x2_t __p0) {
- float32_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float32_t) __builtin_neon_vpadds_f32(__rev0);
- return __ret;
-}
+#define vmls_laneq_f32(__p0_507, __p1_507, __p2_507, __p3_507) __extension__ ({ \
+ float32x2_t __ret_507; \
+ float32x2_t __s0_507 = __p0_507; \
+ float32x2_t __s1_507 = __p1_507; \
+ float32x4_t __s2_507 = __p2_507; \
+ float32x2_t __rev0_507; __rev0_507 = __builtin_shufflevector(__s0_507, __s0_507, 1, 0); \
+ float32x2_t __rev1_507; __rev1_507 = __builtin_shufflevector(__s1_507, __s1_507, 1, 0); \
+ float32x4_t __rev2_507; __rev2_507 = __builtin_shufflevector(__s2_507, __s2_507, 3, 2, 1, 0); \
+ __ret_507 = __rev0_507 - __rev1_507 * __noswap_splat_laneq_f32(__rev2_507, __p3_507); \
+ __ret_507 = __builtin_shufflevector(__ret_507, __ret_507, 1, 0); \
+ __ret_507; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vpmaxq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
- return __ret;
-}
+#define vmls_laneq_s32(__p0_508, __p1_508, __p2_508, __p3_508) __extension__ ({ \
+ int32x2_t __ret_508; \
+ int32x2_t __s0_508 = __p0_508; \
+ int32x2_t __s1_508 = __p1_508; \
+ int32x4_t __s2_508 = __p2_508; \
+ __ret_508 = __s0_508 - __s1_508 * splat_laneq_s32(__s2_508, __p3_508); \
+ __ret_508; \
+})
#else
-__ai uint8x16_t vpmaxq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vmls_laneq_s32(__p0_509, __p1_509, __p2_509, __p3_509) __extension__ ({ \
+ int32x2_t __ret_509; \
+ int32x2_t __s0_509 = __p0_509; \
+ int32x2_t __s1_509 = __p1_509; \
+ int32x4_t __s2_509 = __p2_509; \
+ int32x2_t __rev0_509; __rev0_509 = __builtin_shufflevector(__s0_509, __s0_509, 1, 0); \
+ int32x2_t __rev1_509; __rev1_509 = __builtin_shufflevector(__s1_509, __s1_509, 1, 0); \
+ int32x4_t __rev2_509; __rev2_509 = __builtin_shufflevector(__s2_509, __s2_509, 3, 2, 1, 0); \
+ __ret_509 = __rev0_509 - __rev1_509 * __noswap_splat_laneq_s32(__rev2_509, __p3_509); \
+ __ret_509 = __builtin_shufflevector(__ret_509, __ret_509, 1, 0); \
+ __ret_509; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vpmaxq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
- return __ret;
-}
+#define vmls_laneq_s16(__p0_510, __p1_510, __p2_510, __p3_510) __extension__ ({ \
+ int16x4_t __ret_510; \
+ int16x4_t __s0_510 = __p0_510; \
+ int16x4_t __s1_510 = __p1_510; \
+ int16x8_t __s2_510 = __p2_510; \
+ __ret_510 = __s0_510 - __s1_510 * splat_laneq_s16(__s2_510, __p3_510); \
+ __ret_510; \
+})
#else
-__ai uint32x4_t vpmaxq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vmls_laneq_s16(__p0_511, __p1_511, __p2_511, __p3_511) __extension__ ({ \
+ int16x4_t __ret_511; \
+ int16x4_t __s0_511 = __p0_511; \
+ int16x4_t __s1_511 = __p1_511; \
+ int16x8_t __s2_511 = __p2_511; \
+ int16x4_t __rev0_511; __rev0_511 = __builtin_shufflevector(__s0_511, __s0_511, 3, 2, 1, 0); \
+ int16x4_t __rev1_511; __rev1_511 = __builtin_shufflevector(__s1_511, __s1_511, 3, 2, 1, 0); \
+ int16x8_t __rev2_511; __rev2_511 = __builtin_shufflevector(__s2_511, __s2_511, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_511 = __rev0_511 - __rev1_511 * __noswap_splat_laneq_s16(__rev2_511, __p3_511); \
+ __ret_511 = __builtin_shufflevector(__ret_511, __ret_511, 3, 2, 1, 0); \
+ __ret_511; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vpmaxq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
- return __ret;
-}
+#define vmlsl_high_lane_u32(__p0_512, __p1_512, __p2_512, __p3_512) __extension__ ({ \
+ uint64x2_t __ret_512; \
+ uint64x2_t __s0_512 = __p0_512; \
+ uint32x4_t __s1_512 = __p1_512; \
+ uint32x2_t __s2_512 = __p2_512; \
+ __ret_512 = __s0_512 - vmull_u32(vget_high_u32(__s1_512), splat_lane_u32(__s2_512, __p3_512)); \
+ __ret_512; \
+})
#else
-__ai uint16x8_t vpmaxq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vmlsl_high_lane_u32(__p0_513, __p1_513, __p2_513, __p3_513) __extension__ ({ \
+ uint64x2_t __ret_513; \
+ uint64x2_t __s0_513 = __p0_513; \
+ uint32x4_t __s1_513 = __p1_513; \
+ uint32x2_t __s2_513 = __p2_513; \
+ uint64x2_t __rev0_513; __rev0_513 = __builtin_shufflevector(__s0_513, __s0_513, 1, 0); \
+ uint32x4_t __rev1_513; __rev1_513 = __builtin_shufflevector(__s1_513, __s1_513, 3, 2, 1, 0); \
+ uint32x2_t __rev2_513; __rev2_513 = __builtin_shufflevector(__s2_513, __s2_513, 1, 0); \
+ __ret_513 = __rev0_513 - __noswap_vmull_u32(__noswap_vget_high_u32(__rev1_513), __noswap_splat_lane_u32(__rev2_513, __p3_513)); \
+ __ret_513 = __builtin_shufflevector(__ret_513, __ret_513, 1, 0); \
+ __ret_513; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vpmaxq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
- return __ret;
-}
+#define vmlsl_high_lane_u16(__p0_514, __p1_514, __p2_514, __p3_514) __extension__ ({ \
+ uint32x4_t __ret_514; \
+ uint32x4_t __s0_514 = __p0_514; \
+ uint16x8_t __s1_514 = __p1_514; \
+ uint16x4_t __s2_514 = __p2_514; \
+ __ret_514 = __s0_514 - vmull_u16(vget_high_u16(__s1_514), splat_lane_u16(__s2_514, __p3_514)); \
+ __ret_514; \
+})
#else
-__ai int8x16_t vpmaxq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vmlsl_high_lane_u16(__p0_515, __p1_515, __p2_515, __p3_515) __extension__ ({ \
+ uint32x4_t __ret_515; \
+ uint32x4_t __s0_515 = __p0_515; \
+ uint16x8_t __s1_515 = __p1_515; \
+ uint16x4_t __s2_515 = __p2_515; \
+ uint32x4_t __rev0_515; __rev0_515 = __builtin_shufflevector(__s0_515, __s0_515, 3, 2, 1, 0); \
+ uint16x8_t __rev1_515; __rev1_515 = __builtin_shufflevector(__s1_515, __s1_515, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x4_t __rev2_515; __rev2_515 = __builtin_shufflevector(__s2_515, __s2_515, 3, 2, 1, 0); \
+ __ret_515 = __rev0_515 - __noswap_vmull_u16(__noswap_vget_high_u16(__rev1_515), __noswap_splat_lane_u16(__rev2_515, __p3_515)); \
+ __ret_515 = __builtin_shufflevector(__ret_515, __ret_515, 3, 2, 1, 0); \
+ __ret_515; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vpmaxq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
- return __ret;
-}
+#define vmlsl_high_lane_s32(__p0_516, __p1_516, __p2_516, __p3_516) __extension__ ({ \
+ int64x2_t __ret_516; \
+ int64x2_t __s0_516 = __p0_516; \
+ int32x4_t __s1_516 = __p1_516; \
+ int32x2_t __s2_516 = __p2_516; \
+ __ret_516 = __s0_516 - vmull_s32(vget_high_s32(__s1_516), splat_lane_s32(__s2_516, __p3_516)); \
+ __ret_516; \
+})
#else
-__ai float64x2_t vpmaxq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vmlsl_high_lane_s32(__p0_517, __p1_517, __p2_517, __p3_517) __extension__ ({ \
+ int64x2_t __ret_517; \
+ int64x2_t __s0_517 = __p0_517; \
+ int32x4_t __s1_517 = __p1_517; \
+ int32x2_t __s2_517 = __p2_517; \
+ int64x2_t __rev0_517; __rev0_517 = __builtin_shufflevector(__s0_517, __s0_517, 1, 0); \
+ int32x4_t __rev1_517; __rev1_517 = __builtin_shufflevector(__s1_517, __s1_517, 3, 2, 1, 0); \
+ int32x2_t __rev2_517; __rev2_517 = __builtin_shufflevector(__s2_517, __s2_517, 1, 0); \
+ __ret_517 = __rev0_517 - __noswap_vmull_s32(__noswap_vget_high_s32(__rev1_517), __noswap_splat_lane_s32(__rev2_517, __p3_517)); \
+ __ret_517 = __builtin_shufflevector(__ret_517, __ret_517, 1, 0); \
+ __ret_517; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vpmaxq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
- return __ret;
-}
+#define vmlsl_high_lane_s16(__p0_518, __p1_518, __p2_518, __p3_518) __extension__ ({ \
+ int32x4_t __ret_518; \
+ int32x4_t __s0_518 = __p0_518; \
+ int16x8_t __s1_518 = __p1_518; \
+ int16x4_t __s2_518 = __p2_518; \
+ __ret_518 = __s0_518 - vmull_s16(vget_high_s16(__s1_518), splat_lane_s16(__s2_518, __p3_518)); \
+ __ret_518; \
+})
#else
-__ai float32x4_t vpmaxq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vmlsl_high_lane_s16(__p0_519, __p1_519, __p2_519, __p3_519) __extension__ ({ \
+ int32x4_t __ret_519; \
+ int32x4_t __s0_519 = __p0_519; \
+ int16x8_t __s1_519 = __p1_519; \
+ int16x4_t __s2_519 = __p2_519; \
+ int32x4_t __rev0_519; __rev0_519 = __builtin_shufflevector(__s0_519, __s0_519, 3, 2, 1, 0); \
+ int16x8_t __rev1_519; __rev1_519 = __builtin_shufflevector(__s1_519, __s1_519, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x4_t __rev2_519; __rev2_519 = __builtin_shufflevector(__s2_519, __s2_519, 3, 2, 1, 0); \
+ __ret_519 = __rev0_519 - __noswap_vmull_s16(__noswap_vget_high_s16(__rev1_519), __noswap_splat_lane_s16(__rev2_519, __p3_519)); \
+ __ret_519 = __builtin_shufflevector(__ret_519, __ret_519, 3, 2, 1, 0); \
+ __ret_519; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vpmaxq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
- return __ret;
-}
+#define vmlsl_high_laneq_u32(__p0_520, __p1_520, __p2_520, __p3_520) __extension__ ({ \
+ uint64x2_t __ret_520; \
+ uint64x2_t __s0_520 = __p0_520; \
+ uint32x4_t __s1_520 = __p1_520; \
+ uint32x4_t __s2_520 = __p2_520; \
+ __ret_520 = __s0_520 - vmull_u32(vget_high_u32(__s1_520), splat_laneq_u32(__s2_520, __p3_520)); \
+ __ret_520; \
+})
#else
-__ai int32x4_t vpmaxq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vmlsl_high_laneq_u32(__p0_521, __p1_521, __p2_521, __p3_521) __extension__ ({ \
+ uint64x2_t __ret_521; \
+ uint64x2_t __s0_521 = __p0_521; \
+ uint32x4_t __s1_521 = __p1_521; \
+ uint32x4_t __s2_521 = __p2_521; \
+ uint64x2_t __rev0_521; __rev0_521 = __builtin_shufflevector(__s0_521, __s0_521, 1, 0); \
+ uint32x4_t __rev1_521; __rev1_521 = __builtin_shufflevector(__s1_521, __s1_521, 3, 2, 1, 0); \
+ uint32x4_t __rev2_521; __rev2_521 = __builtin_shufflevector(__s2_521, __s2_521, 3, 2, 1, 0); \
+ __ret_521 = __rev0_521 - __noswap_vmull_u32(__noswap_vget_high_u32(__rev1_521), __noswap_splat_laneq_u32(__rev2_521, __p3_521)); \
+ __ret_521 = __builtin_shufflevector(__ret_521, __ret_521, 1, 0); \
+ __ret_521; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vpmaxq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
- return __ret;
-}
+#define vmlsl_high_laneq_u16(__p0_522, __p1_522, __p2_522, __p3_522) __extension__ ({ \
+ uint32x4_t __ret_522; \
+ uint32x4_t __s0_522 = __p0_522; \
+ uint16x8_t __s1_522 = __p1_522; \
+ uint16x8_t __s2_522 = __p2_522; \
+ __ret_522 = __s0_522 - vmull_u16(vget_high_u16(__s1_522), splat_laneq_u16(__s2_522, __p3_522)); \
+ __ret_522; \
+})
#else
-__ai int16x8_t vpmaxq_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vmlsl_high_laneq_u16(__p0_523, __p1_523, __p2_523, __p3_523) __extension__ ({ \
+ uint32x4_t __ret_523; \
+ uint32x4_t __s0_523 = __p0_523; \
+ uint16x8_t __s1_523 = __p1_523; \
+ uint16x8_t __s2_523 = __p2_523; \
+ uint32x4_t __rev0_523; __rev0_523 = __builtin_shufflevector(__s0_523, __s0_523, 3, 2, 1, 0); \
+ uint16x8_t __rev1_523; __rev1_523 = __builtin_shufflevector(__s1_523, __s1_523, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev2_523; __rev2_523 = __builtin_shufflevector(__s2_523, __s2_523, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_523 = __rev0_523 - __noswap_vmull_u16(__noswap_vget_high_u16(__rev1_523), __noswap_splat_laneq_u16(__rev2_523, __p3_523)); \
+ __ret_523 = __builtin_shufflevector(__ret_523, __ret_523, 3, 2, 1, 0); \
+ __ret_523; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64_t vpmaxqd_f64(float64x2_t __p0) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vpmaxqd_f64(__p0);
- return __ret;
-}
+#define vmlsl_high_laneq_s32(__p0_524, __p1_524, __p2_524, __p3_524) __extension__ ({ \
+ int64x2_t __ret_524; \
+ int64x2_t __s0_524 = __p0_524; \
+ int32x4_t __s1_524 = __p1_524; \
+ int32x4_t __s2_524 = __p2_524; \
+ __ret_524 = __s0_524 - vmull_s32(vget_high_s32(__s1_524), splat_laneq_s32(__s2_524, __p3_524)); \
+ __ret_524; \
+})
#else
-__ai float64_t vpmaxqd_f64(float64x2_t __p0) {
- float64_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64_t) __builtin_neon_vpmaxqd_f64(__rev0);
- return __ret;
-}
+#define vmlsl_high_laneq_s32(__p0_525, __p1_525, __p2_525, __p3_525) __extension__ ({ \
+ int64x2_t __ret_525; \
+ int64x2_t __s0_525 = __p0_525; \
+ int32x4_t __s1_525 = __p1_525; \
+ int32x4_t __s2_525 = __p2_525; \
+ int64x2_t __rev0_525; __rev0_525 = __builtin_shufflevector(__s0_525, __s0_525, 1, 0); \
+ int32x4_t __rev1_525; __rev1_525 = __builtin_shufflevector(__s1_525, __s1_525, 3, 2, 1, 0); \
+ int32x4_t __rev2_525; __rev2_525 = __builtin_shufflevector(__s2_525, __s2_525, 3, 2, 1, 0); \
+ __ret_525 = __rev0_525 - __noswap_vmull_s32(__noswap_vget_high_s32(__rev1_525), __noswap_splat_laneq_s32(__rev2_525, __p3_525)); \
+ __ret_525 = __builtin_shufflevector(__ret_525, __ret_525, 1, 0); \
+ __ret_525; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32_t vpmaxs_f32(float32x2_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vpmaxs_f32(__p0);
- return __ret;
-}
-#else
-__ai float32_t vpmaxs_f32(float32x2_t __p0) {
- float32_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float32_t) __builtin_neon_vpmaxs_f32(__rev0);
- return __ret;
-}
+#define vmlsl_high_laneq_s16(__p0_526, __p1_526, __p2_526, __p3_526) __extension__ ({ \
+ int32x4_t __ret_526; \
+ int32x4_t __s0_526 = __p0_526; \
+ int16x8_t __s1_526 = __p1_526; \
+ int16x8_t __s2_526 = __p2_526; \
+ __ret_526 = __s0_526 - vmull_s16(vget_high_s16(__s1_526), splat_laneq_s16(__s2_526, __p3_526)); \
+ __ret_526; \
+})
+#else
+#define vmlsl_high_laneq_s16(__p0_527, __p1_527, __p2_527, __p3_527) __extension__ ({ \
+ int32x4_t __ret_527; \
+ int32x4_t __s0_527 = __p0_527; \
+ int16x8_t __s1_527 = __p1_527; \
+ int16x8_t __s2_527 = __p2_527; \
+ int32x4_t __rev0_527; __rev0_527 = __builtin_shufflevector(__s0_527, __s0_527, 3, 2, 1, 0); \
+ int16x8_t __rev1_527; __rev1_527 = __builtin_shufflevector(__s1_527, __s1_527, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev2_527; __rev2_527 = __builtin_shufflevector(__s2_527, __s2_527, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_527 = __rev0_527 - __noswap_vmull_s16(__noswap_vget_high_s16(__rev1_527), __noswap_splat_laneq_s16(__rev2_527, __p3_527)); \
+ __ret_527 = __builtin_shufflevector(__ret_527, __ret_527, 3, 2, 1, 0); \
+ __ret_527; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vpmaxnmq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vpmaxnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
- return __ret;
-}
+#define vmlsl_laneq_u32(__p0_528, __p1_528, __p2_528, __p3_528) __extension__ ({ \
+ uint64x2_t __ret_528; \
+ uint64x2_t __s0_528 = __p0_528; \
+ uint32x2_t __s1_528 = __p1_528; \
+ uint32x4_t __s2_528 = __p2_528; \
+ __ret_528 = __s0_528 - vmull_u32(__s1_528, splat_laneq_u32(__s2_528, __p3_528)); \
+ __ret_528; \
+})
+#else
+#define vmlsl_laneq_u32(__p0_529, __p1_529, __p2_529, __p3_529) __extension__ ({ \
+ uint64x2_t __ret_529; \
+ uint64x2_t __s0_529 = __p0_529; \
+ uint32x2_t __s1_529 = __p1_529; \
+ uint32x4_t __s2_529 = __p2_529; \
+ uint64x2_t __rev0_529; __rev0_529 = __builtin_shufflevector(__s0_529, __s0_529, 1, 0); \
+ uint32x2_t __rev1_529; __rev1_529 = __builtin_shufflevector(__s1_529, __s1_529, 1, 0); \
+ uint32x4_t __rev2_529; __rev2_529 = __builtin_shufflevector(__s2_529, __s2_529, 3, 2, 1, 0); \
+ __ret_529 = __rev0_529 - __noswap_vmull_u32(__rev1_529, __noswap_splat_laneq_u32(__rev2_529, __p3_529)); \
+ __ret_529 = __builtin_shufflevector(__ret_529, __ret_529, 1, 0); \
+ __ret_529; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_laneq_u16(__p0_530, __p1_530, __p2_530, __p3_530) __extension__ ({ \
+ uint32x4_t __ret_530; \
+ uint32x4_t __s0_530 = __p0_530; \
+ uint16x4_t __s1_530 = __p1_530; \
+ uint16x8_t __s2_530 = __p2_530; \
+ __ret_530 = __s0_530 - vmull_u16(__s1_530, splat_laneq_u16(__s2_530, __p3_530)); \
+ __ret_530; \
+})
+#else
+#define vmlsl_laneq_u16(__p0_531, __p1_531, __p2_531, __p3_531) __extension__ ({ \
+ uint32x4_t __ret_531; \
+ uint32x4_t __s0_531 = __p0_531; \
+ uint16x4_t __s1_531 = __p1_531; \
+ uint16x8_t __s2_531 = __p2_531; \
+ uint32x4_t __rev0_531; __rev0_531 = __builtin_shufflevector(__s0_531, __s0_531, 3, 2, 1, 0); \
+ uint16x4_t __rev1_531; __rev1_531 = __builtin_shufflevector(__s1_531, __s1_531, 3, 2, 1, 0); \
+ uint16x8_t __rev2_531; __rev2_531 = __builtin_shufflevector(__s2_531, __s2_531, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_531 = __rev0_531 - __noswap_vmull_u16(__rev1_531, __noswap_splat_laneq_u16(__rev2_531, __p3_531)); \
+ __ret_531 = __builtin_shufflevector(__ret_531, __ret_531, 3, 2, 1, 0); \
+ __ret_531; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_laneq_s32(__p0_532, __p1_532, __p2_532, __p3_532) __extension__ ({ \
+ int64x2_t __ret_532; \
+ int64x2_t __s0_532 = __p0_532; \
+ int32x2_t __s1_532 = __p1_532; \
+ int32x4_t __s2_532 = __p2_532; \
+ __ret_532 = __s0_532 - vmull_s32(__s1_532, splat_laneq_s32(__s2_532, __p3_532)); \
+ __ret_532; \
+})
+#else
+#define vmlsl_laneq_s32(__p0_533, __p1_533, __p2_533, __p3_533) __extension__ ({ \
+ int64x2_t __ret_533; \
+ int64x2_t __s0_533 = __p0_533; \
+ int32x2_t __s1_533 = __p1_533; \
+ int32x4_t __s2_533 = __p2_533; \
+ int64x2_t __rev0_533; __rev0_533 = __builtin_shufflevector(__s0_533, __s0_533, 1, 0); \
+ int32x2_t __rev1_533; __rev1_533 = __builtin_shufflevector(__s1_533, __s1_533, 1, 0); \
+ int32x4_t __rev2_533; __rev2_533 = __builtin_shufflevector(__s2_533, __s2_533, 3, 2, 1, 0); \
+ __ret_533 = __rev0_533 - __noswap_vmull_s32(__rev1_533, __noswap_splat_laneq_s32(__rev2_533, __p3_533)); \
+ __ret_533 = __builtin_shufflevector(__ret_533, __ret_533, 1, 0); \
+ __ret_533; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_laneq_s16(__p0_534, __p1_534, __p2_534, __p3_534) __extension__ ({ \
+ int32x4_t __ret_534; \
+ int32x4_t __s0_534 = __p0_534; \
+ int16x4_t __s1_534 = __p1_534; \
+ int16x8_t __s2_534 = __p2_534; \
+ __ret_534 = __s0_534 - vmull_s16(__s1_534, splat_laneq_s16(__s2_534, __p3_534)); \
+ __ret_534; \
+})
#else
-__ai float64x2_t vpmaxnmq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vpmaxnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vmlsl_laneq_s16(__p0_535, __p1_535, __p2_535, __p3_535) __extension__ ({ \
+ int32x4_t __ret_535; \
+ int32x4_t __s0_535 = __p0_535; \
+ int16x4_t __s1_535 = __p1_535; \
+ int16x8_t __s2_535 = __p2_535; \
+ int32x4_t __rev0_535; __rev0_535 = __builtin_shufflevector(__s0_535, __s0_535, 3, 2, 1, 0); \
+ int16x4_t __rev1_535; __rev1_535 = __builtin_shufflevector(__s1_535, __s1_535, 3, 2, 1, 0); \
+ int16x8_t __rev2_535; __rev2_535 = __builtin_shufflevector(__s2_535, __s2_535, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_535 = __rev0_535 - __noswap_vmull_s16(__rev1_535, __noswap_splat_laneq_s16(__rev2_535, __p3_535)); \
+ __ret_535 = __builtin_shufflevector(__ret_535, __ret_535, 3, 2, 1, 0); \
+ __ret_535; \
+})
#endif
+__ai __attribute__((target("neon"))) poly64x1_t vmov_n_p64(poly64_t __p0) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t) {__p0};
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vpmaxnmq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vpmaxnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+__ai __attribute__((target("neon"))) poly64x2_t vmovq_n_p64(poly64_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t) {__p0, __p0};
return __ret;
}
#else
-__ai float32x4_t vpmaxnmq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vpmaxnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly64x2_t vmovq_n_p64(poly64_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t) {__p0, __p0};
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vpmaxnm_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vpmaxnm_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+__ai __attribute__((target("neon"))) float64x2_t vmovq_n_f64(float64_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) {__p0, __p0};
return __ret;
}
#else
-__ai float32x2_t vpmaxnm_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vpmaxnm_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+__ai __attribute__((target("neon"))) float64x2_t vmovq_n_f64(float64_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) {__p0, __p0};
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai float64_t vpmaxnmqd_f64(float64x2_t __p0) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vpmaxnmqd_f64(__p0);
+__ai __attribute__((target("neon"))) float64x1_t vmov_n_f64(float64_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) {__p0};
return __ret;
}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmovl_high_u8(uint8x16_t __p0_536) {
+ uint16x8_t __ret_536;
+ uint8x8_t __a1_536 = vget_high_u8(__p0_536);
+ __ret_536 = (uint16x8_t)(vshll_n_u8(__a1_536, 0));
+ return __ret_536;
+}
#else
-__ai float64_t vpmaxnmqd_f64(float64x2_t __p0) {
- float64_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64_t) __builtin_neon_vpmaxnmqd_f64(__rev0);
- return __ret;
+__ai __attribute__((target("neon"))) uint16x8_t vmovl_high_u8(uint8x16_t __p0_537) {
+ uint16x8_t __ret_537;
+ uint8x16_t __rev0_537; __rev0_537 = __builtin_shufflevector(__p0_537, __p0_537, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __a1_537 = __noswap_vget_high_u8(__rev0_537);
+ __ret_537 = (uint16x8_t)(__noswap_vshll_n_u8(__a1_537, 0));
+ __ret_537 = __builtin_shufflevector(__ret_537, __ret_537, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret_537;
+}
+__ai __attribute__((target("neon"))) uint16x8_t __noswap_vmovl_high_u8(uint8x16_t __p0_538) {
+ uint16x8_t __ret_538;
+ uint8x8_t __a1_538 = __noswap_vget_high_u8(__p0_538);
+ __ret_538 = (uint16x8_t)(__noswap_vshll_n_u8(__a1_538, 0));
+ return __ret_538;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32_t vpmaxnms_f32(float32x2_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vpmaxnms_f32(__p0);
- return __ret;
+__ai __attribute__((target("neon"))) uint64x2_t vmovl_high_u32(uint32x4_t __p0_539) {
+ uint64x2_t __ret_539;
+ uint32x2_t __a1_539 = vget_high_u32(__p0_539);
+ __ret_539 = (uint64x2_t)(vshll_n_u32(__a1_539, 0));
+ return __ret_539;
}
#else
-__ai float32_t vpmaxnms_f32(float32x2_t __p0) {
- float32_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float32_t) __builtin_neon_vpmaxnms_f32(__rev0);
- return __ret;
+__ai __attribute__((target("neon"))) uint64x2_t vmovl_high_u32(uint32x4_t __p0_540) {
+ uint64x2_t __ret_540;
+ uint32x4_t __rev0_540; __rev0_540 = __builtin_shufflevector(__p0_540, __p0_540, 3, 2, 1, 0);
+ uint32x2_t __a1_540 = __noswap_vget_high_u32(__rev0_540);
+ __ret_540 = (uint64x2_t)(__noswap_vshll_n_u32(__a1_540, 0));
+ __ret_540 = __builtin_shufflevector(__ret_540, __ret_540, 1, 0);
+ return __ret_540;
+}
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vmovl_high_u32(uint32x4_t __p0_541) {
+ uint64x2_t __ret_541;
+ uint32x2_t __a1_541 = __noswap_vget_high_u32(__p0_541);
+ __ret_541 = (uint64x2_t)(__noswap_vshll_n_u32(__a1_541, 0));
+ return __ret_541;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vpminq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
- return __ret;
+__ai __attribute__((target("neon"))) uint32x4_t vmovl_high_u16(uint16x8_t __p0_542) {
+ uint32x4_t __ret_542;
+ uint16x4_t __a1_542 = vget_high_u16(__p0_542);
+ __ret_542 = (uint32x4_t)(vshll_n_u16(__a1_542, 0));
+ return __ret_542;
}
#else
-__ai uint8x16_t vpminq_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
+__ai __attribute__((target("neon"))) uint32x4_t vmovl_high_u16(uint16x8_t __p0_543) {
+ uint32x4_t __ret_543;
+ uint16x8_t __rev0_543; __rev0_543 = __builtin_shufflevector(__p0_543, __p0_543, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x4_t __a1_543 = __noswap_vget_high_u16(__rev0_543);
+ __ret_543 = (uint32x4_t)(__noswap_vshll_n_u16(__a1_543, 0));
+ __ret_543 = __builtin_shufflevector(__ret_543, __ret_543, 3, 2, 1, 0);
+ return __ret_543;
+}
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vmovl_high_u16(uint16x8_t __p0_544) {
+ uint32x4_t __ret_544;
+ uint16x4_t __a1_544 = __noswap_vget_high_u16(__p0_544);
+ __ret_544 = (uint32x4_t)(__noswap_vshll_n_u16(__a1_544, 0));
+ return __ret_544;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vpminq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
- return __ret;
+__ai __attribute__((target("neon"))) int16x8_t vmovl_high_s8(int8x16_t __p0_545) {
+ int16x8_t __ret_545;
+ int8x8_t __a1_545 = vget_high_s8(__p0_545);
+ __ret_545 = (int16x8_t)(vshll_n_s8(__a1_545, 0));
+ return __ret_545;
}
#else
-__ai uint32x4_t vpminq_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
+__ai __attribute__((target("neon"))) int16x8_t vmovl_high_s8(int8x16_t __p0_546) {
+ int16x8_t __ret_546;
+ int8x16_t __rev0_546; __rev0_546 = __builtin_shufflevector(__p0_546, __p0_546, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __a1_546 = __noswap_vget_high_s8(__rev0_546);
+ __ret_546 = (int16x8_t)(__noswap_vshll_n_s8(__a1_546, 0));
+ __ret_546 = __builtin_shufflevector(__ret_546, __ret_546, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret_546;
+}
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vmovl_high_s8(int8x16_t __p0_547) {
+ int16x8_t __ret_547;
+ int8x8_t __a1_547 = __noswap_vget_high_s8(__p0_547);
+ __ret_547 = (int16x8_t)(__noswap_vshll_n_s8(__a1_547, 0));
+ return __ret_547;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vpminq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
- return __ret;
+__ai __attribute__((target("neon"))) int64x2_t vmovl_high_s32(int32x4_t __p0_548) {
+ int64x2_t __ret_548;
+ int32x2_t __a1_548 = vget_high_s32(__p0_548);
+ __ret_548 = (int64x2_t)(vshll_n_s32(__a1_548, 0));
+ return __ret_548;
}
#else
-__ai uint16x8_t vpminq_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
+__ai __attribute__((target("neon"))) int64x2_t vmovl_high_s32(int32x4_t __p0_549) {
+ int64x2_t __ret_549;
+ int32x4_t __rev0_549; __rev0_549 = __builtin_shufflevector(__p0_549, __p0_549, 3, 2, 1, 0);
+ int32x2_t __a1_549 = __noswap_vget_high_s32(__rev0_549);
+ __ret_549 = (int64x2_t)(__noswap_vshll_n_s32(__a1_549, 0));
+ __ret_549 = __builtin_shufflevector(__ret_549, __ret_549, 1, 0);
+ return __ret_549;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vmovl_high_s32(int32x4_t __p0_550) {
+ int64x2_t __ret_550;
+ int32x2_t __a1_550 = __noswap_vget_high_s32(__p0_550);
+ __ret_550 = (int64x2_t)(__noswap_vshll_n_s32(__a1_550, 0));
+ return __ret_550;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vpminq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
- return __ret;
+__ai __attribute__((target("neon"))) int32x4_t vmovl_high_s16(int16x8_t __p0_551) {
+ int32x4_t __ret_551;
+ int16x4_t __a1_551 = vget_high_s16(__p0_551);
+ __ret_551 = (int32x4_t)(vshll_n_s16(__a1_551, 0));
+ return __ret_551;
}
#else
-__ai int8x16_t vpminq_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
+__ai __attribute__((target("neon"))) int32x4_t vmovl_high_s16(int16x8_t __p0_552) {
+ int32x4_t __ret_552;
+ int16x8_t __rev0_552; __rev0_552 = __builtin_shufflevector(__p0_552, __p0_552, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x4_t __a1_552 = __noswap_vget_high_s16(__rev0_552);
+ __ret_552 = (int32x4_t)(__noswap_vshll_n_s16(__a1_552, 0));
+ __ret_552 = __builtin_shufflevector(__ret_552, __ret_552, 3, 2, 1, 0);
+ return __ret_552;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vmovl_high_s16(int16x8_t __p0_553) {
+ int32x4_t __ret_553;
+ int16x4_t __a1_553 = __noswap_vget_high_s16(__p0_553);
+ __ret_553 = (int32x4_t)(__noswap_vshll_n_s16(__a1_553, 0));
+ return __ret_553;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vpminq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+__ai __attribute__((target("neon"))) uint16x8_t vmovn_high_u32(uint16x4_t __p0, uint32x4_t __p1) {
+ uint16x8_t __ret;
+ __ret = vcombine_u16(__p0, vmovn_u32(__p1));
return __ret;
}
#else
-__ai float64x2_t vpminq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint16x8_t vmovn_high_u32(uint16x4_t __p0, uint32x4_t __p1) {
+ uint16x8_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_u16(__rev0, __noswap_vmovn_u32(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vpminq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+__ai __attribute__((target("neon"))) uint32x4_t vmovn_high_u64(uint32x2_t __p0, uint64x2_t __p1) {
+ uint32x4_t __ret;
+ __ret = vcombine_u32(__p0, vmovn_u64(__p1));
return __ret;
}
#else
-__ai float32x4_t vpminq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+__ai __attribute__((target("neon"))) uint32x4_t vmovn_high_u64(uint32x2_t __p0, uint64x2_t __p1) {
+ uint32x4_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __noswap_vcombine_u32(__rev0, __noswap_vmovn_u64(__rev1));
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vpminq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+__ai __attribute__((target("neon"))) uint8x16_t vmovn_high_u16(uint8x8_t __p0, uint16x8_t __p1) {
+ uint8x16_t __ret;
+ __ret = vcombine_u8(__p0, vmovn_u16(__p1));
return __ret;
}
#else
-__ai int32x4_t vpminq_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vmovn_high_u16(uint8x8_t __p0, uint16x8_t __p1) {
+ uint8x16_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_u8(__rev0, __noswap_vmovn_u16(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vpminq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vmovn_high_s32(int16x4_t __p0, int32x4_t __p1) {
int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ __ret = vcombine_s16(__p0, vmovn_s32(__p1));
return __ret;
}
#else
-__ai int16x8_t vpminq_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vmovn_high_s32(int16x4_t __p0, int32x4_t __p1) {
int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_s16(__rev0, __noswap_vmovn_s32(__rev1));
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64_t vpminqd_f64(float64x2_t __p0) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vpminqd_f64(__p0);
+__ai __attribute__((target("neon"))) int32x4_t vmovn_high_s64(int32x2_t __p0, int64x2_t __p1) {
+ int32x4_t __ret;
+ __ret = vcombine_s32(__p0, vmovn_s64(__p1));
return __ret;
}
#else
-__ai float64_t vpminqd_f64(float64x2_t __p0) {
- float64_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64_t) __builtin_neon_vpminqd_f64(__rev0);
+__ai __attribute__((target("neon"))) int32x4_t vmovn_high_s64(int32x2_t __p0, int64x2_t __p1) {
+ int32x4_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __noswap_vcombine_s32(__rev0, __noswap_vmovn_s64(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32_t vpmins_f32(float32x2_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vpmins_f32(__p0);
+__ai __attribute__((target("neon"))) int8x16_t vmovn_high_s16(int8x8_t __p0, int16x8_t __p1) {
+ int8x16_t __ret;
+ __ret = vcombine_s8(__p0, vmovn_s16(__p1));
return __ret;
}
#else
-__ai float32_t vpmins_f32(float32x2_t __p0) {
- float32_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float32_t) __builtin_neon_vpmins_f32(__rev0);
+__ai __attribute__((target("neon"))) int8x16_t vmovn_high_s16(int8x8_t __p0, int16x8_t __p1) {
+ int8x16_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_s8(__rev0, __noswap_vmovn_s16(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vpminnmq_f64(float64x2_t __p0, float64x2_t __p1) {
+__ai __attribute__((target("neon"))) float64x2_t vmulq_f64(float64x2_t __p0, float64x2_t __p1) {
float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vpminnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+ __ret = __p0 * __p1;
return __ret;
}
#else
-__ai float64x2_t vpminnmq_f64(float64x2_t __p0, float64x2_t __p1) {
+__ai __attribute__((target("neon"))) float64x2_t vmulq_f64(float64x2_t __p0, float64x2_t __p1) {
float64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vpminnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+ __ret = __rev0 * __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vpminnmq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vpminnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+__ai __attribute__((target("neon"))) float64x1_t vmul_f64(float64x1_t __p0, float64x1_t __p1) {
+ float64x1_t __ret;
+ __ret = __p0 * __p1;
return __ret;
}
+#define vmuld_lane_f64(__p0_554, __p1_554, __p2_554) __extension__ ({ \
+ float64_t __ret_554; \
+ float64_t __s0_554 = __p0_554; \
+ float64x1_t __s1_554 = __p1_554; \
+ __ret_554 = __s0_554 * vget_lane_f64(__s1_554, __p2_554); \
+ __ret_554; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vmuls_lane_f32(__p0_555, __p1_555, __p2_555) __extension__ ({ \
+ float32_t __ret_555; \
+ float32_t __s0_555 = __p0_555; \
+ float32x2_t __s1_555 = __p1_555; \
+ __ret_555 = __s0_555 * vget_lane_f32(__s1_555, __p2_555); \
+ __ret_555; \
+})
#else
-__ai float32x4_t vpminnmq_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vpminnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vmuls_lane_f32(__p0_556, __p1_556, __p2_556) __extension__ ({ \
+ float32_t __ret_556; \
+ float32_t __s0_556 = __p0_556; \
+ float32x2_t __s1_556 = __p1_556; \
+ float32x2_t __rev1_556; __rev1_556 = __builtin_shufflevector(__s1_556, __s1_556, 1, 0); \
+ __ret_556 = __s0_556 * __noswap_vget_lane_f32(__rev1_556, __p2_556); \
+ __ret_556; \
+})
#endif
+#define vmul_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x1_t __ret; \
+ float64x1_t __s0 = __p0; \
+ float64x1_t __s1 = __p1; \
+ __ret = (float64x1_t) __builtin_neon_vmul_lane_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 10); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vpminnm_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vpminnm_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
- return __ret;
-}
+#define vmulq_lane_f64(__p0_557, __p1_557, __p2_557) __extension__ ({ \
+ float64x2_t __ret_557; \
+ float64x2_t __s0_557 = __p0_557; \
+ float64x1_t __s1_557 = __p1_557; \
+ __ret_557 = __s0_557 * splatq_lane_f64(__s1_557, __p2_557); \
+ __ret_557; \
+})
#else
-__ai float32x2_t vpminnm_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vpminnm_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vmulq_lane_f64(__p0_558, __p1_558, __p2_558) __extension__ ({ \
+ float64x2_t __ret_558; \
+ float64x2_t __s0_558 = __p0_558; \
+ float64x1_t __s1_558 = __p1_558; \
+ float64x2_t __rev0_558; __rev0_558 = __builtin_shufflevector(__s0_558, __s0_558, 1, 0); \
+ __ret_558 = __rev0_558 * __noswap_splatq_lane_f64(__s1_558, __p2_558); \
+ __ret_558 = __builtin_shufflevector(__ret_558, __ret_558, 1, 0); \
+ __ret_558; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64_t vpminnmqd_f64(float64x2_t __p0) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vpminnmqd_f64(__p0);
- return __ret;
-}
+#define vmuld_laneq_f64(__p0_559, __p1_559, __p2_559) __extension__ ({ \
+ float64_t __ret_559; \
+ float64_t __s0_559 = __p0_559; \
+ float64x2_t __s1_559 = __p1_559; \
+ __ret_559 = __s0_559 * vgetq_lane_f64(__s1_559, __p2_559); \
+ __ret_559; \
+})
#else
-__ai float64_t vpminnmqd_f64(float64x2_t __p0) {
- float64_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64_t) __builtin_neon_vpminnmqd_f64(__rev0);
- return __ret;
-}
+#define vmuld_laneq_f64(__p0_560, __p1_560, __p2_560) __extension__ ({ \
+ float64_t __ret_560; \
+ float64_t __s0_560 = __p0_560; \
+ float64x2_t __s1_560 = __p1_560; \
+ float64x2_t __rev1_560; __rev1_560 = __builtin_shufflevector(__s1_560, __s1_560, 1, 0); \
+ __ret_560 = __s0_560 * __noswap_vgetq_lane_f64(__rev1_560, __p2_560); \
+ __ret_560; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32_t vpminnms_f32(float32x2_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vpminnms_f32(__p0);
- return __ret;
-}
+#define vmuls_laneq_f32(__p0_561, __p1_561, __p2_561) __extension__ ({ \
+ float32_t __ret_561; \
+ float32_t __s0_561 = __p0_561; \
+ float32x4_t __s1_561 = __p1_561; \
+ __ret_561 = __s0_561 * vgetq_lane_f32(__s1_561, __p2_561); \
+ __ret_561; \
+})
#else
-__ai float32_t vpminnms_f32(float32x2_t __p0) {
- float32_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float32_t) __builtin_neon_vpminnms_f32(__rev0);
- return __ret;
-}
+#define vmuls_laneq_f32(__p0_562, __p1_562, __p2_562) __extension__ ({ \
+ float32_t __ret_562; \
+ float32_t __s0_562 = __p0_562; \
+ float32x4_t __s1_562 = __p1_562; \
+ float32x4_t __rev1_562; __rev1_562 = __builtin_shufflevector(__s1_562, __s1_562, 3, 2, 1, 0); \
+ __ret_562 = __s0_562 * __noswap_vgetq_lane_f32(__rev1_562, __p2_562); \
+ __ret_562; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vqabsq_s64(int64x2_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vqabsq_v((int8x16_t)__p0, 35);
- return __ret;
-}
+#define vmul_laneq_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x1_t __ret; \
+ float64x1_t __s0 = __p0; \
+ float64x2_t __s1 = __p1; \
+ __ret = (float64x1_t) __builtin_neon_vmul_laneq_v((int8x8_t)__s0, (int8x16_t)__s1, __p2, 10); \
+ __ret; \
+})
#else
-__ai int64x2_t vqabsq_s64(int64x2_t __p0) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vqabsq_v((int8x16_t)__rev0, 35);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vmul_laneq_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x1_t __ret; \
+ float64x1_t __s0 = __p0; \
+ float64x2_t __s1 = __p1; \
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (float64x1_t) __builtin_neon_vmul_laneq_v((int8x8_t)__s0, (int8x16_t)__rev1, __p2, 10); \
+ __ret; \
+})
#endif
-__ai int64x1_t vqabs_s64(int64x1_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t) __builtin_neon_vqabs_v((int8x8_t)__p0, 3);
- return __ret;
-}
-__ai int8_t vqabsb_s8(int8_t __p0) {
- int8_t __ret;
- __ret = (int8_t) __builtin_neon_vqabsb_s8(__p0);
- return __ret;
-}
-__ai int32_t vqabss_s32(int32_t __p0) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vqabss_s32(__p0);
- return __ret;
-}
-__ai int64_t vqabsd_s64(int64_t __p0) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vqabsd_s64(__p0);
- return __ret;
-}
-__ai int16_t vqabsh_s16(int16_t __p0) {
- int16_t __ret;
- __ret = (int16_t) __builtin_neon_vqabsh_s16(__p0);
- return __ret;
-}
-__ai uint8_t vqaddb_u8(uint8_t __p0, uint8_t __p1) {
- uint8_t __ret;
- __ret = (uint8_t) __builtin_neon_vqaddb_u8(__p0, __p1);
- return __ret;
-}
-__ai uint32_t vqadds_u32(uint32_t __p0, uint32_t __p1) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vqadds_u32(__p0, __p1);
- return __ret;
-}
-__ai uint64_t vqaddd_u64(uint64_t __p0, uint64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vqaddd_u64(__p0, __p1);
- return __ret;
-}
-__ai uint16_t vqaddh_u16(uint16_t __p0, uint16_t __p1) {
- uint16_t __ret;
- __ret = (uint16_t) __builtin_neon_vqaddh_u16(__p0, __p1);
- return __ret;
-}
-__ai int8_t vqaddb_s8(int8_t __p0, int8_t __p1) {
- int8_t __ret;
- __ret = (int8_t) __builtin_neon_vqaddb_s8(__p0, __p1);
- return __ret;
-}
-__ai int32_t vqadds_s32(int32_t __p0, int32_t __p1) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vqadds_s32(__p0, __p1);
- return __ret;
-}
-__ai int64_t vqaddd_s64(int64_t __p0, int64_t __p1) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vqaddd_s64(__p0, __p1);
- return __ret;
-}
-__ai int16_t vqaddh_s16(int16_t __p0, int16_t __p1) {
- int16_t __ret;
- __ret = (int16_t) __builtin_neon_vqaddh_s16(__p0, __p1);
- return __ret;
-}
-__ai int64_t vqdmlals_s32(int64_t __p0, int32_t __p1, int32_t __p2) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vqdmlals_s32(__p0, __p1, __p2);
- return __ret;
-}
-__ai int32_t vqdmlalh_s16(int32_t __p0, int16_t __p1, int16_t __p2) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vqdmlalh_s16(__p0, __p1, __p2);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vqdmlal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int64x2_t __ret;
- __ret = vqdmlal_s32(__p0, vget_high_s32(__p1), vget_high_s32(__p2));
- return __ret;
-}
+#define vmulq_laneq_u32(__p0_563, __p1_563, __p2_563) __extension__ ({ \
+ uint32x4_t __ret_563; \
+ uint32x4_t __s0_563 = __p0_563; \
+ uint32x4_t __s1_563 = __p1_563; \
+ __ret_563 = __s0_563 * splatq_laneq_u32(__s1_563, __p2_563); \
+ __ret_563; \
+})
#else
-__ai int64x2_t vqdmlal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __noswap_vqdmlal_s32(__rev0, __noswap_vget_high_s32(__rev1), __noswap_vget_high_s32(__rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vmulq_laneq_u32(__p0_564, __p1_564, __p2_564) __extension__ ({ \
+ uint32x4_t __ret_564; \
+ uint32x4_t __s0_564 = __p0_564; \
+ uint32x4_t __s1_564 = __p1_564; \
+ uint32x4_t __rev0_564; __rev0_564 = __builtin_shufflevector(__s0_564, __s0_564, 3, 2, 1, 0); \
+ uint32x4_t __rev1_564; __rev1_564 = __builtin_shufflevector(__s1_564, __s1_564, 3, 2, 1, 0); \
+ __ret_564 = __rev0_564 * __noswap_splatq_laneq_u32(__rev1_564, __p2_564); \
+ __ret_564 = __builtin_shufflevector(__ret_564, __ret_564, 3, 2, 1, 0); \
+ __ret_564; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqdmlal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int32x4_t __ret;
- __ret = vqdmlal_s16(__p0, vget_high_s16(__p1), vget_high_s16(__p2));
- return __ret;
-}
+#define vmulq_laneq_u16(__p0_565, __p1_565, __p2_565) __extension__ ({ \
+ uint16x8_t __ret_565; \
+ uint16x8_t __s0_565 = __p0_565; \
+ uint16x8_t __s1_565 = __p1_565; \
+ __ret_565 = __s0_565 * splatq_laneq_u16(__s1_565, __p2_565); \
+ __ret_565; \
+})
#else
-__ai int32x4_t vqdmlal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vqdmlal_s16(__rev0, __noswap_vget_high_s16(__rev1), __noswap_vget_high_s16(__rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vmulq_laneq_u16(__p0_566, __p1_566, __p2_566) __extension__ ({ \
+ uint16x8_t __ret_566; \
+ uint16x8_t __s0_566 = __p0_566; \
+ uint16x8_t __s1_566 = __p1_566; \
+ uint16x8_t __rev0_566; __rev0_566 = __builtin_shufflevector(__s0_566, __s0_566, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev1_566; __rev1_566 = __builtin_shufflevector(__s1_566, __s1_566, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_566 = __rev0_566 * __noswap_splatq_laneq_u16(__rev1_566, __p2_566); \
+ __ret_566 = __builtin_shufflevector(__ret_566, __ret_566, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_566; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlal_high_lane_s32(__p0_607, __p1_607, __p2_607, __p3_607) __extension__ ({ \
- int64x2_t __ret_607; \
- int64x2_t __s0_607 = __p0_607; \
- int32x4_t __s1_607 = __p1_607; \
- int32x2_t __s2_607 = __p2_607; \
- __ret_607 = vqdmlal_s32(__s0_607, vget_high_s32(__s1_607), splat_lane_s32(__s2_607, __p3_607)); \
- __ret_607; \
+#define vmulq_laneq_f64(__p0_567, __p1_567, __p2_567) __extension__ ({ \
+ float64x2_t __ret_567; \
+ float64x2_t __s0_567 = __p0_567; \
+ float64x2_t __s1_567 = __p1_567; \
+ __ret_567 = __s0_567 * splatq_laneq_f64(__s1_567, __p2_567); \
+ __ret_567; \
})
#else
-#define vqdmlal_high_lane_s32(__p0_608, __p1_608, __p2_608, __p3_608) __extension__ ({ \
- int64x2_t __ret_608; \
- int64x2_t __s0_608 = __p0_608; \
- int32x4_t __s1_608 = __p1_608; \
- int32x2_t __s2_608 = __p2_608; \
- int64x2_t __rev0_608; __rev0_608 = __builtin_shufflevector(__s0_608, __s0_608, 1, 0); \
- int32x4_t __rev1_608; __rev1_608 = __builtin_shufflevector(__s1_608, __s1_608, 3, 2, 1, 0); \
- int32x2_t __rev2_608; __rev2_608 = __builtin_shufflevector(__s2_608, __s2_608, 1, 0); \
- __ret_608 = __noswap_vqdmlal_s32(__rev0_608, __noswap_vget_high_s32(__rev1_608), __noswap_splat_lane_s32(__rev2_608, __p3_608)); \
- __ret_608 = __builtin_shufflevector(__ret_608, __ret_608, 1, 0); \
- __ret_608; \
+#define vmulq_laneq_f64(__p0_568, __p1_568, __p2_568) __extension__ ({ \
+ float64x2_t __ret_568; \
+ float64x2_t __s0_568 = __p0_568; \
+ float64x2_t __s1_568 = __p1_568; \
+ float64x2_t __rev0_568; __rev0_568 = __builtin_shufflevector(__s0_568, __s0_568, 1, 0); \
+ float64x2_t __rev1_568; __rev1_568 = __builtin_shufflevector(__s1_568, __s1_568, 1, 0); \
+ __ret_568 = __rev0_568 * __noswap_splatq_laneq_f64(__rev1_568, __p2_568); \
+ __ret_568 = __builtin_shufflevector(__ret_568, __ret_568, 1, 0); \
+ __ret_568; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlal_high_lane_s16(__p0_609, __p1_609, __p2_609, __p3_609) __extension__ ({ \
- int32x4_t __ret_609; \
- int32x4_t __s0_609 = __p0_609; \
- int16x8_t __s1_609 = __p1_609; \
- int16x4_t __s2_609 = __p2_609; \
- __ret_609 = vqdmlal_s16(__s0_609, vget_high_s16(__s1_609), splat_lane_s16(__s2_609, __p3_609)); \
- __ret_609; \
+#define vmulq_laneq_f32(__p0_569, __p1_569, __p2_569) __extension__ ({ \
+ float32x4_t __ret_569; \
+ float32x4_t __s0_569 = __p0_569; \
+ float32x4_t __s1_569 = __p1_569; \
+ __ret_569 = __s0_569 * splatq_laneq_f32(__s1_569, __p2_569); \
+ __ret_569; \
})
#else
-#define vqdmlal_high_lane_s16(__p0_610, __p1_610, __p2_610, __p3_610) __extension__ ({ \
- int32x4_t __ret_610; \
- int32x4_t __s0_610 = __p0_610; \
- int16x8_t __s1_610 = __p1_610; \
- int16x4_t __s2_610 = __p2_610; \
- int32x4_t __rev0_610; __rev0_610 = __builtin_shufflevector(__s0_610, __s0_610, 3, 2, 1, 0); \
- int16x8_t __rev1_610; __rev1_610 = __builtin_shufflevector(__s1_610, __s1_610, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x4_t __rev2_610; __rev2_610 = __builtin_shufflevector(__s2_610, __s2_610, 3, 2, 1, 0); \
- __ret_610 = __noswap_vqdmlal_s16(__rev0_610, __noswap_vget_high_s16(__rev1_610), __noswap_splat_lane_s16(__rev2_610, __p3_610)); \
- __ret_610 = __builtin_shufflevector(__ret_610, __ret_610, 3, 2, 1, 0); \
- __ret_610; \
+#define vmulq_laneq_f32(__p0_570, __p1_570, __p2_570) __extension__ ({ \
+ float32x4_t __ret_570; \
+ float32x4_t __s0_570 = __p0_570; \
+ float32x4_t __s1_570 = __p1_570; \
+ float32x4_t __rev0_570; __rev0_570 = __builtin_shufflevector(__s0_570, __s0_570, 3, 2, 1, 0); \
+ float32x4_t __rev1_570; __rev1_570 = __builtin_shufflevector(__s1_570, __s1_570, 3, 2, 1, 0); \
+ __ret_570 = __rev0_570 * __noswap_splatq_laneq_f32(__rev1_570, __p2_570); \
+ __ret_570 = __builtin_shufflevector(__ret_570, __ret_570, 3, 2, 1, 0); \
+ __ret_570; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlal_high_laneq_s32(__p0_611, __p1_611, __p2_611, __p3_611) __extension__ ({ \
- int64x2_t __ret_611; \
- int64x2_t __s0_611 = __p0_611; \
- int32x4_t __s1_611 = __p1_611; \
- int32x4_t __s2_611 = __p2_611; \
- __ret_611 = vqdmlal_s32(__s0_611, vget_high_s32(__s1_611), splat_laneq_s32(__s2_611, __p3_611)); \
- __ret_611; \
+#define vmulq_laneq_s32(__p0_571, __p1_571, __p2_571) __extension__ ({ \
+ int32x4_t __ret_571; \
+ int32x4_t __s0_571 = __p0_571; \
+ int32x4_t __s1_571 = __p1_571; \
+ __ret_571 = __s0_571 * splatq_laneq_s32(__s1_571, __p2_571); \
+ __ret_571; \
})
#else
-#define vqdmlal_high_laneq_s32(__p0_612, __p1_612, __p2_612, __p3_612) __extension__ ({ \
- int64x2_t __ret_612; \
- int64x2_t __s0_612 = __p0_612; \
- int32x4_t __s1_612 = __p1_612; \
- int32x4_t __s2_612 = __p2_612; \
- int64x2_t __rev0_612; __rev0_612 = __builtin_shufflevector(__s0_612, __s0_612, 1, 0); \
- int32x4_t __rev1_612; __rev1_612 = __builtin_shufflevector(__s1_612, __s1_612, 3, 2, 1, 0); \
- int32x4_t __rev2_612; __rev2_612 = __builtin_shufflevector(__s2_612, __s2_612, 3, 2, 1, 0); \
- __ret_612 = __noswap_vqdmlal_s32(__rev0_612, __noswap_vget_high_s32(__rev1_612), __noswap_splat_laneq_s32(__rev2_612, __p3_612)); \
- __ret_612 = __builtin_shufflevector(__ret_612, __ret_612, 1, 0); \
- __ret_612; \
+#define vmulq_laneq_s32(__p0_572, __p1_572, __p2_572) __extension__ ({ \
+ int32x4_t __ret_572; \
+ int32x4_t __s0_572 = __p0_572; \
+ int32x4_t __s1_572 = __p1_572; \
+ int32x4_t __rev0_572; __rev0_572 = __builtin_shufflevector(__s0_572, __s0_572, 3, 2, 1, 0); \
+ int32x4_t __rev1_572; __rev1_572 = __builtin_shufflevector(__s1_572, __s1_572, 3, 2, 1, 0); \
+ __ret_572 = __rev0_572 * __noswap_splatq_laneq_s32(__rev1_572, __p2_572); \
+ __ret_572 = __builtin_shufflevector(__ret_572, __ret_572, 3, 2, 1, 0); \
+ __ret_572; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlal_high_laneq_s16(__p0_613, __p1_613, __p2_613, __p3_613) __extension__ ({ \
- int32x4_t __ret_613; \
- int32x4_t __s0_613 = __p0_613; \
- int16x8_t __s1_613 = __p1_613; \
- int16x8_t __s2_613 = __p2_613; \
- __ret_613 = vqdmlal_s16(__s0_613, vget_high_s16(__s1_613), splat_laneq_s16(__s2_613, __p3_613)); \
- __ret_613; \
+#define vmulq_laneq_s16(__p0_573, __p1_573, __p2_573) __extension__ ({ \
+ int16x8_t __ret_573; \
+ int16x8_t __s0_573 = __p0_573; \
+ int16x8_t __s1_573 = __p1_573; \
+ __ret_573 = __s0_573 * splatq_laneq_s16(__s1_573, __p2_573); \
+ __ret_573; \
})
#else
-#define vqdmlal_high_laneq_s16(__p0_614, __p1_614, __p2_614, __p3_614) __extension__ ({ \
- int32x4_t __ret_614; \
- int32x4_t __s0_614 = __p0_614; \
- int16x8_t __s1_614 = __p1_614; \
- int16x8_t __s2_614 = __p2_614; \
- int32x4_t __rev0_614; __rev0_614 = __builtin_shufflevector(__s0_614, __s0_614, 3, 2, 1, 0); \
- int16x8_t __rev1_614; __rev1_614 = __builtin_shufflevector(__s1_614, __s1_614, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev2_614; __rev2_614 = __builtin_shufflevector(__s2_614, __s2_614, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_614 = __noswap_vqdmlal_s16(__rev0_614, __noswap_vget_high_s16(__rev1_614), __noswap_splat_laneq_s16(__rev2_614, __p3_614)); \
- __ret_614 = __builtin_shufflevector(__ret_614, __ret_614, 3, 2, 1, 0); \
- __ret_614; \
+#define vmulq_laneq_s16(__p0_574, __p1_574, __p2_574) __extension__ ({ \
+ int16x8_t __ret_574; \
+ int16x8_t __s0_574 = __p0_574; \
+ int16x8_t __s1_574 = __p1_574; \
+ int16x8_t __rev0_574; __rev0_574 = __builtin_shufflevector(__s0_574, __s0_574, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1_574; __rev1_574 = __builtin_shufflevector(__s1_574, __s1_574, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_574 = __rev0_574 * __noswap_splatq_laneq_s16(__rev1_574, __p2_574); \
+ __ret_574 = __builtin_shufflevector(__ret_574, __ret_574, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_574; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vqdmlal_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
- int64x2_t __ret;
- __ret = vqdmlal_n_s32(__p0, vget_high_s32(__p1), __p2);
- return __ret;
-}
+#define vmul_laneq_u32(__p0_575, __p1_575, __p2_575) __extension__ ({ \
+ uint32x2_t __ret_575; \
+ uint32x2_t __s0_575 = __p0_575; \
+ uint32x4_t __s1_575 = __p1_575; \
+ __ret_575 = __s0_575 * splat_laneq_u32(__s1_575, __p2_575); \
+ __ret_575; \
+})
#else
-__ai int64x2_t vqdmlal_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vqdmlal_n_s32(__rev0, __noswap_vget_high_s32(__rev1), __p2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vmul_laneq_u32(__p0_576, __p1_576, __p2_576) __extension__ ({ \
+ uint32x2_t __ret_576; \
+ uint32x2_t __s0_576 = __p0_576; \
+ uint32x4_t __s1_576 = __p1_576; \
+ uint32x2_t __rev0_576; __rev0_576 = __builtin_shufflevector(__s0_576, __s0_576, 1, 0); \
+ uint32x4_t __rev1_576; __rev1_576 = __builtin_shufflevector(__s1_576, __s1_576, 3, 2, 1, 0); \
+ __ret_576 = __rev0_576 * __noswap_splat_laneq_u32(__rev1_576, __p2_576); \
+ __ret_576 = __builtin_shufflevector(__ret_576, __ret_576, 1, 0); \
+ __ret_576; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqdmlal_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
- int32x4_t __ret;
- __ret = vqdmlal_n_s16(__p0, vget_high_s16(__p1), __p2);
- return __ret;
-}
+#define vmul_laneq_u16(__p0_577, __p1_577, __p2_577) __extension__ ({ \
+ uint16x4_t __ret_577; \
+ uint16x4_t __s0_577 = __p0_577; \
+ uint16x8_t __s1_577 = __p1_577; \
+ __ret_577 = __s0_577 * splat_laneq_u16(__s1_577, __p2_577); \
+ __ret_577; \
+})
#else
-__ai int32x4_t vqdmlal_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vqdmlal_n_s16(__rev0, __noswap_vget_high_s16(__rev1), __p2);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vmul_laneq_u16(__p0_578, __p1_578, __p2_578) __extension__ ({ \
+ uint16x4_t __ret_578; \
+ uint16x4_t __s0_578 = __p0_578; \
+ uint16x8_t __s1_578 = __p1_578; \
+ uint16x4_t __rev0_578; __rev0_578 = __builtin_shufflevector(__s0_578, __s0_578, 3, 2, 1, 0); \
+ uint16x8_t __rev1_578; __rev1_578 = __builtin_shufflevector(__s1_578, __s1_578, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_578 = __rev0_578 * __noswap_splat_laneq_u16(__rev1_578, __p2_578); \
+ __ret_578 = __builtin_shufflevector(__ret_578, __ret_578, 3, 2, 1, 0); \
+ __ret_578; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlals_lane_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
- int64_t __ret; \
- int64_t __s0 = __p0; \
- int32_t __s1 = __p1; \
- int32x2_t __s2 = __p2; \
- __ret = (int64_t) __builtin_neon_vqdmlals_lane_s32(__s0, __s1, __s2, __p3); \
- __ret; \
+#define vmul_laneq_f32(__p0_579, __p1_579, __p2_579) __extension__ ({ \
+ float32x2_t __ret_579; \
+ float32x2_t __s0_579 = __p0_579; \
+ float32x4_t __s1_579 = __p1_579; \
+ __ret_579 = __s0_579 * splat_laneq_f32(__s1_579, __p2_579); \
+ __ret_579; \
})
#else
-#define vqdmlals_lane_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
- int64_t __ret; \
- int64_t __s0 = __p0; \
- int32_t __s1 = __p1; \
- int32x2_t __s2 = __p2; \
- int32x2_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
- __ret = (int64_t) __builtin_neon_vqdmlals_lane_s32(__s0, __s1, __rev2, __p3); \
- __ret; \
+#define vmul_laneq_f32(__p0_580, __p1_580, __p2_580) __extension__ ({ \
+ float32x2_t __ret_580; \
+ float32x2_t __s0_580 = __p0_580; \
+ float32x4_t __s1_580 = __p1_580; \
+ float32x2_t __rev0_580; __rev0_580 = __builtin_shufflevector(__s0_580, __s0_580, 1, 0); \
+ float32x4_t __rev1_580; __rev1_580 = __builtin_shufflevector(__s1_580, __s1_580, 3, 2, 1, 0); \
+ __ret_580 = __rev0_580 * __noswap_splat_laneq_f32(__rev1_580, __p2_580); \
+ __ret_580 = __builtin_shufflevector(__ret_580, __ret_580, 1, 0); \
+ __ret_580; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlalh_lane_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
- int32_t __ret; \
- int32_t __s0 = __p0; \
- int16_t __s1 = __p1; \
- int16x4_t __s2 = __p2; \
- __ret = (int32_t) __builtin_neon_vqdmlalh_lane_s16(__s0, __s1, __s2, __p3); \
- __ret; \
+#define vmul_laneq_s32(__p0_581, __p1_581, __p2_581) __extension__ ({ \
+ int32x2_t __ret_581; \
+ int32x2_t __s0_581 = __p0_581; \
+ int32x4_t __s1_581 = __p1_581; \
+ __ret_581 = __s0_581 * splat_laneq_s32(__s1_581, __p2_581); \
+ __ret_581; \
})
#else
-#define vqdmlalh_lane_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
- int32_t __ret; \
- int32_t __s0 = __p0; \
- int16_t __s1 = __p1; \
- int16x4_t __s2 = __p2; \
- int16x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
- __ret = (int32_t) __builtin_neon_vqdmlalh_lane_s16(__s0, __s1, __rev2, __p3); \
- __ret; \
+#define vmul_laneq_s32(__p0_582, __p1_582, __p2_582) __extension__ ({ \
+ int32x2_t __ret_582; \
+ int32x2_t __s0_582 = __p0_582; \
+ int32x4_t __s1_582 = __p1_582; \
+ int32x2_t __rev0_582; __rev0_582 = __builtin_shufflevector(__s0_582, __s0_582, 1, 0); \
+ int32x4_t __rev1_582; __rev1_582 = __builtin_shufflevector(__s1_582, __s1_582, 3, 2, 1, 0); \
+ __ret_582 = __rev0_582 * __noswap_splat_laneq_s32(__rev1_582, __p2_582); \
+ __ret_582 = __builtin_shufflevector(__ret_582, __ret_582, 1, 0); \
+ __ret_582; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlals_laneq_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
- int64_t __ret; \
- int64_t __s0 = __p0; \
- int32_t __s1 = __p1; \
- int32x4_t __s2 = __p2; \
- __ret = (int64_t) __builtin_neon_vqdmlals_laneq_s32(__s0, __s1, __s2, __p3); \
- __ret; \
+#define vmul_laneq_s16(__p0_583, __p1_583, __p2_583) __extension__ ({ \
+ int16x4_t __ret_583; \
+ int16x4_t __s0_583 = __p0_583; \
+ int16x8_t __s1_583 = __p1_583; \
+ __ret_583 = __s0_583 * splat_laneq_s16(__s1_583, __p2_583); \
+ __ret_583; \
})
#else
-#define vqdmlals_laneq_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
- int64_t __ret; \
- int64_t __s0 = __p0; \
- int32_t __s1 = __p1; \
- int32x4_t __s2 = __p2; \
- int32x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
- __ret = (int64_t) __builtin_neon_vqdmlals_laneq_s32(__s0, __s1, __rev2, __p3); \
- __ret; \
+#define vmul_laneq_s16(__p0_584, __p1_584, __p2_584) __extension__ ({ \
+ int16x4_t __ret_584; \
+ int16x4_t __s0_584 = __p0_584; \
+ int16x8_t __s1_584 = __p1_584; \
+ int16x4_t __rev0_584; __rev0_584 = __builtin_shufflevector(__s0_584, __s0_584, 3, 2, 1, 0); \
+ int16x8_t __rev1_584; __rev1_584 = __builtin_shufflevector(__s1_584, __s1_584, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_584 = __rev0_584 * __noswap_splat_laneq_s16(__rev1_584, __p2_584); \
+ __ret_584 = __builtin_shufflevector(__ret_584, __ret_584, 3, 2, 1, 0); \
+ __ret_584; \
})
#endif
+__ai __attribute__((target("neon"))) float64x1_t vmul_n_f64(float64x1_t __p0, float64_t __p1) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vmul_n_f64((float64x1_t)__p0, __p1);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vqdmlalh_laneq_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
- int32_t __ret; \
- int32_t __s0 = __p0; \
- int16_t __s1 = __p1; \
- int16x8_t __s2 = __p2; \
- __ret = (int32_t) __builtin_neon_vqdmlalh_laneq_s16(__s0, __s1, __s2, __p3); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vmulq_n_f64(float64x2_t __p0, float64_t __p1) {
+ float64x2_t __ret;
+ __ret = __p0 * (float64x2_t) {__p1, __p1};
+ return __ret;
+}
#else
-#define vqdmlalh_laneq_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
- int32_t __ret; \
- int32_t __s0 = __p0; \
- int16_t __s1 = __p1; \
- int16x8_t __s2 = __p2; \
- int16x8_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int32_t) __builtin_neon_vqdmlalh_laneq_s16(__s0, __s1, __rev2, __p3); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vmulq_n_f64(float64x2_t __p0, float64_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = __rev0 * (float64x2_t) {__p1, __p1};
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlal_laneq_s32(__p0_615, __p1_615, __p2_615, __p3_615) __extension__ ({ \
- int64x2_t __ret_615; \
- int64x2_t __s0_615 = __p0_615; \
- int32x2_t __s1_615 = __p1_615; \
- int32x4_t __s2_615 = __p2_615; \
- __ret_615 = vqdmlal_s32(__s0_615, __s1_615, splat_laneq_s32(__s2_615, __p3_615)); \
- __ret_615; \
-})
+__ai __attribute__((target("neon"))) poly16x8_t vmull_high_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly16x8_t __ret;
+ __ret = vmull_p8(vget_high_p8(__p0), vget_high_p8(__p1));
+ return __ret;
+}
#else
-#define vqdmlal_laneq_s32(__p0_616, __p1_616, __p2_616, __p3_616) __extension__ ({ \
- int64x2_t __ret_616; \
- int64x2_t __s0_616 = __p0_616; \
- int32x2_t __s1_616 = __p1_616; \
- int32x4_t __s2_616 = __p2_616; \
- int64x2_t __rev0_616; __rev0_616 = __builtin_shufflevector(__s0_616, __s0_616, 1, 0); \
- int32x2_t __rev1_616; __rev1_616 = __builtin_shufflevector(__s1_616, __s1_616, 1, 0); \
- int32x4_t __rev2_616; __rev2_616 = __builtin_shufflevector(__s2_616, __s2_616, 3, 2, 1, 0); \
- __ret_616 = __noswap_vqdmlal_s32(__rev0_616, __rev1_616, __noswap_splat_laneq_s32(__rev2_616, __p3_616)); \
- __ret_616 = __builtin_shufflevector(__ret_616, __ret_616, 1, 0); \
- __ret_616; \
-})
+__ai __attribute__((target("neon"))) poly16x8_t vmull_high_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly16x8_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vmull_p8(__noswap_vget_high_p8(__rev0), __noswap_vget_high_p8(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlal_laneq_s16(__p0_617, __p1_617, __p2_617, __p3_617) __extension__ ({ \
- int32x4_t __ret_617; \
- int32x4_t __s0_617 = __p0_617; \
- int16x4_t __s1_617 = __p1_617; \
- int16x8_t __s2_617 = __p2_617; \
- __ret_617 = vqdmlal_s16(__s0_617, __s1_617, splat_laneq_s16(__s2_617, __p3_617)); \
- __ret_617; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vmull_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint16x8_t __ret;
+ __ret = vmull_u8(vget_high_u8(__p0), vget_high_u8(__p1));
+ return __ret;
+}
#else
-#define vqdmlal_laneq_s16(__p0_618, __p1_618, __p2_618, __p3_618) __extension__ ({ \
- int32x4_t __ret_618; \
- int32x4_t __s0_618 = __p0_618; \
- int16x4_t __s1_618 = __p1_618; \
- int16x8_t __s2_618 = __p2_618; \
- int32x4_t __rev0_618; __rev0_618 = __builtin_shufflevector(__s0_618, __s0_618, 3, 2, 1, 0); \
- int16x4_t __rev1_618; __rev1_618 = __builtin_shufflevector(__s1_618, __s1_618, 3, 2, 1, 0); \
- int16x8_t __rev2_618; __rev2_618 = __builtin_shufflevector(__s2_618, __s2_618, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_618 = __noswap_vqdmlal_s16(__rev0_618, __rev1_618, __noswap_splat_laneq_s16(__rev2_618, __p3_618)); \
- __ret_618 = __builtin_shufflevector(__ret_618, __ret_618, 3, 2, 1, 0); \
- __ret_618; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vmull_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint16x8_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vmull_u8(__noswap_vget_high_u8(__rev0), __noswap_vget_high_u8(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
-__ai int64_t vqdmlsls_s32(int64_t __p0, int32_t __p1, int32_t __p2) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vqdmlsls_s32(__p0, __p1, __p2);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vmull_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint64x2_t __ret;
+ __ret = vmull_u32(vget_high_u32(__p0), vget_high_u32(__p1));
return __ret;
}
-__ai int32_t vqdmlslh_s16(int32_t __p0, int16_t __p1, int16_t __p2) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vqdmlslh_s16(__p0, __p1, __p2);
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vmull_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint64x2_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __noswap_vmull_u32(__noswap_vget_high_u32(__rev0), __noswap_vget_high_u32(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmull_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint32x4_t __ret;
+ __ret = vmull_u16(vget_high_u16(__p0), vget_high_u16(__p1));
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmull_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint32x4_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vmull_u16(__noswap_vget_high_u16(__rev0), __noswap_vget_high_u16(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmull_high_s8(int8x16_t __p0, int8x16_t __p1) {
+ int16x8_t __ret;
+ __ret = vmull_s8(vget_high_s8(__p0), vget_high_s8(__p1));
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmull_high_s8(int8x16_t __p0, int8x16_t __p1) {
+ int16x8_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vmull_s8(__noswap_vget_high_s8(__rev0), __noswap_vget_high_s8(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
+#endif
+
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vqdmlsl_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmull_high_s32(int32x4_t __p0, int32x4_t __p1) {
int64x2_t __ret;
- __ret = vqdmlsl_s32(__p0, vget_high_s32(__p1), vget_high_s32(__p2));
+ __ret = vmull_s32(vget_high_s32(__p0), vget_high_s32(__p1));
return __ret;
}
#else
-__ai int64x2_t vqdmlsl_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmull_high_s32(int32x4_t __p0, int32x4_t __p1) {
int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __noswap_vqdmlsl_s32(__rev0, __noswap_vget_high_s32(__rev1), __noswap_vget_high_s32(__rev2));
+ __ret = __noswap_vmull_s32(__noswap_vget_high_s32(__rev0), __noswap_vget_high_s32(__rev1));
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqdmlsl_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmull_high_s16(int16x8_t __p0, int16x8_t __p1) {
int32x4_t __ret;
- __ret = vqdmlsl_s16(__p0, vget_high_s16(__p1), vget_high_s16(__p2));
+ __ret = vmull_s16(vget_high_s16(__p0), vget_high_s16(__p1));
return __ret;
}
#else
-__ai int32x4_t vqdmlsl_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmull_high_s16(int16x8_t __p0, int16x8_t __p1) {
int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vqdmlsl_s16(__rev0, __noswap_vget_high_s16(__rev1), __noswap_vget_high_s16(__rev2));
+ __ret = __noswap_vmull_s16(__noswap_vget_high_s16(__rev0), __noswap_vget_high_s16(__rev1));
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlsl_high_lane_s32(__p0_619, __p1_619, __p2_619, __p3_619) __extension__ ({ \
- int64x2_t __ret_619; \
- int64x2_t __s0_619 = __p0_619; \
- int32x4_t __s1_619 = __p1_619; \
- int32x2_t __s2_619 = __p2_619; \
- __ret_619 = vqdmlsl_s32(__s0_619, vget_high_s32(__s1_619), splat_lane_s32(__s2_619, __p3_619)); \
- __ret_619; \
+#define vmull_high_lane_u32(__p0_585, __p1_585, __p2_585) __extension__ ({ \
+ uint64x2_t __ret_585; \
+ uint32x4_t __s0_585 = __p0_585; \
+ uint32x2_t __s1_585 = __p1_585; \
+ __ret_585 = vmull_u32(vget_high_u32(__s0_585), splat_lane_u32(__s1_585, __p2_585)); \
+ __ret_585; \
})
#else
-#define vqdmlsl_high_lane_s32(__p0_620, __p1_620, __p2_620, __p3_620) __extension__ ({ \
- int64x2_t __ret_620; \
- int64x2_t __s0_620 = __p0_620; \
- int32x4_t __s1_620 = __p1_620; \
- int32x2_t __s2_620 = __p2_620; \
- int64x2_t __rev0_620; __rev0_620 = __builtin_shufflevector(__s0_620, __s0_620, 1, 0); \
- int32x4_t __rev1_620; __rev1_620 = __builtin_shufflevector(__s1_620, __s1_620, 3, 2, 1, 0); \
- int32x2_t __rev2_620; __rev2_620 = __builtin_shufflevector(__s2_620, __s2_620, 1, 0); \
- __ret_620 = __noswap_vqdmlsl_s32(__rev0_620, __noswap_vget_high_s32(__rev1_620), __noswap_splat_lane_s32(__rev2_620, __p3_620)); \
- __ret_620 = __builtin_shufflevector(__ret_620, __ret_620, 1, 0); \
- __ret_620; \
+#define vmull_high_lane_u32(__p0_586, __p1_586, __p2_586) __extension__ ({ \
+ uint64x2_t __ret_586; \
+ uint32x4_t __s0_586 = __p0_586; \
+ uint32x2_t __s1_586 = __p1_586; \
+ uint32x4_t __rev0_586; __rev0_586 = __builtin_shufflevector(__s0_586, __s0_586, 3, 2, 1, 0); \
+ uint32x2_t __rev1_586; __rev1_586 = __builtin_shufflevector(__s1_586, __s1_586, 1, 0); \
+ __ret_586 = __noswap_vmull_u32(__noswap_vget_high_u32(__rev0_586), __noswap_splat_lane_u32(__rev1_586, __p2_586)); \
+ __ret_586 = __builtin_shufflevector(__ret_586, __ret_586, 1, 0); \
+ __ret_586; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlsl_high_lane_s16(__p0_621, __p1_621, __p2_621, __p3_621) __extension__ ({ \
- int32x4_t __ret_621; \
- int32x4_t __s0_621 = __p0_621; \
- int16x8_t __s1_621 = __p1_621; \
- int16x4_t __s2_621 = __p2_621; \
- __ret_621 = vqdmlsl_s16(__s0_621, vget_high_s16(__s1_621), splat_lane_s16(__s2_621, __p3_621)); \
- __ret_621; \
+#define vmull_high_lane_u16(__p0_587, __p1_587, __p2_587) __extension__ ({ \
+ uint32x4_t __ret_587; \
+ uint16x8_t __s0_587 = __p0_587; \
+ uint16x4_t __s1_587 = __p1_587; \
+ __ret_587 = vmull_u16(vget_high_u16(__s0_587), splat_lane_u16(__s1_587, __p2_587)); \
+ __ret_587; \
})
#else
-#define vqdmlsl_high_lane_s16(__p0_622, __p1_622, __p2_622, __p3_622) __extension__ ({ \
- int32x4_t __ret_622; \
- int32x4_t __s0_622 = __p0_622; \
- int16x8_t __s1_622 = __p1_622; \
- int16x4_t __s2_622 = __p2_622; \
- int32x4_t __rev0_622; __rev0_622 = __builtin_shufflevector(__s0_622, __s0_622, 3, 2, 1, 0); \
- int16x8_t __rev1_622; __rev1_622 = __builtin_shufflevector(__s1_622, __s1_622, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x4_t __rev2_622; __rev2_622 = __builtin_shufflevector(__s2_622, __s2_622, 3, 2, 1, 0); \
- __ret_622 = __noswap_vqdmlsl_s16(__rev0_622, __noswap_vget_high_s16(__rev1_622), __noswap_splat_lane_s16(__rev2_622, __p3_622)); \
- __ret_622 = __builtin_shufflevector(__ret_622, __ret_622, 3, 2, 1, 0); \
- __ret_622; \
+#define vmull_high_lane_u16(__p0_588, __p1_588, __p2_588) __extension__ ({ \
+ uint32x4_t __ret_588; \
+ uint16x8_t __s0_588 = __p0_588; \
+ uint16x4_t __s1_588 = __p1_588; \
+ uint16x8_t __rev0_588; __rev0_588 = __builtin_shufflevector(__s0_588, __s0_588, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x4_t __rev1_588; __rev1_588 = __builtin_shufflevector(__s1_588, __s1_588, 3, 2, 1, 0); \
+ __ret_588 = __noswap_vmull_u16(__noswap_vget_high_u16(__rev0_588), __noswap_splat_lane_u16(__rev1_588, __p2_588)); \
+ __ret_588 = __builtin_shufflevector(__ret_588, __ret_588, 3, 2, 1, 0); \
+ __ret_588; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlsl_high_laneq_s32(__p0_623, __p1_623, __p2_623, __p3_623) __extension__ ({ \
- int64x2_t __ret_623; \
- int64x2_t __s0_623 = __p0_623; \
- int32x4_t __s1_623 = __p1_623; \
- int32x4_t __s2_623 = __p2_623; \
- __ret_623 = vqdmlsl_s32(__s0_623, vget_high_s32(__s1_623), splat_laneq_s32(__s2_623, __p3_623)); \
- __ret_623; \
+#define vmull_high_lane_s32(__p0_589, __p1_589, __p2_589) __extension__ ({ \
+ int64x2_t __ret_589; \
+ int32x4_t __s0_589 = __p0_589; \
+ int32x2_t __s1_589 = __p1_589; \
+ __ret_589 = vmull_s32(vget_high_s32(__s0_589), splat_lane_s32(__s1_589, __p2_589)); \
+ __ret_589; \
})
#else
-#define vqdmlsl_high_laneq_s32(__p0_624, __p1_624, __p2_624, __p3_624) __extension__ ({ \
- int64x2_t __ret_624; \
- int64x2_t __s0_624 = __p0_624; \
- int32x4_t __s1_624 = __p1_624; \
- int32x4_t __s2_624 = __p2_624; \
- int64x2_t __rev0_624; __rev0_624 = __builtin_shufflevector(__s0_624, __s0_624, 1, 0); \
- int32x4_t __rev1_624; __rev1_624 = __builtin_shufflevector(__s1_624, __s1_624, 3, 2, 1, 0); \
- int32x4_t __rev2_624; __rev2_624 = __builtin_shufflevector(__s2_624, __s2_624, 3, 2, 1, 0); \
- __ret_624 = __noswap_vqdmlsl_s32(__rev0_624, __noswap_vget_high_s32(__rev1_624), __noswap_splat_laneq_s32(__rev2_624, __p3_624)); \
- __ret_624 = __builtin_shufflevector(__ret_624, __ret_624, 1, 0); \
- __ret_624; \
+#define vmull_high_lane_s32(__p0_590, __p1_590, __p2_590) __extension__ ({ \
+ int64x2_t __ret_590; \
+ int32x4_t __s0_590 = __p0_590; \
+ int32x2_t __s1_590 = __p1_590; \
+ int32x4_t __rev0_590; __rev0_590 = __builtin_shufflevector(__s0_590, __s0_590, 3, 2, 1, 0); \
+ int32x2_t __rev1_590; __rev1_590 = __builtin_shufflevector(__s1_590, __s1_590, 1, 0); \
+ __ret_590 = __noswap_vmull_s32(__noswap_vget_high_s32(__rev0_590), __noswap_splat_lane_s32(__rev1_590, __p2_590)); \
+ __ret_590 = __builtin_shufflevector(__ret_590, __ret_590, 1, 0); \
+ __ret_590; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlsl_high_laneq_s16(__p0_625, __p1_625, __p2_625, __p3_625) __extension__ ({ \
- int32x4_t __ret_625; \
- int32x4_t __s0_625 = __p0_625; \
- int16x8_t __s1_625 = __p1_625; \
- int16x8_t __s2_625 = __p2_625; \
- __ret_625 = vqdmlsl_s16(__s0_625, vget_high_s16(__s1_625), splat_laneq_s16(__s2_625, __p3_625)); \
- __ret_625; \
+#define vmull_high_lane_s16(__p0_591, __p1_591, __p2_591) __extension__ ({ \
+ int32x4_t __ret_591; \
+ int16x8_t __s0_591 = __p0_591; \
+ int16x4_t __s1_591 = __p1_591; \
+ __ret_591 = vmull_s16(vget_high_s16(__s0_591), splat_lane_s16(__s1_591, __p2_591)); \
+ __ret_591; \
})
#else
-#define vqdmlsl_high_laneq_s16(__p0_626, __p1_626, __p2_626, __p3_626) __extension__ ({ \
- int32x4_t __ret_626; \
- int32x4_t __s0_626 = __p0_626; \
- int16x8_t __s1_626 = __p1_626; \
- int16x8_t __s2_626 = __p2_626; \
- int32x4_t __rev0_626; __rev0_626 = __builtin_shufflevector(__s0_626, __s0_626, 3, 2, 1, 0); \
- int16x8_t __rev1_626; __rev1_626 = __builtin_shufflevector(__s1_626, __s1_626, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev2_626; __rev2_626 = __builtin_shufflevector(__s2_626, __s2_626, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_626 = __noswap_vqdmlsl_s16(__rev0_626, __noswap_vget_high_s16(__rev1_626), __noswap_splat_laneq_s16(__rev2_626, __p3_626)); \
- __ret_626 = __builtin_shufflevector(__ret_626, __ret_626, 3, 2, 1, 0); \
- __ret_626; \
+#define vmull_high_lane_s16(__p0_592, __p1_592, __p2_592) __extension__ ({ \
+ int32x4_t __ret_592; \
+ int16x8_t __s0_592 = __p0_592; \
+ int16x4_t __s1_592 = __p1_592; \
+ int16x8_t __rev0_592; __rev0_592 = __builtin_shufflevector(__s0_592, __s0_592, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x4_t __rev1_592; __rev1_592 = __builtin_shufflevector(__s1_592, __s1_592, 3, 2, 1, 0); \
+ __ret_592 = __noswap_vmull_s16(__noswap_vget_high_s16(__rev0_592), __noswap_splat_lane_s16(__rev1_592, __p2_592)); \
+ __ret_592 = __builtin_shufflevector(__ret_592, __ret_592, 3, 2, 1, 0); \
+ __ret_592; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_high_laneq_u32(__p0_593, __p1_593, __p2_593) __extension__ ({ \
+ uint64x2_t __ret_593; \
+ uint32x4_t __s0_593 = __p0_593; \
+ uint32x4_t __s1_593 = __p1_593; \
+ __ret_593 = vmull_u32(vget_high_u32(__s0_593), splat_laneq_u32(__s1_593, __p2_593)); \
+ __ret_593; \
+})
+#else
+#define vmull_high_laneq_u32(__p0_594, __p1_594, __p2_594) __extension__ ({ \
+ uint64x2_t __ret_594; \
+ uint32x4_t __s0_594 = __p0_594; \
+ uint32x4_t __s1_594 = __p1_594; \
+ uint32x4_t __rev0_594; __rev0_594 = __builtin_shufflevector(__s0_594, __s0_594, 3, 2, 1, 0); \
+ uint32x4_t __rev1_594; __rev1_594 = __builtin_shufflevector(__s1_594, __s1_594, 3, 2, 1, 0); \
+ __ret_594 = __noswap_vmull_u32(__noswap_vget_high_u32(__rev0_594), __noswap_splat_laneq_u32(__rev1_594, __p2_594)); \
+ __ret_594 = __builtin_shufflevector(__ret_594, __ret_594, 1, 0); \
+ __ret_594; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_high_laneq_u16(__p0_595, __p1_595, __p2_595) __extension__ ({ \
+ uint32x4_t __ret_595; \
+ uint16x8_t __s0_595 = __p0_595; \
+ uint16x8_t __s1_595 = __p1_595; \
+ __ret_595 = vmull_u16(vget_high_u16(__s0_595), splat_laneq_u16(__s1_595, __p2_595)); \
+ __ret_595; \
+})
+#else
+#define vmull_high_laneq_u16(__p0_596, __p1_596, __p2_596) __extension__ ({ \
+ uint32x4_t __ret_596; \
+ uint16x8_t __s0_596 = __p0_596; \
+ uint16x8_t __s1_596 = __p1_596; \
+ uint16x8_t __rev0_596; __rev0_596 = __builtin_shufflevector(__s0_596, __s0_596, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev1_596; __rev1_596 = __builtin_shufflevector(__s1_596, __s1_596, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_596 = __noswap_vmull_u16(__noswap_vget_high_u16(__rev0_596), __noswap_splat_laneq_u16(__rev1_596, __p2_596)); \
+ __ret_596 = __builtin_shufflevector(__ret_596, __ret_596, 3, 2, 1, 0); \
+ __ret_596; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_high_laneq_s32(__p0_597, __p1_597, __p2_597) __extension__ ({ \
+ int64x2_t __ret_597; \
+ int32x4_t __s0_597 = __p0_597; \
+ int32x4_t __s1_597 = __p1_597; \
+ __ret_597 = vmull_s32(vget_high_s32(__s0_597), splat_laneq_s32(__s1_597, __p2_597)); \
+ __ret_597; \
+})
+#else
+#define vmull_high_laneq_s32(__p0_598, __p1_598, __p2_598) __extension__ ({ \
+ int64x2_t __ret_598; \
+ int32x4_t __s0_598 = __p0_598; \
+ int32x4_t __s1_598 = __p1_598; \
+ int32x4_t __rev0_598; __rev0_598 = __builtin_shufflevector(__s0_598, __s0_598, 3, 2, 1, 0); \
+ int32x4_t __rev1_598; __rev1_598 = __builtin_shufflevector(__s1_598, __s1_598, 3, 2, 1, 0); \
+ __ret_598 = __noswap_vmull_s32(__noswap_vget_high_s32(__rev0_598), __noswap_splat_laneq_s32(__rev1_598, __p2_598)); \
+ __ret_598 = __builtin_shufflevector(__ret_598, __ret_598, 1, 0); \
+ __ret_598; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_high_laneq_s16(__p0_599, __p1_599, __p2_599) __extension__ ({ \
+ int32x4_t __ret_599; \
+ int16x8_t __s0_599 = __p0_599; \
+ int16x8_t __s1_599 = __p1_599; \
+ __ret_599 = vmull_s16(vget_high_s16(__s0_599), splat_laneq_s16(__s1_599, __p2_599)); \
+ __ret_599; \
+})
+#else
+#define vmull_high_laneq_s16(__p0_600, __p1_600, __p2_600) __extension__ ({ \
+ int32x4_t __ret_600; \
+ int16x8_t __s0_600 = __p0_600; \
+ int16x8_t __s1_600 = __p1_600; \
+ int16x8_t __rev0_600; __rev0_600 = __builtin_shufflevector(__s0_600, __s0_600, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1_600; __rev1_600 = __builtin_shufflevector(__s1_600, __s1_600, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_600 = __noswap_vmull_s16(__noswap_vget_high_s16(__rev0_600), __noswap_splat_laneq_s16(__rev1_600, __p2_600)); \
+ __ret_600 = __builtin_shufflevector(__ret_600, __ret_600, 3, 2, 1, 0); \
+ __ret_600; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vqdmlsl_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vmull_high_n_u32(uint32x4_t __p0, uint32_t __p1) {
+ uint64x2_t __ret;
+ __ret = vmull_n_u32(vget_high_u32(__p0), __p1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vmull_high_n_u32(uint32x4_t __p0, uint32_t __p1) {
+ uint64x2_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __noswap_vmull_n_u32(__noswap_vget_high_u32(__rev0), __p1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmull_high_n_u16(uint16x8_t __p0, uint16_t __p1) {
+ uint32x4_t __ret;
+ __ret = vmull_n_u16(vget_high_u16(__p0), __p1);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmull_high_n_u16(uint16x8_t __p0, uint16_t __p1) {
+ uint32x4_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vmull_n_u16(__noswap_vget_high_u16(__rev0), __p1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vmull_high_n_s32(int32x4_t __p0, int32_t __p1) {
int64x2_t __ret;
- __ret = vqdmlsl_n_s32(__p0, vget_high_s32(__p1), __p2);
+ __ret = vmull_n_s32(vget_high_s32(__p0), __p1);
return __ret;
}
#else
-__ai int64x2_t vqdmlsl_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmull_high_n_s32(int32x4_t __p0, int32_t __p1) {
int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vqdmlsl_n_s32(__rev0, __noswap_vget_high_s32(__rev1), __p2);
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __noswap_vmull_n_s32(__noswap_vget_high_s32(__rev0), __p1);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqdmlsl_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmull_high_n_s16(int16x8_t __p0, int16_t __p1) {
int32x4_t __ret;
- __ret = vqdmlsl_n_s16(__p0, vget_high_s16(__p1), __p2);
+ __ret = vmull_n_s16(vget_high_s16(__p0), __p1);
return __ret;
}
#else
-__ai int32x4_t vqdmlsl_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmull_high_n_s16(int16x8_t __p0, int16_t __p1) {
int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vqdmlsl_n_s16(__rev0, __noswap_vget_high_s16(__rev1), __p2);
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vmull_n_s16(__noswap_vget_high_s16(__rev0), __p1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlsls_lane_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
- int64_t __ret; \
- int64_t __s0 = __p0; \
- int32_t __s1 = __p1; \
- int32x2_t __s2 = __p2; \
- __ret = (int64_t) __builtin_neon_vqdmlsls_lane_s32(__s0, __s1, __s2, __p3); \
- __ret; \
+#define vmull_laneq_u32(__p0_601, __p1_601, __p2_601) __extension__ ({ \
+ uint64x2_t __ret_601; \
+ uint32x2_t __s0_601 = __p0_601; \
+ uint32x4_t __s1_601 = __p1_601; \
+ __ret_601 = vmull_u32(__s0_601, splat_laneq_u32(__s1_601, __p2_601)); \
+ __ret_601; \
})
#else
-#define vqdmlsls_lane_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
- int64_t __ret; \
- int64_t __s0 = __p0; \
- int32_t __s1 = __p1; \
- int32x2_t __s2 = __p2; \
- int32x2_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
- __ret = (int64_t) __builtin_neon_vqdmlsls_lane_s32(__s0, __s1, __rev2, __p3); \
- __ret; \
+#define vmull_laneq_u32(__p0_602, __p1_602, __p2_602) __extension__ ({ \
+ uint64x2_t __ret_602; \
+ uint32x2_t __s0_602 = __p0_602; \
+ uint32x4_t __s1_602 = __p1_602; \
+ uint32x2_t __rev0_602; __rev0_602 = __builtin_shufflevector(__s0_602, __s0_602, 1, 0); \
+ uint32x4_t __rev1_602; __rev1_602 = __builtin_shufflevector(__s1_602, __s1_602, 3, 2, 1, 0); \
+ __ret_602 = __noswap_vmull_u32(__rev0_602, __noswap_splat_laneq_u32(__rev1_602, __p2_602)); \
+ __ret_602 = __builtin_shufflevector(__ret_602, __ret_602, 1, 0); \
+ __ret_602; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlslh_lane_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
- int32_t __ret; \
- int32_t __s0 = __p0; \
- int16_t __s1 = __p1; \
- int16x4_t __s2 = __p2; \
- __ret = (int32_t) __builtin_neon_vqdmlslh_lane_s16(__s0, __s1, __s2, __p3); \
- __ret; \
+#define vmull_laneq_u16(__p0_603, __p1_603, __p2_603) __extension__ ({ \
+ uint32x4_t __ret_603; \
+ uint16x4_t __s0_603 = __p0_603; \
+ uint16x8_t __s1_603 = __p1_603; \
+ __ret_603 = vmull_u16(__s0_603, splat_laneq_u16(__s1_603, __p2_603)); \
+ __ret_603; \
})
#else
-#define vqdmlslh_lane_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
- int32_t __ret; \
- int32_t __s0 = __p0; \
- int16_t __s1 = __p1; \
- int16x4_t __s2 = __p2; \
- int16x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
- __ret = (int32_t) __builtin_neon_vqdmlslh_lane_s16(__s0, __s1, __rev2, __p3); \
- __ret; \
+#define vmull_laneq_u16(__p0_604, __p1_604, __p2_604) __extension__ ({ \
+ uint32x4_t __ret_604; \
+ uint16x4_t __s0_604 = __p0_604; \
+ uint16x8_t __s1_604 = __p1_604; \
+ uint16x4_t __rev0_604; __rev0_604 = __builtin_shufflevector(__s0_604, __s0_604, 3, 2, 1, 0); \
+ uint16x8_t __rev1_604; __rev1_604 = __builtin_shufflevector(__s1_604, __s1_604, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_604 = __noswap_vmull_u16(__rev0_604, __noswap_splat_laneq_u16(__rev1_604, __p2_604)); \
+ __ret_604 = __builtin_shufflevector(__ret_604, __ret_604, 3, 2, 1, 0); \
+ __ret_604; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlsls_laneq_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
- int64_t __ret; \
- int64_t __s0 = __p0; \
- int32_t __s1 = __p1; \
- int32x4_t __s2 = __p2; \
- __ret = (int64_t) __builtin_neon_vqdmlsls_laneq_s32(__s0, __s1, __s2, __p3); \
- __ret; \
+#define vmull_laneq_s32(__p0_605, __p1_605, __p2_605) __extension__ ({ \
+ int64x2_t __ret_605; \
+ int32x2_t __s0_605 = __p0_605; \
+ int32x4_t __s1_605 = __p1_605; \
+ __ret_605 = vmull_s32(__s0_605, splat_laneq_s32(__s1_605, __p2_605)); \
+ __ret_605; \
})
#else
-#define vqdmlsls_laneq_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
- int64_t __ret; \
- int64_t __s0 = __p0; \
- int32_t __s1 = __p1; \
- int32x4_t __s2 = __p2; \
- int32x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
- __ret = (int64_t) __builtin_neon_vqdmlsls_laneq_s32(__s0, __s1, __rev2, __p3); \
- __ret; \
+#define vmull_laneq_s32(__p0_606, __p1_606, __p2_606) __extension__ ({ \
+ int64x2_t __ret_606; \
+ int32x2_t __s0_606 = __p0_606; \
+ int32x4_t __s1_606 = __p1_606; \
+ int32x2_t __rev0_606; __rev0_606 = __builtin_shufflevector(__s0_606, __s0_606, 1, 0); \
+ int32x4_t __rev1_606; __rev1_606 = __builtin_shufflevector(__s1_606, __s1_606, 3, 2, 1, 0); \
+ __ret_606 = __noswap_vmull_s32(__rev0_606, __noswap_splat_laneq_s32(__rev1_606, __p2_606)); \
+ __ret_606 = __builtin_shufflevector(__ret_606, __ret_606, 1, 0); \
+ __ret_606; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlslh_laneq_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
- int32_t __ret; \
- int32_t __s0 = __p0; \
- int16_t __s1 = __p1; \
- int16x8_t __s2 = __p2; \
- __ret = (int32_t) __builtin_neon_vqdmlslh_laneq_s16(__s0, __s1, __s2, __p3); \
- __ret; \
+#define vmull_laneq_s16(__p0_607, __p1_607, __p2_607) __extension__ ({ \
+ int32x4_t __ret_607; \
+ int16x4_t __s0_607 = __p0_607; \
+ int16x8_t __s1_607 = __p1_607; \
+ __ret_607 = vmull_s16(__s0_607, splat_laneq_s16(__s1_607, __p2_607)); \
+ __ret_607; \
})
#else
-#define vqdmlslh_laneq_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
- int32_t __ret; \
- int32_t __s0 = __p0; \
- int16_t __s1 = __p1; \
- int16x8_t __s2 = __p2; \
- int16x8_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int32_t) __builtin_neon_vqdmlslh_laneq_s16(__s0, __s1, __rev2, __p3); \
- __ret; \
+#define vmull_laneq_s16(__p0_608, __p1_608, __p2_608) __extension__ ({ \
+ int32x4_t __ret_608; \
+ int16x4_t __s0_608 = __p0_608; \
+ int16x8_t __s1_608 = __p1_608; \
+ int16x4_t __rev0_608; __rev0_608 = __builtin_shufflevector(__s0_608, __s0_608, 3, 2, 1, 0); \
+ int16x8_t __rev1_608; __rev1_608 = __builtin_shufflevector(__s1_608, __s1_608, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_608 = __noswap_vmull_s16(__rev0_608, __noswap_splat_laneq_s16(__rev1_608, __p2_608)); \
+ __ret_608 = __builtin_shufflevector(__ret_608, __ret_608, 3, 2, 1, 0); \
+ __ret_608; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlsl_laneq_s32(__p0_627, __p1_627, __p2_627, __p3_627) __extension__ ({ \
- int64x2_t __ret_627; \
- int64x2_t __s0_627 = __p0_627; \
- int32x2_t __s1_627 = __p1_627; \
- int32x4_t __s2_627 = __p2_627; \
- __ret_627 = vqdmlsl_s32(__s0_627, __s1_627, splat_laneq_s32(__s2_627, __p3_627)); \
- __ret_627; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vmulxq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vmulxq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+ return __ret;
+}
#else
-#define vqdmlsl_laneq_s32(__p0_628, __p1_628, __p2_628, __p3_628) __extension__ ({ \
- int64x2_t __ret_628; \
- int64x2_t __s0_628 = __p0_628; \
- int32x2_t __s1_628 = __p1_628; \
- int32x4_t __s2_628 = __p2_628; \
- int64x2_t __rev0_628; __rev0_628 = __builtin_shufflevector(__s0_628, __s0_628, 1, 0); \
- int32x2_t __rev1_628; __rev1_628 = __builtin_shufflevector(__s1_628, __s1_628, 1, 0); \
- int32x4_t __rev2_628; __rev2_628 = __builtin_shufflevector(__s2_628, __s2_628, 3, 2, 1, 0); \
- __ret_628 = __noswap_vqdmlsl_s32(__rev0_628, __rev1_628, __noswap_splat_laneq_s32(__rev2_628, __p3_628)); \
- __ret_628 = __builtin_shufflevector(__ret_628, __ret_628, 1, 0); \
- __ret_628; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vmulxq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vmulxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t __noswap_vmulxq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vmulxq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmlsl_laneq_s16(__p0_629, __p1_629, __p2_629, __p3_629) __extension__ ({ \
- int32x4_t __ret_629; \
- int32x4_t __s0_629 = __p0_629; \
- int16x4_t __s1_629 = __p1_629; \
- int16x8_t __s2_629 = __p2_629; \
- __ret_629 = vqdmlsl_s16(__s0_629, __s1_629, splat_laneq_s16(__s2_629, __p3_629)); \
- __ret_629; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vmulxq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vmulxq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+ return __ret;
+}
#else
-#define vqdmlsl_laneq_s16(__p0_630, __p1_630, __p2_630, __p3_630) __extension__ ({ \
- int32x4_t __ret_630; \
- int32x4_t __s0_630 = __p0_630; \
- int16x4_t __s1_630 = __p1_630; \
- int16x8_t __s2_630 = __p2_630; \
- int32x4_t __rev0_630; __rev0_630 = __builtin_shufflevector(__s0_630, __s0_630, 3, 2, 1, 0); \
- int16x4_t __rev1_630; __rev1_630 = __builtin_shufflevector(__s1_630, __s1_630, 3, 2, 1, 0); \
- int16x8_t __rev2_630; __rev2_630 = __builtin_shufflevector(__s2_630, __s2_630, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_630 = __noswap_vqdmlsl_s16(__rev0_630, __rev1_630, __noswap_splat_laneq_s16(__rev2_630, __p3_630)); \
- __ret_630 = __builtin_shufflevector(__ret_630, __ret_630, 3, 2, 1, 0); \
- __ret_630; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vmulxq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vmulxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t __noswap_vmulxq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vmulxq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+ return __ret;
+}
#endif
-__ai int32_t vqdmulhs_s32(int32_t __p0, int32_t __p1) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vqdmulhs_s32(__p0, __p1);
+__ai __attribute__((target("neon"))) float64x1_t vmulx_f64(float64x1_t __p0, float64x1_t __p1) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vmulx_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
return __ret;
}
-__ai int16_t vqdmulhh_s16(int16_t __p0, int16_t __p1) {
- int16_t __ret;
- __ret = (int16_t) __builtin_neon_vqdmulhh_s16(__p0, __p1);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vmulx_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vmulx_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
return __ret;
}
-#ifdef __LITTLE_ENDIAN__
-#define vqdmulhq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x2_t __s1 = __p1; \
- __ret = (int32x4_t) __builtin_neon_vqdmulhq_lane_v((int8x16_t)__s0, (int8x8_t)__s1, __p2, 2); \
- __ret; \
-})
#else
-#define vqdmulhq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x2_t __s1 = __p1; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_vqdmulhq_lane_v((int8x16_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vmulx_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vmulx_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t __noswap_vmulx_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vmulx_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+ return __ret;
+}
#endif
+__ai __attribute__((target("neon"))) float64_t vmulxd_f64(float64_t __p0, float64_t __p1) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vmulxd_f64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float32_t vmulxs_f32(float32_t __p0, float32_t __p1) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vmulxs_f32(__p0, __p1);
+ return __ret;
+}
+#define vmulxd_lane_f64(__p0_609, __p1_609, __p2_609) __extension__ ({ \
+ float64_t __ret_609; \
+ float64_t __s0_609 = __p0_609; \
+ float64x1_t __s1_609 = __p1_609; \
+ __ret_609 = vmulxd_f64(__s0_609, vget_lane_f64(__s1_609, __p2_609)); \
+ __ret_609; \
+})
#ifdef __LITTLE_ENDIAN__
-#define vqdmulhq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x4_t __s1 = __p1; \
- __ret = (int16x8_t) __builtin_neon_vqdmulhq_lane_v((int8x16_t)__s0, (int8x8_t)__s1, __p2, 1); \
- __ret; \
+#define vmulxs_lane_f32(__p0_610, __p1_610, __p2_610) __extension__ ({ \
+ float32_t __ret_610; \
+ float32_t __s0_610 = __p0_610; \
+ float32x2_t __s1_610 = __p1_610; \
+ __ret_610 = vmulxs_f32(__s0_610, vget_lane_f32(__s1_610, __p2_610)); \
+ __ret_610; \
})
#else
-#define vqdmulhq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x4_t __s1 = __p1; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_vqdmulhq_lane_v((int8x16_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vmulxs_lane_f32(__p0_611, __p1_611, __p2_611) __extension__ ({ \
+ float32_t __ret_611; \
+ float32_t __s0_611 = __p0_611; \
+ float32x2_t __s1_611 = __p1_611; \
+ float32x2_t __rev1_611; __rev1_611 = __builtin_shufflevector(__s1_611, __s1_611, 1, 0); \
+ __ret_611 = vmulxs_f32(__s0_611, __noswap_vget_lane_f32(__rev1_611, __p2_611)); \
+ __ret_611; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmulh_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __s1 = __p1; \
- __ret = (int32x2_t) __builtin_neon_vqdmulh_lane_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
- __ret; \
+#define vmulxq_lane_f64(__p0_612, __p1_612, __p2_612) __extension__ ({ \
+ float64x2_t __ret_612; \
+ float64x2_t __s0_612 = __p0_612; \
+ float64x1_t __s1_612 = __p1_612; \
+ __ret_612 = vmulxq_f64(__s0_612, splatq_lane_f64(__s1_612, __p2_612)); \
+ __ret_612; \
})
#else
-#define vqdmulh_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __s1 = __p1; \
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vqdmulh_lane_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
+#define vmulxq_lane_f64(__p0_613, __p1_613, __p2_613) __extension__ ({ \
+ float64x2_t __ret_613; \
+ float64x2_t __s0_613 = __p0_613; \
+ float64x1_t __s1_613 = __p1_613; \
+ float64x2_t __rev0_613; __rev0_613 = __builtin_shufflevector(__s0_613, __s0_613, 1, 0); \
+ __ret_613 = __noswap_vmulxq_f64(__rev0_613, __noswap_splatq_lane_f64(__s1_613, __p2_613)); \
+ __ret_613 = __builtin_shufflevector(__ret_613, __ret_613, 1, 0); \
+ __ret_613; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmulh_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __s1 = __p1; \
- __ret = (int16x4_t) __builtin_neon_vqdmulh_lane_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
- __ret; \
+#define vmulxq_lane_f32(__p0_614, __p1_614, __p2_614) __extension__ ({ \
+ float32x4_t __ret_614; \
+ float32x4_t __s0_614 = __p0_614; \
+ float32x2_t __s1_614 = __p1_614; \
+ __ret_614 = vmulxq_f32(__s0_614, splatq_lane_f32(__s1_614, __p2_614)); \
+ __ret_614; \
})
#else
-#define vqdmulh_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __s1 = __p1; \
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vqdmulh_lane_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
+#define vmulxq_lane_f32(__p0_615, __p1_615, __p2_615) __extension__ ({ \
+ float32x4_t __ret_615; \
+ float32x4_t __s0_615 = __p0_615; \
+ float32x2_t __s1_615 = __p1_615; \
+ float32x4_t __rev0_615; __rev0_615 = __builtin_shufflevector(__s0_615, __s0_615, 3, 2, 1, 0); \
+ float32x2_t __rev1_615; __rev1_615 = __builtin_shufflevector(__s1_615, __s1_615, 1, 0); \
+ __ret_615 = __noswap_vmulxq_f32(__rev0_615, __noswap_splatq_lane_f32(__rev1_615, __p2_615)); \
+ __ret_615 = __builtin_shufflevector(__ret_615, __ret_615, 3, 2, 1, 0); \
+ __ret_615; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmulhs_lane_s32(__p0_631, __p1_631, __p2_631) __extension__ ({ \
- int32_t __ret_631; \
- int32_t __s0_631 = __p0_631; \
- int32x2_t __s1_631 = __p1_631; \
- __ret_631 = vqdmulhs_s32(__s0_631, vget_lane_s32(__s1_631, __p2_631)); \
- __ret_631; \
+#define vmulx_lane_f32(__p0_616, __p1_616, __p2_616) __extension__ ({ \
+ float32x2_t __ret_616; \
+ float32x2_t __s0_616 = __p0_616; \
+ float32x2_t __s1_616 = __p1_616; \
+ __ret_616 = vmulx_f32(__s0_616, splat_lane_f32(__s1_616, __p2_616)); \
+ __ret_616; \
})
#else
-#define vqdmulhs_lane_s32(__p0_632, __p1_632, __p2_632) __extension__ ({ \
- int32_t __ret_632; \
- int32_t __s0_632 = __p0_632; \
- int32x2_t __s1_632 = __p1_632; \
- int32x2_t __rev1_632; __rev1_632 = __builtin_shufflevector(__s1_632, __s1_632, 1, 0); \
- __ret_632 = vqdmulhs_s32(__s0_632, __noswap_vget_lane_s32(__rev1_632, __p2_632)); \
- __ret_632; \
+#define vmulx_lane_f32(__p0_617, __p1_617, __p2_617) __extension__ ({ \
+ float32x2_t __ret_617; \
+ float32x2_t __s0_617 = __p0_617; \
+ float32x2_t __s1_617 = __p1_617; \
+ float32x2_t __rev0_617; __rev0_617 = __builtin_shufflevector(__s0_617, __s0_617, 1, 0); \
+ float32x2_t __rev1_617; __rev1_617 = __builtin_shufflevector(__s1_617, __s1_617, 1, 0); \
+ __ret_617 = __noswap_vmulx_f32(__rev0_617, __noswap_splat_lane_f32(__rev1_617, __p2_617)); \
+ __ret_617 = __builtin_shufflevector(__ret_617, __ret_617, 1, 0); \
+ __ret_617; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmulhh_lane_s16(__p0_633, __p1_633, __p2_633) __extension__ ({ \
- int16_t __ret_633; \
- int16_t __s0_633 = __p0_633; \
- int16x4_t __s1_633 = __p1_633; \
- __ret_633 = vqdmulhh_s16(__s0_633, vget_lane_s16(__s1_633, __p2_633)); \
- __ret_633; \
+#define vmulxd_laneq_f64(__p0_618, __p1_618, __p2_618) __extension__ ({ \
+ float64_t __ret_618; \
+ float64_t __s0_618 = __p0_618; \
+ float64x2_t __s1_618 = __p1_618; \
+ __ret_618 = vmulxd_f64(__s0_618, vgetq_lane_f64(__s1_618, __p2_618)); \
+ __ret_618; \
})
#else
-#define vqdmulhh_lane_s16(__p0_634, __p1_634, __p2_634) __extension__ ({ \
- int16_t __ret_634; \
- int16_t __s0_634 = __p0_634; \
- int16x4_t __s1_634 = __p1_634; \
- int16x4_t __rev1_634; __rev1_634 = __builtin_shufflevector(__s1_634, __s1_634, 3, 2, 1, 0); \
- __ret_634 = vqdmulhh_s16(__s0_634, __noswap_vget_lane_s16(__rev1_634, __p2_634)); \
- __ret_634; \
+#define vmulxd_laneq_f64(__p0_619, __p1_619, __p2_619) __extension__ ({ \
+ float64_t __ret_619; \
+ float64_t __s0_619 = __p0_619; \
+ float64x2_t __s1_619 = __p1_619; \
+ float64x2_t __rev1_619; __rev1_619 = __builtin_shufflevector(__s1_619, __s1_619, 1, 0); \
+ __ret_619 = vmulxd_f64(__s0_619, __noswap_vgetq_lane_f64(__rev1_619, __p2_619)); \
+ __ret_619; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmulhs_laneq_s32(__p0_635, __p1_635, __p2_635) __extension__ ({ \
- int32_t __ret_635; \
- int32_t __s0_635 = __p0_635; \
- int32x4_t __s1_635 = __p1_635; \
- __ret_635 = vqdmulhs_s32(__s0_635, vgetq_lane_s32(__s1_635, __p2_635)); \
- __ret_635; \
+#define vmulxs_laneq_f32(__p0_620, __p1_620, __p2_620) __extension__ ({ \
+ float32_t __ret_620; \
+ float32_t __s0_620 = __p0_620; \
+ float32x4_t __s1_620 = __p1_620; \
+ __ret_620 = vmulxs_f32(__s0_620, vgetq_lane_f32(__s1_620, __p2_620)); \
+ __ret_620; \
})
#else
-#define vqdmulhs_laneq_s32(__p0_636, __p1_636, __p2_636) __extension__ ({ \
- int32_t __ret_636; \
- int32_t __s0_636 = __p0_636; \
- int32x4_t __s1_636 = __p1_636; \
- int32x4_t __rev1_636; __rev1_636 = __builtin_shufflevector(__s1_636, __s1_636, 3, 2, 1, 0); \
- __ret_636 = vqdmulhs_s32(__s0_636, __noswap_vgetq_lane_s32(__rev1_636, __p2_636)); \
- __ret_636; \
+#define vmulxs_laneq_f32(__p0_621, __p1_621, __p2_621) __extension__ ({ \
+ float32_t __ret_621; \
+ float32_t __s0_621 = __p0_621; \
+ float32x4_t __s1_621 = __p1_621; \
+ float32x4_t __rev1_621; __rev1_621 = __builtin_shufflevector(__s1_621, __s1_621, 3, 2, 1, 0); \
+ __ret_621 = vmulxs_f32(__s0_621, __noswap_vgetq_lane_f32(__rev1_621, __p2_621)); \
+ __ret_621; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmulhh_laneq_s16(__p0_637, __p1_637, __p2_637) __extension__ ({ \
- int16_t __ret_637; \
- int16_t __s0_637 = __p0_637; \
- int16x8_t __s1_637 = __p1_637; \
- __ret_637 = vqdmulhh_s16(__s0_637, vgetq_lane_s16(__s1_637, __p2_637)); \
- __ret_637; \
+#define vmulxq_laneq_f64(__p0_622, __p1_622, __p2_622) __extension__ ({ \
+ float64x2_t __ret_622; \
+ float64x2_t __s0_622 = __p0_622; \
+ float64x2_t __s1_622 = __p1_622; \
+ __ret_622 = vmulxq_f64(__s0_622, splatq_laneq_f64(__s1_622, __p2_622)); \
+ __ret_622; \
})
#else
-#define vqdmulhh_laneq_s16(__p0_638, __p1_638, __p2_638) __extension__ ({ \
- int16_t __ret_638; \
- int16_t __s0_638 = __p0_638; \
- int16x8_t __s1_638 = __p1_638; \
- int16x8_t __rev1_638; __rev1_638 = __builtin_shufflevector(__s1_638, __s1_638, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_638 = vqdmulhh_s16(__s0_638, __noswap_vgetq_lane_s16(__rev1_638, __p2_638)); \
- __ret_638; \
+#define vmulxq_laneq_f64(__p0_623, __p1_623, __p2_623) __extension__ ({ \
+ float64x2_t __ret_623; \
+ float64x2_t __s0_623 = __p0_623; \
+ float64x2_t __s1_623 = __p1_623; \
+ float64x2_t __rev0_623; __rev0_623 = __builtin_shufflevector(__s0_623, __s0_623, 1, 0); \
+ float64x2_t __rev1_623; __rev1_623 = __builtin_shufflevector(__s1_623, __s1_623, 1, 0); \
+ __ret_623 = __noswap_vmulxq_f64(__rev0_623, __noswap_splatq_laneq_f64(__rev1_623, __p2_623)); \
+ __ret_623 = __builtin_shufflevector(__ret_623, __ret_623, 1, 0); \
+ __ret_623; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmulhq_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __s1 = __p1; \
- __ret = (int32x4_t) __builtin_neon_vqdmulhq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
- __ret; \
+#define vmulxq_laneq_f32(__p0_624, __p1_624, __p2_624) __extension__ ({ \
+ float32x4_t __ret_624; \
+ float32x4_t __s0_624 = __p0_624; \
+ float32x4_t __s1_624 = __p1_624; \
+ __ret_624 = vmulxq_f32(__s0_624, splatq_laneq_f32(__s1_624, __p2_624)); \
+ __ret_624; \
})
#else
-#define vqdmulhq_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __s1 = __p1; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_vqdmulhq_laneq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
+#define vmulxq_laneq_f32(__p0_625, __p1_625, __p2_625) __extension__ ({ \
+ float32x4_t __ret_625; \
+ float32x4_t __s0_625 = __p0_625; \
+ float32x4_t __s1_625 = __p1_625; \
+ float32x4_t __rev0_625; __rev0_625 = __builtin_shufflevector(__s0_625, __s0_625, 3, 2, 1, 0); \
+ float32x4_t __rev1_625; __rev1_625 = __builtin_shufflevector(__s1_625, __s1_625, 3, 2, 1, 0); \
+ __ret_625 = __noswap_vmulxq_f32(__rev0_625, __noswap_splatq_laneq_f32(__rev1_625, __p2_625)); \
+ __ret_625 = __builtin_shufflevector(__ret_625, __ret_625, 3, 2, 1, 0); \
+ __ret_625; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmulhq_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __s1 = __p1; \
- __ret = (int16x8_t) __builtin_neon_vqdmulhq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
- __ret; \
+#define vmulx_laneq_f32(__p0_626, __p1_626, __p2_626) __extension__ ({ \
+ float32x2_t __ret_626; \
+ float32x2_t __s0_626 = __p0_626; \
+ float32x4_t __s1_626 = __p1_626; \
+ __ret_626 = vmulx_f32(__s0_626, splat_laneq_f32(__s1_626, __p2_626)); \
+ __ret_626; \
})
#else
-#define vqdmulhq_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __s1 = __p1; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_vqdmulhq_laneq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
+#define vmulx_laneq_f32(__p0_627, __p1_627, __p2_627) __extension__ ({ \
+ float32x2_t __ret_627; \
+ float32x2_t __s0_627 = __p0_627; \
+ float32x4_t __s1_627 = __p1_627; \
+ float32x2_t __rev0_627; __rev0_627 = __builtin_shufflevector(__s0_627, __s0_627, 1, 0); \
+ float32x4_t __rev1_627; __rev1_627 = __builtin_shufflevector(__s1_627, __s1_627, 3, 2, 1, 0); \
+ __ret_627 = __noswap_vmulx_f32(__rev0_627, __noswap_splat_laneq_f32(__rev1_627, __p2_627)); \
+ __ret_627 = __builtin_shufflevector(__ret_627, __ret_627, 1, 0); \
+ __ret_627; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmulh_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x4_t __s1 = __p1; \
- __ret = (int32x2_t) __builtin_neon_vqdmulh_laneq_v((int8x8_t)__s0, (int8x16_t)__s1, __p2, 2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vnegq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ __ret = -__p0;
+ return __ret;
+}
#else
-#define vqdmulh_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x4_t __s1 = __p1; \
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vqdmulh_laneq_v((int8x8_t)__rev0, (int8x16_t)__rev1, __p2, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vnegq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = -__rev0;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmulh_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x8_t __s1 = __p1; \
- __ret = (int16x4_t) __builtin_neon_vqdmulh_laneq_v((int8x8_t)__s0, (int8x16_t)__s1, __p2, 1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vnegq_s64(int64x2_t __p0) {
+ int64x2_t __ret;
+ __ret = -__p0;
+ return __ret;
+}
#else
-#define vqdmulh_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x8_t __s1 = __p1; \
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vqdmulh_laneq_v((int8x8_t)__rev0, (int8x16_t)__rev1, __p2, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vnegq_s64(int64x2_t __p0) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = -__rev0;
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
-__ai int64_t vqdmulls_s32(int32_t __p0, int32_t __p1) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vqdmulls_s32(__p0, __p1);
+__ai __attribute__((target("neon"))) float64x1_t vneg_f64(float64x1_t __p0) {
+ float64x1_t __ret;
+ __ret = -__p0;
return __ret;
}
-__ai int32_t vqdmullh_s16(int16_t __p0, int16_t __p1) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vqdmullh_s16(__p0, __p1);
+__ai __attribute__((target("neon"))) int64x1_t vneg_s64(int64x1_t __p0) {
+ int64x1_t __ret;
+ __ret = -__p0;
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vnegd_s64(int64_t __p0) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vnegd_s64(__p0);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vqdmull_high_s32(int32x4_t __p0, int32x4_t __p1) {
- int64x2_t __ret;
- __ret = vqdmull_s32(vget_high_s32(__p0), vget_high_s32(__p1));
+__ai __attribute__((target("neon"))) uint8x16_t vpaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
return __ret;
}
#else
-__ai int64x2_t vqdmull_high_s32(int32x4_t __p0, int32x4_t __p1) {
- int64x2_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vqdmull_s32(__noswap_vget_high_s32(__rev0), __noswap_vget_high_s32(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vpaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqdmull_high_s16(int16x8_t __p0, int16x8_t __p1) {
- int32x4_t __ret;
- __ret = vqdmull_s16(vget_high_s16(__p0), vget_high_s16(__p1));
+__ai __attribute__((target("neon"))) uint32x4_t vpaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
return __ret;
}
#else
-__ai int32x4_t vqdmull_high_s16(int16x8_t __p0, int16x8_t __p1) {
- int32x4_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vqdmull_s16(__noswap_vget_high_s16(__rev0), __noswap_vget_high_s16(__rev1));
+__ai __attribute__((target("neon"))) uint32x4_t vpaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmull_high_lane_s32(__p0_639, __p1_639, __p2_639) __extension__ ({ \
- int64x2_t __ret_639; \
- int32x4_t __s0_639 = __p0_639; \
- int32x2_t __s1_639 = __p1_639; \
- __ret_639 = vqdmull_s32(vget_high_s32(__s0_639), splat_lane_s32(__s1_639, __p2_639)); \
- __ret_639; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vpaddq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+ return __ret;
+}
#else
-#define vqdmull_high_lane_s32(__p0_640, __p1_640, __p2_640) __extension__ ({ \
- int64x2_t __ret_640; \
- int32x4_t __s0_640 = __p0_640; \
- int32x2_t __s1_640 = __p1_640; \
- int32x4_t __rev0_640; __rev0_640 = __builtin_shufflevector(__s0_640, __s0_640, 3, 2, 1, 0); \
- int32x2_t __rev1_640; __rev1_640 = __builtin_shufflevector(__s1_640, __s1_640, 1, 0); \
- __ret_640 = __noswap_vqdmull_s32(__noswap_vget_high_s32(__rev0_640), __noswap_splat_lane_s32(__rev1_640, __p2_640)); \
- __ret_640 = __builtin_shufflevector(__ret_640, __ret_640, 1, 0); \
- __ret_640; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vpaddq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmull_high_lane_s16(__p0_641, __p1_641, __p2_641) __extension__ ({ \
- int32x4_t __ret_641; \
- int16x8_t __s0_641 = __p0_641; \
- int16x4_t __s1_641 = __p1_641; \
- __ret_641 = vqdmull_s16(vget_high_s16(__s0_641), splat_lane_s16(__s1_641, __p2_641)); \
- __ret_641; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vpaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ return __ret;
+}
#else
-#define vqdmull_high_lane_s16(__p0_642, __p1_642, __p2_642) __extension__ ({ \
- int32x4_t __ret_642; \
- int16x8_t __s0_642 = __p0_642; \
- int16x4_t __s1_642 = __p1_642; \
- int16x8_t __rev0_642; __rev0_642 = __builtin_shufflevector(__s0_642, __s0_642, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x4_t __rev1_642; __rev1_642 = __builtin_shufflevector(__s1_642, __s1_642, 3, 2, 1, 0); \
- __ret_642 = __noswap_vqdmull_s16(__noswap_vget_high_s16(__rev0_642), __noswap_splat_lane_s16(__rev1_642, __p2_642)); \
- __ret_642 = __builtin_shufflevector(__ret_642, __ret_642, 3, 2, 1, 0); \
- __ret_642; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vpaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmull_high_laneq_s32(__p0_643, __p1_643, __p2_643) __extension__ ({ \
- int64x2_t __ret_643; \
- int32x4_t __s0_643 = __p0_643; \
- int32x4_t __s1_643 = __p1_643; \
- __ret_643 = vqdmull_s32(vget_high_s32(__s0_643), splat_laneq_s32(__s1_643, __p2_643)); \
- __ret_643; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vpaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+ return __ret;
+}
#else
-#define vqdmull_high_laneq_s32(__p0_644, __p1_644, __p2_644) __extension__ ({ \
- int64x2_t __ret_644; \
- int32x4_t __s0_644 = __p0_644; \
- int32x4_t __s1_644 = __p1_644; \
- int32x4_t __rev0_644; __rev0_644 = __builtin_shufflevector(__s0_644, __s0_644, 3, 2, 1, 0); \
- int32x4_t __rev1_644; __rev1_644 = __builtin_shufflevector(__s1_644, __s1_644, 3, 2, 1, 0); \
- __ret_644 = __noswap_vqdmull_s32(__noswap_vget_high_s32(__rev0_644), __noswap_splat_laneq_s32(__rev1_644, __p2_644)); \
- __ret_644 = __builtin_shufflevector(__ret_644, __ret_644, 1, 0); \
- __ret_644; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vpaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmull_high_laneq_s16(__p0_645, __p1_645, __p2_645) __extension__ ({ \
- int32x4_t __ret_645; \
- int16x8_t __s0_645 = __p0_645; \
- int16x8_t __s1_645 = __p1_645; \
- __ret_645 = vqdmull_s16(vget_high_s16(__s0_645), splat_laneq_s16(__s1_645, __p2_645)); \
- __ret_645; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vpaddq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+ return __ret;
+}
#else
-#define vqdmull_high_laneq_s16(__p0_646, __p1_646, __p2_646) __extension__ ({ \
- int32x4_t __ret_646; \
- int16x8_t __s0_646 = __p0_646; \
- int16x8_t __s1_646 = __p1_646; \
- int16x8_t __rev0_646; __rev0_646 = __builtin_shufflevector(__s0_646, __s0_646, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1_646; __rev1_646 = __builtin_shufflevector(__s1_646, __s1_646, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_646 = __noswap_vqdmull_s16(__noswap_vget_high_s16(__rev0_646), __noswap_splat_laneq_s16(__rev1_646, __p2_646)); \
- __ret_646 = __builtin_shufflevector(__ret_646, __ret_646, 3, 2, 1, 0); \
- __ret_646; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vpaddq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vqdmull_high_n_s32(int32x4_t __p0, int32_t __p1) {
- int64x2_t __ret;
- __ret = vqdmull_n_s32(vget_high_s32(__p0), __p1);
+__ai __attribute__((target("neon"))) float32x4_t vpaddq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
return __ret;
}
#else
-__ai int64x2_t vqdmull_high_n_s32(int32x4_t __p0, int32_t __p1) {
- int64x2_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __noswap_vqdmull_n_s32(__noswap_vget_high_s32(__rev0), __p1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) float32x4_t vpaddq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqdmull_high_n_s16(int16x8_t __p0, int16_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vpaddq_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
- __ret = vqdmull_n_s16(vget_high_s16(__p0), __p1);
+ __ret = (int32x4_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
return __ret;
}
#else
-__ai int32x4_t vqdmull_high_n_s16(int16x8_t __p0, int16_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vpaddq_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vqdmull_n_s16(__noswap_vget_high_s16(__rev0), __p1);
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmulls_lane_s32(__p0_647, __p1_647, __p2_647) __extension__ ({ \
- int64_t __ret_647; \
- int32_t __s0_647 = __p0_647; \
- int32x2_t __s1_647 = __p1_647; \
- __ret_647 = vqdmulls_s32(__s0_647, vget_lane_s32(__s1_647, __p2_647)); \
- __ret_647; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vpaddq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+ return __ret;
+}
#else
-#define vqdmulls_lane_s32(__p0_648, __p1_648, __p2_648) __extension__ ({ \
- int64_t __ret_648; \
- int32_t __s0_648 = __p0_648; \
- int32x2_t __s1_648 = __p1_648; \
- int32x2_t __rev1_648; __rev1_648 = __builtin_shufflevector(__s1_648, __s1_648, 1, 0); \
- __ret_648 = vqdmulls_s32(__s0_648, __noswap_vget_lane_s32(__rev1_648, __p2_648)); \
- __ret_648; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vpaddq_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmullh_lane_s16(__p0_649, __p1_649, __p2_649) __extension__ ({ \
- int32_t __ret_649; \
- int16_t __s0_649 = __p0_649; \
- int16x4_t __s1_649 = __p1_649; \
- __ret_649 = vqdmullh_s16(__s0_649, vget_lane_s16(__s1_649, __p2_649)); \
- __ret_649; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vpaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ return __ret;
+}
#else
-#define vqdmullh_lane_s16(__p0_650, __p1_650, __p2_650) __extension__ ({ \
- int32_t __ret_650; \
- int16_t __s0_650 = __p0_650; \
- int16x4_t __s1_650 = __p1_650; \
- int16x4_t __rev1_650; __rev1_650 = __builtin_shufflevector(__s1_650, __s1_650, 3, 2, 1, 0); \
- __ret_650 = vqdmullh_s16(__s0_650, __noswap_vget_lane_s16(__rev1_650, __p2_650)); \
- __ret_650; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vpaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmulls_laneq_s32(__p0_651, __p1_651, __p2_651) __extension__ ({ \
- int64_t __ret_651; \
- int32_t __s0_651 = __p0_651; \
- int32x4_t __s1_651 = __p1_651; \
- __ret_651 = vqdmulls_s32(__s0_651, vgetq_lane_s32(__s1_651, __p2_651)); \
- __ret_651; \
-})
+__ai __attribute__((target("neon"))) uint64_t vpaddd_u64(uint64x2_t __p0) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vpaddd_u64(__p0);
+ return __ret;
+}
#else
-#define vqdmulls_laneq_s32(__p0_652, __p1_652, __p2_652) __extension__ ({ \
- int64_t __ret_652; \
- int32_t __s0_652 = __p0_652; \
- int32x4_t __s1_652 = __p1_652; \
- int32x4_t __rev1_652; __rev1_652 = __builtin_shufflevector(__s1_652, __s1_652, 3, 2, 1, 0); \
- __ret_652 = vqdmulls_s32(__s0_652, __noswap_vgetq_lane_s32(__rev1_652, __p2_652)); \
- __ret_652; \
-})
+__ai __attribute__((target("neon"))) uint64_t vpaddd_u64(uint64x2_t __p0) {
+ uint64_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (uint64_t) __builtin_neon_vpaddd_u64(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmullh_laneq_s16(__p0_653, __p1_653, __p2_653) __extension__ ({ \
- int32_t __ret_653; \
- int16_t __s0_653 = __p0_653; \
- int16x8_t __s1_653 = __p1_653; \
- __ret_653 = vqdmullh_s16(__s0_653, vgetq_lane_s16(__s1_653, __p2_653)); \
- __ret_653; \
-})
+__ai __attribute__((target("neon"))) float64_t vpaddd_f64(float64x2_t __p0) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vpaddd_f64(__p0);
+ return __ret;
+}
#else
-#define vqdmullh_laneq_s16(__p0_654, __p1_654, __p2_654) __extension__ ({ \
- int32_t __ret_654; \
- int16_t __s0_654 = __p0_654; \
- int16x8_t __s1_654 = __p1_654; \
- int16x8_t __rev1_654; __rev1_654 = __builtin_shufflevector(__s1_654, __s1_654, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_654 = vqdmullh_s16(__s0_654, __noswap_vgetq_lane_s16(__rev1_654, __p2_654)); \
- __ret_654; \
-})
+__ai __attribute__((target("neon"))) float64_t vpaddd_f64(float64x2_t __p0) {
+ float64_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64_t) __builtin_neon_vpaddd_f64(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmull_laneq_s32(__p0_655, __p1_655, __p2_655) __extension__ ({ \
- int64x2_t __ret_655; \
- int32x2_t __s0_655 = __p0_655; \
- int32x4_t __s1_655 = __p1_655; \
- __ret_655 = vqdmull_s32(__s0_655, splat_laneq_s32(__s1_655, __p2_655)); \
- __ret_655; \
-})
+__ai __attribute__((target("neon"))) int64_t vpaddd_s64(int64x2_t __p0) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vpaddd_s64(__p0);
+ return __ret;
+}
#else
-#define vqdmull_laneq_s32(__p0_656, __p1_656, __p2_656) __extension__ ({ \
- int64x2_t __ret_656; \
- int32x2_t __s0_656 = __p0_656; \
- int32x4_t __s1_656 = __p1_656; \
- int32x2_t __rev0_656; __rev0_656 = __builtin_shufflevector(__s0_656, __s0_656, 1, 0); \
- int32x4_t __rev1_656; __rev1_656 = __builtin_shufflevector(__s1_656, __s1_656, 3, 2, 1, 0); \
- __ret_656 = __noswap_vqdmull_s32(__rev0_656, __noswap_splat_laneq_s32(__rev1_656, __p2_656)); \
- __ret_656 = __builtin_shufflevector(__ret_656, __ret_656, 1, 0); \
- __ret_656; \
-})
+__ai __attribute__((target("neon"))) int64_t vpaddd_s64(int64x2_t __p0) {
+ int64_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int64_t) __builtin_neon_vpaddd_s64(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqdmull_laneq_s16(__p0_657, __p1_657, __p2_657) __extension__ ({ \
- int32x4_t __ret_657; \
- int16x4_t __s0_657 = __p0_657; \
- int16x8_t __s1_657 = __p1_657; \
- __ret_657 = vqdmull_s16(__s0_657, splat_laneq_s16(__s1_657, __p2_657)); \
- __ret_657; \
-})
-#else
-#define vqdmull_laneq_s16(__p0_658, __p1_658, __p2_658) __extension__ ({ \
- int32x4_t __ret_658; \
- int16x4_t __s0_658 = __p0_658; \
- int16x8_t __s1_658 = __p1_658; \
- int16x4_t __rev0_658; __rev0_658 = __builtin_shufflevector(__s0_658, __s0_658, 3, 2, 1, 0); \
- int16x8_t __rev1_658; __rev1_658 = __builtin_shufflevector(__s1_658, __s1_658, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_658 = __noswap_vqdmull_s16(__rev0_658, __noswap_splat_laneq_s16(__rev1_658, __p2_658)); \
- __ret_658 = __builtin_shufflevector(__ret_658, __ret_658, 3, 2, 1, 0); \
- __ret_658; \
-})
-#endif
-
-__ai int16_t vqmovns_s32(int32_t __p0) {
- int16_t __ret;
- __ret = (int16_t) __builtin_neon_vqmovns_s32(__p0);
+__ai __attribute__((target("neon"))) float32_t vpadds_f32(float32x2_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vpadds_f32(__p0);
return __ret;
}
-__ai int32_t vqmovnd_s64(int64_t __p0) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vqmovnd_s64(__p0);
+#else
+__ai __attribute__((target("neon"))) float32_t vpadds_f32(float32x2_t __p0) {
+ float32_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float32_t) __builtin_neon_vpadds_f32(__rev0);
return __ret;
}
-__ai int8_t vqmovnh_s16(int16_t __p0) {
- int8_t __ret;
- __ret = (int8_t) __builtin_neon_vqmovnh_s16(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vpmaxq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
return __ret;
}
-__ai uint16_t vqmovns_u32(uint32_t __p0) {
- uint16_t __ret;
- __ret = (uint16_t) __builtin_neon_vqmovns_u32(__p0);
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vpmaxq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai uint32_t vqmovnd_u64(uint64_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vqmovnd_u64(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vpmaxq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
return __ret;
}
-__ai uint8_t vqmovnh_u16(uint16_t __p0) {
- uint8_t __ret;
- __ret = (uint8_t) __builtin_neon_vqmovnh_u16(__p0);
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vpmaxq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
+#endif
+
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vqmovn_high_u32(uint16x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vpmaxq_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint16x8_t __ret;
- __ret = vcombine_u16(__p0, vqmovn_u32(__p1));
+ __ret = (uint16x8_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
return __ret;
}
#else
-__ai uint16x8_t vqmovn_high_u32(uint16x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vpmaxq_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint16x8_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vcombine_u16(__rev0, __noswap_vqmovn_u32(__rev1));
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vqmovn_high_u64(uint32x2_t __p0, uint64x2_t __p1) {
- uint32x4_t __ret;
- __ret = vcombine_u32(__p0, vqmovn_u64(__p1));
+__ai __attribute__((target("neon"))) int8x16_t vpmaxq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
return __ret;
}
#else
-__ai uint32x4_t vqmovn_high_u64(uint32x2_t __p0, uint64x2_t __p1) {
- uint32x4_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __noswap_vcombine_u32(__rev0, __noswap_vqmovn_u64(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int8x16_t vpmaxq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vqmovn_high_u16(uint8x8_t __p0, uint16x8_t __p1) {
- uint8x16_t __ret;
- __ret = vcombine_u8(__p0, vqmovn_u16(__p1));
+__ai __attribute__((target("neon"))) float64x2_t vpmaxq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
return __ret;
}
#else
-__ai uint8x16_t vqmovn_high_u16(uint8x8_t __p0, uint16x8_t __p1) {
- uint8x16_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vcombine_u8(__rev0, __noswap_vqmovn_u16(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float64x2_t vpmaxq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vqmovn_high_s32(int16x4_t __p0, int32x4_t __p1) {
- int16x8_t __ret;
- __ret = vcombine_s16(__p0, vqmovn_s32(__p1));
+__ai __attribute__((target("neon"))) float32x4_t vpmaxq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
return __ret;
}
#else
-__ai int16x8_t vqmovn_high_s32(int16x4_t __p0, int32x4_t __p1) {
- int16x8_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vcombine_s16(__rev0, __noswap_vqmovn_s32(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x4_t vpmaxq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vqmovn_high_s64(int32x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vpmaxq_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
- __ret = vcombine_s32(__p0, vqmovn_s64(__p1));
+ __ret = (int32x4_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
return __ret;
}
#else
-__ai int32x4_t vqmovn_high_s64(int32x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vpmaxq_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __noswap_vcombine_s32(__rev0, __noswap_vqmovn_s64(__rev1));
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vqmovn_high_s16(int8x8_t __p0, int16x8_t __p1) {
- int8x16_t __ret;
- __ret = vcombine_s8(__p0, vqmovn_s16(__p1));
+__ai __attribute__((target("neon"))) int16x8_t vpmaxq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
return __ret;
}
#else
-__ai int8x16_t vqmovn_high_s16(int8x8_t __p0, int16x8_t __p1) {
- int8x16_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16x8_t vpmaxq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vcombine_s8(__rev0, __noswap_vqmovn_s16(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai uint16_t vqmovuns_s32(int32_t __p0) {
- uint16_t __ret;
- __ret = (uint16_t) __builtin_neon_vqmovuns_s32(__p0);
- return __ret;
-}
-__ai uint32_t vqmovund_s64(int64_t __p0) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vqmovund_s64(__p0);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64_t vpmaxqd_f64(float64x2_t __p0) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vpmaxqd_f64(__p0);
return __ret;
}
-__ai uint8_t vqmovunh_s16(int16_t __p0) {
- uint8_t __ret;
- __ret = (uint8_t) __builtin_neon_vqmovunh_s16(__p0);
+#else
+__ai __attribute__((target("neon"))) float64_t vpmaxqd_f64(float64x2_t __p0) {
+ float64_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64_t) __builtin_neon_vpmaxqd_f64(__rev0);
return __ret;
}
+#endif
+
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vqmovun_high_s32(uint16x4_t __p0, int32x4_t __p1) {
- uint16x8_t __ret;
- __ret = vcombine_u16((uint16x4_t)(__p0), vqmovun_s32(__p1));
+__ai __attribute__((target("neon"))) float32_t vpmaxs_f32(float32x2_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vpmaxs_f32(__p0);
return __ret;
}
#else
-__ai uint16x8_t vqmovun_high_s32(uint16x4_t __p0, int32x4_t __p1) {
- uint16x8_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vcombine_u16((uint16x4_t)(__rev0), __noswap_vqmovun_s32(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32_t vpmaxs_f32(float32x2_t __p0) {
+ float32_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float32_t) __builtin_neon_vpmaxs_f32(__rev0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vqmovun_high_s64(uint32x2_t __p0, int64x2_t __p1) {
- uint32x4_t __ret;
- __ret = vcombine_u32((uint32x2_t)(__p0), vqmovun_s64(__p1));
+__ai __attribute__((target("neon"))) float64x2_t vpmaxnmq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vpmaxnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
return __ret;
}
#else
-__ai uint32x4_t vqmovun_high_s64(uint32x2_t __p0, int64x2_t __p1) {
- uint32x4_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __noswap_vcombine_u32((uint32x2_t)(__rev0), __noswap_vqmovun_s64(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float64x2_t vpmaxnmq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vpmaxnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vqmovun_high_s16(uint8x8_t __p0, int16x8_t __p1) {
- uint8x16_t __ret;
- __ret = vcombine_u8((uint8x8_t)(__p0), vqmovun_s16(__p1));
+__ai __attribute__((target("neon"))) float32x4_t vpmaxnmq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vpmaxnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
return __ret;
}
#else
-__ai uint8x16_t vqmovun_high_s16(uint8x8_t __p0, int16x8_t __p1) {
- uint8x16_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vcombine_u8((uint8x8_t)(__rev0), __noswap_vqmovun_s16(__rev1));
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x4_t vpmaxnmq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vpmaxnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vqnegq_s64(int64x2_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vqnegq_v((int8x16_t)__p0, 35);
+__ai __attribute__((target("neon"))) float32x2_t vpmaxnm_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vpmaxnm_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
return __ret;
}
#else
-__ai int64x2_t vqnegq_s64(int64x2_t __p0) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vqnegq_v((int8x16_t)__rev0, 35);
+__ai __attribute__((target("neon"))) float32x2_t vpmaxnm_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vpmaxnm_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-__ai int64x1_t vqneg_s64(int64x1_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t) __builtin_neon_vqneg_v((int8x8_t)__p0, 3);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64_t vpmaxnmqd_f64(float64x2_t __p0) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vpmaxnmqd_f64(__p0);
return __ret;
}
-__ai int8_t vqnegb_s8(int8_t __p0) {
- int8_t __ret;
- __ret = (int8_t) __builtin_neon_vqnegb_s8(__p0);
+#else
+__ai __attribute__((target("neon"))) float64_t vpmaxnmqd_f64(float64x2_t __p0) {
+ float64_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64_t) __builtin_neon_vpmaxnmqd_f64(__rev0);
return __ret;
}
-__ai int32_t vqnegs_s32(int32_t __p0) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vqnegs_s32(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32_t vpmaxnms_f32(float32x2_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vpmaxnms_f32(__p0);
return __ret;
}
-__ai int64_t vqnegd_s64(int64_t __p0) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vqnegd_s64(__p0);
+#else
+__ai __attribute__((target("neon"))) float32_t vpmaxnms_f32(float32x2_t __p0) {
+ float32_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float32_t) __builtin_neon_vpmaxnms_f32(__rev0);
return __ret;
}
-__ai int16_t vqnegh_s16(int16_t __p0) {
- int16_t __ret;
- __ret = (int16_t) __builtin_neon_vqnegh_s16(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vpminq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
return __ret;
}
-__ai int32_t vqrdmulhs_s32(int32_t __p0, int32_t __p1) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vqrdmulhs_s32(__p0, __p1);
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vpminq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai int16_t vqrdmulhh_s16(int16_t __p0, int16_t __p1) {
- int16_t __ret;
- __ret = (int16_t) __builtin_neon_vqrdmulhh_s16(__p0, __p1);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vpminq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
return __ret;
}
-#ifdef __LITTLE_ENDIAN__
-#define vqrdmulhq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x2_t __s1 = __p1; \
- __ret = (int32x4_t) __builtin_neon_vqrdmulhq_lane_v((int8x16_t)__s0, (int8x8_t)__s1, __p2, 2); \
- __ret; \
-})
#else
-#define vqrdmulhq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x2_t __s1 = __p1; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_vqrdmulhq_lane_v((int8x16_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vpminq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmulhq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x4_t __s1 = __p1; \
- __ret = (int16x8_t) __builtin_neon_vqrdmulhq_lane_v((int8x16_t)__s0, (int8x8_t)__s1, __p2, 1); \
- __ret; \
-})
-#else
-#define vqrdmulhq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x4_t __s1 = __p1; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_vqrdmulhq_lane_v((int8x16_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vpminq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vpminq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmulh_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __s1 = __p1; \
- __ret = (int32x2_t) __builtin_neon_vqrdmulh_lane_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vpminq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+ return __ret;
+}
#else
-#define vqrdmulh_lane_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x2_t __s1 = __p1; \
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vqrdmulh_lane_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vpminq_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmulh_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __s1 = __p1; \
- __ret = (int16x4_t) __builtin_neon_vqrdmulh_lane_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vpminq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+ return __ret;
+}
#else
-#define vqrdmulh_lane_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x4_t __s1 = __p1; \
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vqrdmulh_lane_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vpminq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmulhs_lane_s32(__p0_659, __p1_659, __p2_659) __extension__ ({ \
- int32_t __ret_659; \
- int32_t __s0_659 = __p0_659; \
- int32x2_t __s1_659 = __p1_659; \
- __ret_659 = vqrdmulhs_s32(__s0_659, vget_lane_s32(__s1_659, __p2_659)); \
- __ret_659; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vpminq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+ return __ret;
+}
#else
-#define vqrdmulhs_lane_s32(__p0_660, __p1_660, __p2_660) __extension__ ({ \
- int32_t __ret_660; \
- int32_t __s0_660 = __p0_660; \
- int32x2_t __s1_660 = __p1_660; \
- int32x2_t __rev1_660; __rev1_660 = __builtin_shufflevector(__s1_660, __s1_660, 1, 0); \
- __ret_660 = vqrdmulhs_s32(__s0_660, __noswap_vget_lane_s32(__rev1_660, __p2_660)); \
- __ret_660; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vpminq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmulhh_lane_s16(__p0_661, __p1_661, __p2_661) __extension__ ({ \
- int16_t __ret_661; \
- int16_t __s0_661 = __p0_661; \
- int16x4_t __s1_661 = __p1_661; \
- __ret_661 = vqrdmulhh_s16(__s0_661, vget_lane_s16(__s1_661, __p2_661)); \
- __ret_661; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vpminq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+ return __ret;
+}
#else
-#define vqrdmulhh_lane_s16(__p0_662, __p1_662, __p2_662) __extension__ ({ \
- int16_t __ret_662; \
- int16_t __s0_662 = __p0_662; \
- int16x4_t __s1_662 = __p1_662; \
- int16x4_t __rev1_662; __rev1_662 = __builtin_shufflevector(__s1_662, __s1_662, 3, 2, 1, 0); \
- __ret_662 = vqrdmulhh_s16(__s0_662, __noswap_vget_lane_s16(__rev1_662, __p2_662)); \
- __ret_662; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vpminq_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmulhs_laneq_s32(__p0_663, __p1_663, __p2_663) __extension__ ({ \
- int32_t __ret_663; \
- int32_t __s0_663 = __p0_663; \
- int32x4_t __s1_663 = __p1_663; \
- __ret_663 = vqrdmulhs_s32(__s0_663, vgetq_lane_s32(__s1_663, __p2_663)); \
- __ret_663; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vpminq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ return __ret;
+}
#else
-#define vqrdmulhs_laneq_s32(__p0_664, __p1_664, __p2_664) __extension__ ({ \
- int32_t __ret_664; \
- int32_t __s0_664 = __p0_664; \
- int32x4_t __s1_664 = __p1_664; \
- int32x4_t __rev1_664; __rev1_664 = __builtin_shufflevector(__s1_664, __s1_664, 3, 2, 1, 0); \
- __ret_664 = vqrdmulhs_s32(__s0_664, __noswap_vgetq_lane_s32(__rev1_664, __p2_664)); \
- __ret_664; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vpminq_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmulhh_laneq_s16(__p0_665, __p1_665, __p2_665) __extension__ ({ \
- int16_t __ret_665; \
- int16_t __s0_665 = __p0_665; \
- int16x8_t __s1_665 = __p1_665; \
- __ret_665 = vqrdmulhh_s16(__s0_665, vgetq_lane_s16(__s1_665, __p2_665)); \
- __ret_665; \
-})
+__ai __attribute__((target("neon"))) float64_t vpminqd_f64(float64x2_t __p0) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vpminqd_f64(__p0);
+ return __ret;
+}
#else
-#define vqrdmulhh_laneq_s16(__p0_666, __p1_666, __p2_666) __extension__ ({ \
- int16_t __ret_666; \
- int16_t __s0_666 = __p0_666; \
- int16x8_t __s1_666 = __p1_666; \
- int16x8_t __rev1_666; __rev1_666 = __builtin_shufflevector(__s1_666, __s1_666, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_666 = vqrdmulhh_s16(__s0_666, __noswap_vgetq_lane_s16(__rev1_666, __p2_666)); \
- __ret_666; \
-})
+__ai __attribute__((target("neon"))) float64_t vpminqd_f64(float64x2_t __p0) {
+ float64_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64_t) __builtin_neon_vpminqd_f64(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmulhq_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __s1 = __p1; \
- __ret = (int32x4_t) __builtin_neon_vqrdmulhq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32_t vpmins_f32(float32x2_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vpmins_f32(__p0);
+ return __ret;
+}
#else
-#define vqrdmulhq_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x4_t __ret; \
- int32x4_t __s0 = __p0; \
- int32x4_t __s1 = __p1; \
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int32x4_t) __builtin_neon_vqrdmulhq_laneq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32_t vpmins_f32(float32x2_t __p0) {
+ float32_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float32_t) __builtin_neon_vpmins_f32(__rev0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmulhq_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __s1 = __p1; \
- __ret = (int16x8_t) __builtin_neon_vqrdmulhq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vpminnmq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vpminnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+ return __ret;
+}
#else
-#define vqrdmulhq_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x8_t __ret; \
- int16x8_t __s0 = __p0; \
- int16x8_t __s1 = __p1; \
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x8_t) __builtin_neon_vqrdmulhq_laneq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vpminnmq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vpminnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmulh_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x4_t __s1 = __p1; \
- __ret = (int32x2_t) __builtin_neon_vqrdmulh_laneq_v((int8x8_t)__s0, (int8x16_t)__s1, __p2, 2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vpminnmq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vpminnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+ return __ret;
+}
#else
-#define vqrdmulh_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
- int32x2_t __ret; \
- int32x2_t __s0 = __p0; \
- int32x4_t __s1 = __p1; \
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (int32x2_t) __builtin_neon_vqrdmulh_laneq_v((int8x8_t)__rev0, (int8x16_t)__rev1, __p2, 2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vpminnmq_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vpminnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmulh_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x8_t __s1 = __p1; \
- __ret = (int16x4_t) __builtin_neon_vqrdmulh_laneq_v((int8x8_t)__s0, (int8x16_t)__s1, __p2, 1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vpminnm_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vpminnm_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+ return __ret;
+}
#else
-#define vqrdmulh_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
- int16x4_t __ret; \
- int16x4_t __s0 = __p0; \
- int16x8_t __s1 = __p1; \
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (int16x4_t) __builtin_neon_vqrdmulh_laneq_v((int8x8_t)__rev0, (int8x16_t)__rev1, __p2, 1); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vpminnm_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vpminnm_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64_t vpminnmqd_f64(float64x2_t __p0) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vpminnmqd_f64(__p0);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64_t vpminnmqd_f64(float64x2_t __p0) {
+ float64_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64_t) __builtin_neon_vpminnmqd_f64(__rev0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32_t vpminnms_f32(float32x2_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vpminnms_f32(__p0);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32_t vpminnms_f32(float32x2_t __p0) {
+ float32_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float32_t) __builtin_neon_vpminnms_f32(__rev0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqabsq_s64(int64x2_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vqabsq_v((int8x16_t)__p0, 35);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqabsq_s64(int64x2_t __p0) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vqabsq_v((int8x16_t)__rev0, 35);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
-__ai uint8_t vqrshlb_u8(uint8_t __p0, int8_t __p1) {
+__ai __attribute__((target("neon"))) int64x1_t vqabs_s64(int64x1_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t) __builtin_neon_vqabs_v((int8x8_t)__p0, 3);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8_t vqabsb_s8(int8_t __p0) {
+ int8_t __ret;
+ __ret = (int8_t) __builtin_neon_vqabsb_s8(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vqabss_s32(int32_t __p0) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vqabss_s32(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vqabsd_s64(int64_t __p0) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vqabsd_s64(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16_t vqabsh_s16(int16_t __p0) {
+ int16_t __ret;
+ __ret = (int16_t) __builtin_neon_vqabsh_s16(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8_t vqaddb_u8(uint8_t __p0, uint8_t __p1) {
uint8_t __ret;
- __ret = (uint8_t) __builtin_neon_vqrshlb_u8(__p0, __p1);
+ __ret = (uint8_t) __builtin_neon_vqaddb_u8(__p0, __p1);
return __ret;
}
-__ai uint32_t vqrshls_u32(uint32_t __p0, int32_t __p1) {
+__ai __attribute__((target("neon"))) uint32_t vqadds_u32(uint32_t __p0, uint32_t __p1) {
uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vqrshls_u32(__p0, __p1);
+ __ret = (uint32_t) __builtin_neon_vqadds_u32(__p0, __p1);
return __ret;
}
-__ai uint64_t vqrshld_u64(uint64_t __p0, int64_t __p1) {
+__ai __attribute__((target("neon"))) uint64_t vqaddd_u64(uint64_t __p0, uint64_t __p1) {
uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vqrshld_u64(__p0, __p1);
+ __ret = (uint64_t) __builtin_neon_vqaddd_u64(__p0, __p1);
return __ret;
}
-__ai uint16_t vqrshlh_u16(uint16_t __p0, int16_t __p1) {
+__ai __attribute__((target("neon"))) uint16_t vqaddh_u16(uint16_t __p0, uint16_t __p1) {
uint16_t __ret;
- __ret = (uint16_t) __builtin_neon_vqrshlh_u16(__p0, __p1);
+ __ret = (uint16_t) __builtin_neon_vqaddh_u16(__p0, __p1);
return __ret;
}
-__ai int8_t vqrshlb_s8(int8_t __p0, int8_t __p1) {
+__ai __attribute__((target("neon"))) int8_t vqaddb_s8(int8_t __p0, int8_t __p1) {
int8_t __ret;
- __ret = (int8_t) __builtin_neon_vqrshlb_s8(__p0, __p1);
+ __ret = (int8_t) __builtin_neon_vqaddb_s8(__p0, __p1);
return __ret;
}
-__ai int32_t vqrshls_s32(int32_t __p0, int32_t __p1) {
+__ai __attribute__((target("neon"))) int32_t vqadds_s32(int32_t __p0, int32_t __p1) {
int32_t __ret;
- __ret = (int32_t) __builtin_neon_vqrshls_s32(__p0, __p1);
+ __ret = (int32_t) __builtin_neon_vqadds_s32(__p0, __p1);
return __ret;
}
-__ai int64_t vqrshld_s64(int64_t __p0, int64_t __p1) {
+__ai __attribute__((target("neon"))) int64_t vqaddd_s64(int64_t __p0, int64_t __p1) {
int64_t __ret;
- __ret = (int64_t) __builtin_neon_vqrshld_s64(__p0, __p1);
+ __ret = (int64_t) __builtin_neon_vqaddd_s64(__p0, __p1);
return __ret;
}
-__ai int16_t vqrshlh_s16(int16_t __p0, int16_t __p1) {
+__ai __attribute__((target("neon"))) int16_t vqaddh_s16(int16_t __p0, int16_t __p1) {
int16_t __ret;
- __ret = (int16_t) __builtin_neon_vqrshlh_s16(__p0, __p1);
+ __ret = (int16_t) __builtin_neon_vqaddh_s16(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vqdmlals_s32(int64_t __p0, int32_t __p1, int32_t __p2) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vqdmlals_s32(__p0, __p1, __p2);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vqdmlalh_s16(int32_t __p0, int16_t __p1, int16_t __p2) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vqdmlalh_s16(__p0, __p1, __p2);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-#define vqrshrn_high_n_u32(__p0_667, __p1_667, __p2_667) __extension__ ({ \
- uint16x8_t __ret_667; \
- uint16x4_t __s0_667 = __p0_667; \
- uint32x4_t __s1_667 = __p1_667; \
- __ret_667 = (uint16x8_t)(vcombine_u16((uint16x4_t)(__s0_667), (uint16x4_t)(vqrshrn_n_u32(__s1_667, __p2_667)))); \
- __ret_667; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vqdmlal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+ int64x2_t __ret;
+ __ret = vqdmlal_s32(__p0, vget_high_s32(__p1), vget_high_s32(__p2));
+ return __ret;
+}
#else
-#define vqrshrn_high_n_u32(__p0_668, __p1_668, __p2_668) __extension__ ({ \
- uint16x8_t __ret_668; \
- uint16x4_t __s0_668 = __p0_668; \
- uint32x4_t __s1_668 = __p1_668; \
- uint16x4_t __rev0_668; __rev0_668 = __builtin_shufflevector(__s0_668, __s0_668, 3, 2, 1, 0); \
- uint32x4_t __rev1_668; __rev1_668 = __builtin_shufflevector(__s1_668, __s1_668, 3, 2, 1, 0); \
- __ret_668 = (uint16x8_t)(__noswap_vcombine_u16((uint16x4_t)(__rev0_668), (uint16x4_t)(__noswap_vqrshrn_n_u32(__rev1_668, __p2_668)))); \
- __ret_668 = __builtin_shufflevector(__ret_668, __ret_668, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_668; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vqdmlal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __noswap_vqdmlal_s32(__rev0, __noswap_vget_high_s32(__rev1), __noswap_vget_high_s32(__rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrshrn_high_n_u64(__p0_669, __p1_669, __p2_669) __extension__ ({ \
- uint32x4_t __ret_669; \
- uint32x2_t __s0_669 = __p0_669; \
- uint64x2_t __s1_669 = __p1_669; \
- __ret_669 = (uint32x4_t)(vcombine_u32((uint32x2_t)(__s0_669), (uint32x2_t)(vqrshrn_n_u64(__s1_669, __p2_669)))); \
- __ret_669; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vqdmlal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+ int32x4_t __ret;
+ __ret = vqdmlal_s16(__p0, vget_high_s16(__p1), vget_high_s16(__p2));
+ return __ret;
+}
#else
-#define vqrshrn_high_n_u64(__p0_670, __p1_670, __p2_670) __extension__ ({ \
- uint32x4_t __ret_670; \
- uint32x2_t __s0_670 = __p0_670; \
- uint64x2_t __s1_670 = __p1_670; \
- uint32x2_t __rev0_670; __rev0_670 = __builtin_shufflevector(__s0_670, __s0_670, 1, 0); \
- uint64x2_t __rev1_670; __rev1_670 = __builtin_shufflevector(__s1_670, __s1_670, 1, 0); \
- __ret_670 = (uint32x4_t)(__noswap_vcombine_u32((uint32x2_t)(__rev0_670), (uint32x2_t)(__noswap_vqrshrn_n_u64(__rev1_670, __p2_670)))); \
- __ret_670 = __builtin_shufflevector(__ret_670, __ret_670, 3, 2, 1, 0); \
- __ret_670; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vqdmlal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vqdmlal_s16(__rev0, __noswap_vget_high_s16(__rev1), __noswap_vget_high_s16(__rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrshrn_high_n_u16(__p0_671, __p1_671, __p2_671) __extension__ ({ \
- uint8x16_t __ret_671; \
- uint8x8_t __s0_671 = __p0_671; \
- uint16x8_t __s1_671 = __p1_671; \
- __ret_671 = (uint8x16_t)(vcombine_u8((uint8x8_t)(__s0_671), (uint8x8_t)(vqrshrn_n_u16(__s1_671, __p2_671)))); \
- __ret_671; \
+#define vqdmlal_high_lane_s32(__p0_628, __p1_628, __p2_628, __p3_628) __extension__ ({ \
+ int64x2_t __ret_628; \
+ int64x2_t __s0_628 = __p0_628; \
+ int32x4_t __s1_628 = __p1_628; \
+ int32x2_t __s2_628 = __p2_628; \
+ __ret_628 = vqdmlal_s32(__s0_628, vget_high_s32(__s1_628), splat_lane_s32(__s2_628, __p3_628)); \
+ __ret_628; \
})
#else
-#define vqrshrn_high_n_u16(__p0_672, __p1_672, __p2_672) __extension__ ({ \
- uint8x16_t __ret_672; \
- uint8x8_t __s0_672 = __p0_672; \
- uint16x8_t __s1_672 = __p1_672; \
- uint8x8_t __rev0_672; __rev0_672 = __builtin_shufflevector(__s0_672, __s0_672, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x8_t __rev1_672; __rev1_672 = __builtin_shufflevector(__s1_672, __s1_672, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_672 = (uint8x16_t)(__noswap_vcombine_u8((uint8x8_t)(__rev0_672), (uint8x8_t)(__noswap_vqrshrn_n_u16(__rev1_672, __p2_672)))); \
- __ret_672 = __builtin_shufflevector(__ret_672, __ret_672, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_672; \
+#define vqdmlal_high_lane_s32(__p0_629, __p1_629, __p2_629, __p3_629) __extension__ ({ \
+ int64x2_t __ret_629; \
+ int64x2_t __s0_629 = __p0_629; \
+ int32x4_t __s1_629 = __p1_629; \
+ int32x2_t __s2_629 = __p2_629; \
+ int64x2_t __rev0_629; __rev0_629 = __builtin_shufflevector(__s0_629, __s0_629, 1, 0); \
+ int32x4_t __rev1_629; __rev1_629 = __builtin_shufflevector(__s1_629, __s1_629, 3, 2, 1, 0); \
+ int32x2_t __rev2_629; __rev2_629 = __builtin_shufflevector(__s2_629, __s2_629, 1, 0); \
+ __ret_629 = __noswap_vqdmlal_s32(__rev0_629, __noswap_vget_high_s32(__rev1_629), __noswap_splat_lane_s32(__rev2_629, __p3_629)); \
+ __ret_629 = __builtin_shufflevector(__ret_629, __ret_629, 1, 0); \
+ __ret_629; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrshrn_high_n_s32(__p0_673, __p1_673, __p2_673) __extension__ ({ \
- int16x8_t __ret_673; \
- int16x4_t __s0_673 = __p0_673; \
- int32x4_t __s1_673 = __p1_673; \
- __ret_673 = (int16x8_t)(vcombine_s16((int16x4_t)(__s0_673), (int16x4_t)(vqrshrn_n_s32(__s1_673, __p2_673)))); \
- __ret_673; \
+#define vqdmlal_high_lane_s16(__p0_630, __p1_630, __p2_630, __p3_630) __extension__ ({ \
+ int32x4_t __ret_630; \
+ int32x4_t __s0_630 = __p0_630; \
+ int16x8_t __s1_630 = __p1_630; \
+ int16x4_t __s2_630 = __p2_630; \
+ __ret_630 = vqdmlal_s16(__s0_630, vget_high_s16(__s1_630), splat_lane_s16(__s2_630, __p3_630)); \
+ __ret_630; \
})
#else
-#define vqrshrn_high_n_s32(__p0_674, __p1_674, __p2_674) __extension__ ({ \
- int16x8_t __ret_674; \
- int16x4_t __s0_674 = __p0_674; \
- int32x4_t __s1_674 = __p1_674; \
- int16x4_t __rev0_674; __rev0_674 = __builtin_shufflevector(__s0_674, __s0_674, 3, 2, 1, 0); \
- int32x4_t __rev1_674; __rev1_674 = __builtin_shufflevector(__s1_674, __s1_674, 3, 2, 1, 0); \
- __ret_674 = (int16x8_t)(__noswap_vcombine_s16((int16x4_t)(__rev0_674), (int16x4_t)(__noswap_vqrshrn_n_s32(__rev1_674, __p2_674)))); \
- __ret_674 = __builtin_shufflevector(__ret_674, __ret_674, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_674; \
+#define vqdmlal_high_lane_s16(__p0_631, __p1_631, __p2_631, __p3_631) __extension__ ({ \
+ int32x4_t __ret_631; \
+ int32x4_t __s0_631 = __p0_631; \
+ int16x8_t __s1_631 = __p1_631; \
+ int16x4_t __s2_631 = __p2_631; \
+ int32x4_t __rev0_631; __rev0_631 = __builtin_shufflevector(__s0_631, __s0_631, 3, 2, 1, 0); \
+ int16x8_t __rev1_631; __rev1_631 = __builtin_shufflevector(__s1_631, __s1_631, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x4_t __rev2_631; __rev2_631 = __builtin_shufflevector(__s2_631, __s2_631, 3, 2, 1, 0); \
+ __ret_631 = __noswap_vqdmlal_s16(__rev0_631, __noswap_vget_high_s16(__rev1_631), __noswap_splat_lane_s16(__rev2_631, __p3_631)); \
+ __ret_631 = __builtin_shufflevector(__ret_631, __ret_631, 3, 2, 1, 0); \
+ __ret_631; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrshrn_high_n_s64(__p0_675, __p1_675, __p2_675) __extension__ ({ \
- int32x4_t __ret_675; \
- int32x2_t __s0_675 = __p0_675; \
- int64x2_t __s1_675 = __p1_675; \
- __ret_675 = (int32x4_t)(vcombine_s32((int32x2_t)(__s0_675), (int32x2_t)(vqrshrn_n_s64(__s1_675, __p2_675)))); \
- __ret_675; \
+#define vqdmlal_high_laneq_s32(__p0_632, __p1_632, __p2_632, __p3_632) __extension__ ({ \
+ int64x2_t __ret_632; \
+ int64x2_t __s0_632 = __p0_632; \
+ int32x4_t __s1_632 = __p1_632; \
+ int32x4_t __s2_632 = __p2_632; \
+ __ret_632 = vqdmlal_s32(__s0_632, vget_high_s32(__s1_632), splat_laneq_s32(__s2_632, __p3_632)); \
+ __ret_632; \
})
#else
-#define vqrshrn_high_n_s64(__p0_676, __p1_676, __p2_676) __extension__ ({ \
- int32x4_t __ret_676; \
- int32x2_t __s0_676 = __p0_676; \
- int64x2_t __s1_676 = __p1_676; \
- int32x2_t __rev0_676; __rev0_676 = __builtin_shufflevector(__s0_676, __s0_676, 1, 0); \
- int64x2_t __rev1_676; __rev1_676 = __builtin_shufflevector(__s1_676, __s1_676, 1, 0); \
- __ret_676 = (int32x4_t)(__noswap_vcombine_s32((int32x2_t)(__rev0_676), (int32x2_t)(__noswap_vqrshrn_n_s64(__rev1_676, __p2_676)))); \
- __ret_676 = __builtin_shufflevector(__ret_676, __ret_676, 3, 2, 1, 0); \
- __ret_676; \
+#define vqdmlal_high_laneq_s32(__p0_633, __p1_633, __p2_633, __p3_633) __extension__ ({ \
+ int64x2_t __ret_633; \
+ int64x2_t __s0_633 = __p0_633; \
+ int32x4_t __s1_633 = __p1_633; \
+ int32x4_t __s2_633 = __p2_633; \
+ int64x2_t __rev0_633; __rev0_633 = __builtin_shufflevector(__s0_633, __s0_633, 1, 0); \
+ int32x4_t __rev1_633; __rev1_633 = __builtin_shufflevector(__s1_633, __s1_633, 3, 2, 1, 0); \
+ int32x4_t __rev2_633; __rev2_633 = __builtin_shufflevector(__s2_633, __s2_633, 3, 2, 1, 0); \
+ __ret_633 = __noswap_vqdmlal_s32(__rev0_633, __noswap_vget_high_s32(__rev1_633), __noswap_splat_laneq_s32(__rev2_633, __p3_633)); \
+ __ret_633 = __builtin_shufflevector(__ret_633, __ret_633, 1, 0); \
+ __ret_633; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrshrn_high_n_s16(__p0_677, __p1_677, __p2_677) __extension__ ({ \
- int8x16_t __ret_677; \
- int8x8_t __s0_677 = __p0_677; \
- int16x8_t __s1_677 = __p1_677; \
- __ret_677 = (int8x16_t)(vcombine_s8((int8x8_t)(__s0_677), (int8x8_t)(vqrshrn_n_s16(__s1_677, __p2_677)))); \
- __ret_677; \
+#define vqdmlal_high_laneq_s16(__p0_634, __p1_634, __p2_634, __p3_634) __extension__ ({ \
+ int32x4_t __ret_634; \
+ int32x4_t __s0_634 = __p0_634; \
+ int16x8_t __s1_634 = __p1_634; \
+ int16x8_t __s2_634 = __p2_634; \
+ __ret_634 = vqdmlal_s16(__s0_634, vget_high_s16(__s1_634), splat_laneq_s16(__s2_634, __p3_634)); \
+ __ret_634; \
})
#else
-#define vqrshrn_high_n_s16(__p0_678, __p1_678, __p2_678) __extension__ ({ \
- int8x16_t __ret_678; \
- int8x8_t __s0_678 = __p0_678; \
- int16x8_t __s1_678 = __p1_678; \
- int8x8_t __rev0_678; __rev0_678 = __builtin_shufflevector(__s0_678, __s0_678, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1_678; __rev1_678 = __builtin_shufflevector(__s1_678, __s1_678, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_678 = (int8x16_t)(__noswap_vcombine_s8((int8x8_t)(__rev0_678), (int8x8_t)(__noswap_vqrshrn_n_s16(__rev1_678, __p2_678)))); \
- __ret_678 = __builtin_shufflevector(__ret_678, __ret_678, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_678; \
+#define vqdmlal_high_laneq_s16(__p0_635, __p1_635, __p2_635, __p3_635) __extension__ ({ \
+ int32x4_t __ret_635; \
+ int32x4_t __s0_635 = __p0_635; \
+ int16x8_t __s1_635 = __p1_635; \
+ int16x8_t __s2_635 = __p2_635; \
+ int32x4_t __rev0_635; __rev0_635 = __builtin_shufflevector(__s0_635, __s0_635, 3, 2, 1, 0); \
+ int16x8_t __rev1_635; __rev1_635 = __builtin_shufflevector(__s1_635, __s1_635, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev2_635; __rev2_635 = __builtin_shufflevector(__s2_635, __s2_635, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_635 = __noswap_vqdmlal_s16(__rev0_635, __noswap_vget_high_s16(__rev1_635), __noswap_splat_laneq_s16(__rev2_635, __p3_635)); \
+ __ret_635 = __builtin_shufflevector(__ret_635, __ret_635, 3, 2, 1, 0); \
+ __ret_635; \
})
#endif
-#define vqrshrns_n_u32(__p0, __p1) __extension__ ({ \
- uint16_t __ret; \
- uint32_t __s0 = __p0; \
- __ret = (uint16_t) __builtin_neon_vqrshrns_n_u32(__s0, __p1); \
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqdmlal_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
+ int64x2_t __ret;
+ __ret = vqdmlal_n_s32(__p0, vget_high_s32(__p1), __p2);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqdmlal_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __noswap_vqdmlal_n_s32(__rev0, __noswap_vget_high_s32(__rev1), __p2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqdmlal_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
+ int32x4_t __ret;
+ __ret = vqdmlal_n_s16(__p0, vget_high_s16(__p1), __p2);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqdmlal_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vqdmlal_n_s16(__rev0, __noswap_vget_high_s16(__rev1), __p2);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlals_lane_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ int64_t __ret; \
+ int64_t __s0 = __p0; \
+ int32_t __s1 = __p1; \
+ int32x2_t __s2 = __p2; \
+ __ret = (int64_t) __builtin_neon_vqdmlals_lane_s32(__s0, __s1, __s2, __p3); \
__ret; \
})
-#define vqrshrnd_n_u64(__p0, __p1) __extension__ ({ \
- uint32_t __ret; \
- uint64_t __s0 = __p0; \
- __ret = (uint32_t) __builtin_neon_vqrshrnd_n_u64(__s0, __p1); \
+#else
+#define vqdmlals_lane_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ int64_t __ret; \
+ int64_t __s0 = __p0; \
+ int32_t __s1 = __p1; \
+ int32x2_t __s2 = __p2; \
+ int32x2_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
+ __ret = (int64_t) __builtin_neon_vqdmlals_lane_s32(__s0, __s1, __rev2, __p3); \
__ret; \
})
-#define vqrshrnh_n_u16(__p0, __p1) __extension__ ({ \
- uint8_t __ret; \
- uint16_t __s0 = __p0; \
- __ret = (uint8_t) __builtin_neon_vqrshrnh_n_u16(__s0, __p1); \
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlalh_lane_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ int32_t __ret; \
+ int32_t __s0 = __p0; \
+ int16_t __s1 = __p1; \
+ int16x4_t __s2 = __p2; \
+ __ret = (int32_t) __builtin_neon_vqdmlalh_lane_s16(__s0, __s1, __s2, __p3); \
__ret; \
})
-#define vqrshrns_n_s32(__p0, __p1) __extension__ ({ \
- int16_t __ret; \
+#else
+#define vqdmlalh_lane_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ int32_t __ret; \
int32_t __s0 = __p0; \
- __ret = (int16_t) __builtin_neon_vqrshrns_n_s32(__s0, __p1); \
+ int16_t __s1 = __p1; \
+ int16x4_t __s2 = __p2; \
+ int16x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+ __ret = (int32_t) __builtin_neon_vqdmlalh_lane_s16(__s0, __s1, __rev2, __p3); \
__ret; \
})
-#define vqrshrnd_n_s64(__p0, __p1) __extension__ ({ \
- int32_t __ret; \
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlals_laneq_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ int64_t __ret; \
int64_t __s0 = __p0; \
- __ret = (int32_t) __builtin_neon_vqrshrnd_n_s64(__s0, __p1); \
+ int32_t __s1 = __p1; \
+ int32x4_t __s2 = __p2; \
+ __ret = (int64_t) __builtin_neon_vqdmlals_laneq_s32(__s0, __s1, __s2, __p3); \
__ret; \
})
-#define vqrshrnh_n_s16(__p0, __p1) __extension__ ({ \
- int8_t __ret; \
- int16_t __s0 = __p0; \
- __ret = (int8_t) __builtin_neon_vqrshrnh_n_s16(__s0, __p1); \
+#else
+#define vqdmlals_laneq_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ int64_t __ret; \
+ int64_t __s0 = __p0; \
+ int32_t __s1 = __p1; \
+ int32x4_t __s2 = __p2; \
+ int32x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+ __ret = (int64_t) __builtin_neon_vqdmlals_laneq_s32(__s0, __s1, __rev2, __p3); \
__ret; \
})
+#endif
+
#ifdef __LITTLE_ENDIAN__
-#define vqrshrun_high_n_s32(__p0_679, __p1_679, __p2_679) __extension__ ({ \
- int16x8_t __ret_679; \
- int16x4_t __s0_679 = __p0_679; \
- int32x4_t __s1_679 = __p1_679; \
- __ret_679 = (int16x8_t)(vcombine_s16((int16x4_t)(__s0_679), (int16x4_t)(vqrshrun_n_s32(__s1_679, __p2_679)))); \
- __ret_679; \
+#define vqdmlalh_laneq_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ int32_t __ret; \
+ int32_t __s0 = __p0; \
+ int16_t __s1 = __p1; \
+ int16x8_t __s2 = __p2; \
+ __ret = (int32_t) __builtin_neon_vqdmlalh_laneq_s16(__s0, __s1, __s2, __p3); \
+ __ret; \
})
#else
-#define vqrshrun_high_n_s32(__p0_680, __p1_680, __p2_680) __extension__ ({ \
- int16x8_t __ret_680; \
- int16x4_t __s0_680 = __p0_680; \
- int32x4_t __s1_680 = __p1_680; \
- int16x4_t __rev0_680; __rev0_680 = __builtin_shufflevector(__s0_680, __s0_680, 3, 2, 1, 0); \
- int32x4_t __rev1_680; __rev1_680 = __builtin_shufflevector(__s1_680, __s1_680, 3, 2, 1, 0); \
- __ret_680 = (int16x8_t)(__noswap_vcombine_s16((int16x4_t)(__rev0_680), (int16x4_t)(__noswap_vqrshrun_n_s32(__rev1_680, __p2_680)))); \
- __ret_680 = __builtin_shufflevector(__ret_680, __ret_680, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_680; \
+#define vqdmlalh_laneq_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ int32_t __ret; \
+ int32_t __s0 = __p0; \
+ int16_t __s1 = __p1; \
+ int16x8_t __s2 = __p2; \
+ int16x8_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int32_t) __builtin_neon_vqdmlalh_laneq_s16(__s0, __s1, __rev2, __p3); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrshrun_high_n_s64(__p0_681, __p1_681, __p2_681) __extension__ ({ \
- int32x4_t __ret_681; \
- int32x2_t __s0_681 = __p0_681; \
- int64x2_t __s1_681 = __p1_681; \
- __ret_681 = (int32x4_t)(vcombine_s32((int32x2_t)(__s0_681), (int32x2_t)(vqrshrun_n_s64(__s1_681, __p2_681)))); \
- __ret_681; \
+#define vqdmlal_laneq_s32(__p0_636, __p1_636, __p2_636, __p3_636) __extension__ ({ \
+ int64x2_t __ret_636; \
+ int64x2_t __s0_636 = __p0_636; \
+ int32x2_t __s1_636 = __p1_636; \
+ int32x4_t __s2_636 = __p2_636; \
+ __ret_636 = vqdmlal_s32(__s0_636, __s1_636, splat_laneq_s32(__s2_636, __p3_636)); \
+ __ret_636; \
})
#else
-#define vqrshrun_high_n_s64(__p0_682, __p1_682, __p2_682) __extension__ ({ \
- int32x4_t __ret_682; \
- int32x2_t __s0_682 = __p0_682; \
- int64x2_t __s1_682 = __p1_682; \
- int32x2_t __rev0_682; __rev0_682 = __builtin_shufflevector(__s0_682, __s0_682, 1, 0); \
- int64x2_t __rev1_682; __rev1_682 = __builtin_shufflevector(__s1_682, __s1_682, 1, 0); \
- __ret_682 = (int32x4_t)(__noswap_vcombine_s32((int32x2_t)(__rev0_682), (int32x2_t)(__noswap_vqrshrun_n_s64(__rev1_682, __p2_682)))); \
- __ret_682 = __builtin_shufflevector(__ret_682, __ret_682, 3, 2, 1, 0); \
- __ret_682; \
+#define vqdmlal_laneq_s32(__p0_637, __p1_637, __p2_637, __p3_637) __extension__ ({ \
+ int64x2_t __ret_637; \
+ int64x2_t __s0_637 = __p0_637; \
+ int32x2_t __s1_637 = __p1_637; \
+ int32x4_t __s2_637 = __p2_637; \
+ int64x2_t __rev0_637; __rev0_637 = __builtin_shufflevector(__s0_637, __s0_637, 1, 0); \
+ int32x2_t __rev1_637; __rev1_637 = __builtin_shufflevector(__s1_637, __s1_637, 1, 0); \
+ int32x4_t __rev2_637; __rev2_637 = __builtin_shufflevector(__s2_637, __s2_637, 3, 2, 1, 0); \
+ __ret_637 = __noswap_vqdmlal_s32(__rev0_637, __rev1_637, __noswap_splat_laneq_s32(__rev2_637, __p3_637)); \
+ __ret_637 = __builtin_shufflevector(__ret_637, __ret_637, 1, 0); \
+ __ret_637; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrshrun_high_n_s16(__p0_683, __p1_683, __p2_683) __extension__ ({ \
- int8x16_t __ret_683; \
- int8x8_t __s0_683 = __p0_683; \
- int16x8_t __s1_683 = __p1_683; \
- __ret_683 = (int8x16_t)(vcombine_s8((int8x8_t)(__s0_683), (int8x8_t)(vqrshrun_n_s16(__s1_683, __p2_683)))); \
- __ret_683; \
+#define vqdmlal_laneq_s16(__p0_638, __p1_638, __p2_638, __p3_638) __extension__ ({ \
+ int32x4_t __ret_638; \
+ int32x4_t __s0_638 = __p0_638; \
+ int16x4_t __s1_638 = __p1_638; \
+ int16x8_t __s2_638 = __p2_638; \
+ __ret_638 = vqdmlal_s16(__s0_638, __s1_638, splat_laneq_s16(__s2_638, __p3_638)); \
+ __ret_638; \
})
#else
-#define vqrshrun_high_n_s16(__p0_684, __p1_684, __p2_684) __extension__ ({ \
- int8x16_t __ret_684; \
- int8x8_t __s0_684 = __p0_684; \
- int16x8_t __s1_684 = __p1_684; \
- int8x8_t __rev0_684; __rev0_684 = __builtin_shufflevector(__s0_684, __s0_684, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1_684; __rev1_684 = __builtin_shufflevector(__s1_684, __s1_684, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_684 = (int8x16_t)(__noswap_vcombine_s8((int8x8_t)(__rev0_684), (int8x8_t)(__noswap_vqrshrun_n_s16(__rev1_684, __p2_684)))); \
- __ret_684 = __builtin_shufflevector(__ret_684, __ret_684, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_684; \
+#define vqdmlal_laneq_s16(__p0_639, __p1_639, __p2_639, __p3_639) __extension__ ({ \
+ int32x4_t __ret_639; \
+ int32x4_t __s0_639 = __p0_639; \
+ int16x4_t __s1_639 = __p1_639; \
+ int16x8_t __s2_639 = __p2_639; \
+ int32x4_t __rev0_639; __rev0_639 = __builtin_shufflevector(__s0_639, __s0_639, 3, 2, 1, 0); \
+ int16x4_t __rev1_639; __rev1_639 = __builtin_shufflevector(__s1_639, __s1_639, 3, 2, 1, 0); \
+ int16x8_t __rev2_639; __rev2_639 = __builtin_shufflevector(__s2_639, __s2_639, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_639 = __noswap_vqdmlal_s16(__rev0_639, __rev1_639, __noswap_splat_laneq_s16(__rev2_639, __p3_639)); \
+ __ret_639 = __builtin_shufflevector(__ret_639, __ret_639, 3, 2, 1, 0); \
+ __ret_639; \
})
#endif
-#define vqrshruns_n_s32(__p0, __p1) __extension__ ({ \
- int16_t __ret; \
- int32_t __s0 = __p0; \
- __ret = (int16_t) __builtin_neon_vqrshruns_n_s32(__s0, __p1); \
- __ret; \
-})
-#define vqrshrund_n_s64(__p0, __p1) __extension__ ({ \
- int32_t __ret; \
- int64_t __s0 = __p0; \
- __ret = (int32_t) __builtin_neon_vqrshrund_n_s64(__s0, __p1); \
- __ret; \
-})
-#define vqrshrunh_n_s16(__p0, __p1) __extension__ ({ \
- int8_t __ret; \
- int16_t __s0 = __p0; \
- __ret = (int8_t) __builtin_neon_vqrshrunh_n_s16(__s0, __p1); \
- __ret; \
-})
-__ai uint8_t vqshlb_u8(uint8_t __p0, int8_t __p1) {
- uint8_t __ret;
- __ret = (uint8_t) __builtin_neon_vqshlb_u8(__p0, __p1);
- return __ret;
-}
-__ai uint32_t vqshls_u32(uint32_t __p0, int32_t __p1) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vqshls_u32(__p0, __p1);
- return __ret;
-}
-__ai uint64_t vqshld_u64(uint64_t __p0, int64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vqshld_u64(__p0, __p1);
+__ai __attribute__((target("neon"))) int64_t vqdmlsls_s32(int64_t __p0, int32_t __p1, int32_t __p2) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vqdmlsls_s32(__p0, __p1, __p2);
return __ret;
}
-__ai uint16_t vqshlh_u16(uint16_t __p0, int16_t __p1) {
- uint16_t __ret;
- __ret = (uint16_t) __builtin_neon_vqshlh_u16(__p0, __p1);
+__ai __attribute__((target("neon"))) int32_t vqdmlslh_s16(int32_t __p0, int16_t __p1, int16_t __p2) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vqdmlslh_s16(__p0, __p1, __p2);
return __ret;
}
-__ai int8_t vqshlb_s8(int8_t __p0, int8_t __p1) {
- int8_t __ret;
- __ret = (int8_t) __builtin_neon_vqshlb_s8(__p0, __p1);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqdmlsl_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+ int64x2_t __ret;
+ __ret = vqdmlsl_s32(__p0, vget_high_s32(__p1), vget_high_s32(__p2));
return __ret;
}
-__ai int32_t vqshls_s32(int32_t __p0, int32_t __p1) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vqshls_s32(__p0, __p1);
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqdmlsl_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __noswap_vqdmlsl_s32(__rev0, __noswap_vget_high_s32(__rev1), __noswap_vget_high_s32(__rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai int64_t vqshld_s64(int64_t __p0, int64_t __p1) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vqshld_s64(__p0, __p1);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqdmlsl_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+ int32x4_t __ret;
+ __ret = vqdmlsl_s16(__p0, vget_high_s16(__p1), vget_high_s16(__p2));
return __ret;
}
-__ai int16_t vqshlh_s16(int16_t __p0, int16_t __p1) {
- int16_t __ret;
- __ret = (int16_t) __builtin_neon_vqshlh_s16(__p0, __p1);
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqdmlsl_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vqdmlsl_s16(__rev0, __noswap_vget_high_s16(__rev1), __noswap_vget_high_s16(__rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-#define vqshlb_n_u8(__p0, __p1) __extension__ ({ \
- uint8_t __ret; \
- uint8_t __s0 = __p0; \
- __ret = (uint8_t) __builtin_neon_vqshlb_n_u8(__s0, __p1); \
- __ret; \
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlsl_high_lane_s32(__p0_640, __p1_640, __p2_640, __p3_640) __extension__ ({ \
+ int64x2_t __ret_640; \
+ int64x2_t __s0_640 = __p0_640; \
+ int32x4_t __s1_640 = __p1_640; \
+ int32x2_t __s2_640 = __p2_640; \
+ __ret_640 = vqdmlsl_s32(__s0_640, vget_high_s32(__s1_640), splat_lane_s32(__s2_640, __p3_640)); \
+ __ret_640; \
})
-#define vqshls_n_u32(__p0, __p1) __extension__ ({ \
- uint32_t __ret; \
- uint32_t __s0 = __p0; \
- __ret = (uint32_t) __builtin_neon_vqshls_n_u32(__s0, __p1); \
- __ret; \
+#else
+#define vqdmlsl_high_lane_s32(__p0_641, __p1_641, __p2_641, __p3_641) __extension__ ({ \
+ int64x2_t __ret_641; \
+ int64x2_t __s0_641 = __p0_641; \
+ int32x4_t __s1_641 = __p1_641; \
+ int32x2_t __s2_641 = __p2_641; \
+ int64x2_t __rev0_641; __rev0_641 = __builtin_shufflevector(__s0_641, __s0_641, 1, 0); \
+ int32x4_t __rev1_641; __rev1_641 = __builtin_shufflevector(__s1_641, __s1_641, 3, 2, 1, 0); \
+ int32x2_t __rev2_641; __rev2_641 = __builtin_shufflevector(__s2_641, __s2_641, 1, 0); \
+ __ret_641 = __noswap_vqdmlsl_s32(__rev0_641, __noswap_vget_high_s32(__rev1_641), __noswap_splat_lane_s32(__rev2_641, __p3_641)); \
+ __ret_641 = __builtin_shufflevector(__ret_641, __ret_641, 1, 0); \
+ __ret_641; \
})
-#define vqshld_n_u64(__p0, __p1) __extension__ ({ \
- uint64_t __ret; \
- uint64_t __s0 = __p0; \
- __ret = (uint64_t) __builtin_neon_vqshld_n_u64(__s0, __p1); \
- __ret; \
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlsl_high_lane_s16(__p0_642, __p1_642, __p2_642, __p3_642) __extension__ ({ \
+ int32x4_t __ret_642; \
+ int32x4_t __s0_642 = __p0_642; \
+ int16x8_t __s1_642 = __p1_642; \
+ int16x4_t __s2_642 = __p2_642; \
+ __ret_642 = vqdmlsl_s16(__s0_642, vget_high_s16(__s1_642), splat_lane_s16(__s2_642, __p3_642)); \
+ __ret_642; \
})
-#define vqshlh_n_u16(__p0, __p1) __extension__ ({ \
- uint16_t __ret; \
- uint16_t __s0 = __p0; \
- __ret = (uint16_t) __builtin_neon_vqshlh_n_u16(__s0, __p1); \
- __ret; \
+#else
+#define vqdmlsl_high_lane_s16(__p0_643, __p1_643, __p2_643, __p3_643) __extension__ ({ \
+ int32x4_t __ret_643; \
+ int32x4_t __s0_643 = __p0_643; \
+ int16x8_t __s1_643 = __p1_643; \
+ int16x4_t __s2_643 = __p2_643; \
+ int32x4_t __rev0_643; __rev0_643 = __builtin_shufflevector(__s0_643, __s0_643, 3, 2, 1, 0); \
+ int16x8_t __rev1_643; __rev1_643 = __builtin_shufflevector(__s1_643, __s1_643, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x4_t __rev2_643; __rev2_643 = __builtin_shufflevector(__s2_643, __s2_643, 3, 2, 1, 0); \
+ __ret_643 = __noswap_vqdmlsl_s16(__rev0_643, __noswap_vget_high_s16(__rev1_643), __noswap_splat_lane_s16(__rev2_643, __p3_643)); \
+ __ret_643 = __builtin_shufflevector(__ret_643, __ret_643, 3, 2, 1, 0); \
+ __ret_643; \
})
-#define vqshlb_n_s8(__p0, __p1) __extension__ ({ \
- int8_t __ret; \
- int8_t __s0 = __p0; \
- __ret = (int8_t) __builtin_neon_vqshlb_n_s8(__s0, __p1); \
- __ret; \
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlsl_high_laneq_s32(__p0_644, __p1_644, __p2_644, __p3_644) __extension__ ({ \
+ int64x2_t __ret_644; \
+ int64x2_t __s0_644 = __p0_644; \
+ int32x4_t __s1_644 = __p1_644; \
+ int32x4_t __s2_644 = __p2_644; \
+ __ret_644 = vqdmlsl_s32(__s0_644, vget_high_s32(__s1_644), splat_laneq_s32(__s2_644, __p3_644)); \
+ __ret_644; \
})
-#define vqshls_n_s32(__p0, __p1) __extension__ ({ \
- int32_t __ret; \
- int32_t __s0 = __p0; \
- __ret = (int32_t) __builtin_neon_vqshls_n_s32(__s0, __p1); \
- __ret; \
+#else
+#define vqdmlsl_high_laneq_s32(__p0_645, __p1_645, __p2_645, __p3_645) __extension__ ({ \
+ int64x2_t __ret_645; \
+ int64x2_t __s0_645 = __p0_645; \
+ int32x4_t __s1_645 = __p1_645; \
+ int32x4_t __s2_645 = __p2_645; \
+ int64x2_t __rev0_645; __rev0_645 = __builtin_shufflevector(__s0_645, __s0_645, 1, 0); \
+ int32x4_t __rev1_645; __rev1_645 = __builtin_shufflevector(__s1_645, __s1_645, 3, 2, 1, 0); \
+ int32x4_t __rev2_645; __rev2_645 = __builtin_shufflevector(__s2_645, __s2_645, 3, 2, 1, 0); \
+ __ret_645 = __noswap_vqdmlsl_s32(__rev0_645, __noswap_vget_high_s32(__rev1_645), __noswap_splat_laneq_s32(__rev2_645, __p3_645)); \
+ __ret_645 = __builtin_shufflevector(__ret_645, __ret_645, 1, 0); \
+ __ret_645; \
})
-#define vqshld_n_s64(__p0, __p1) __extension__ ({ \
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlsl_high_laneq_s16(__p0_646, __p1_646, __p2_646, __p3_646) __extension__ ({ \
+ int32x4_t __ret_646; \
+ int32x4_t __s0_646 = __p0_646; \
+ int16x8_t __s1_646 = __p1_646; \
+ int16x8_t __s2_646 = __p2_646; \
+ __ret_646 = vqdmlsl_s16(__s0_646, vget_high_s16(__s1_646), splat_laneq_s16(__s2_646, __p3_646)); \
+ __ret_646; \
+})
+#else
+#define vqdmlsl_high_laneq_s16(__p0_647, __p1_647, __p2_647, __p3_647) __extension__ ({ \
+ int32x4_t __ret_647; \
+ int32x4_t __s0_647 = __p0_647; \
+ int16x8_t __s1_647 = __p1_647; \
+ int16x8_t __s2_647 = __p2_647; \
+ int32x4_t __rev0_647; __rev0_647 = __builtin_shufflevector(__s0_647, __s0_647, 3, 2, 1, 0); \
+ int16x8_t __rev1_647; __rev1_647 = __builtin_shufflevector(__s1_647, __s1_647, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev2_647; __rev2_647 = __builtin_shufflevector(__s2_647, __s2_647, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_647 = __noswap_vqdmlsl_s16(__rev0_647, __noswap_vget_high_s16(__rev1_647), __noswap_splat_laneq_s16(__rev2_647, __p3_647)); \
+ __ret_647 = __builtin_shufflevector(__ret_647, __ret_647, 3, 2, 1, 0); \
+ __ret_647; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqdmlsl_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
+ int64x2_t __ret;
+ __ret = vqdmlsl_n_s32(__p0, vget_high_s32(__p1), __p2);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqdmlsl_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __noswap_vqdmlsl_n_s32(__rev0, __noswap_vget_high_s32(__rev1), __p2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqdmlsl_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
+ int32x4_t __ret;
+ __ret = vqdmlsl_n_s16(__p0, vget_high_s16(__p1), __p2);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqdmlsl_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vqdmlsl_n_s16(__rev0, __noswap_vget_high_s16(__rev1), __p2);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlsls_lane_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
int64_t __ret; \
int64_t __s0 = __p0; \
- __ret = (int64_t) __builtin_neon_vqshld_n_s64(__s0, __p1); \
+ int32_t __s1 = __p1; \
+ int32x2_t __s2 = __p2; \
+ __ret = (int64_t) __builtin_neon_vqdmlsls_lane_s32(__s0, __s1, __s2, __p3); \
__ret; \
})
-#define vqshlh_n_s16(__p0, __p1) __extension__ ({ \
- int16_t __ret; \
- int16_t __s0 = __p0; \
- __ret = (int16_t) __builtin_neon_vqshlh_n_s16(__s0, __p1); \
+#else
+#define vqdmlsls_lane_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ int64_t __ret; \
+ int64_t __s0 = __p0; \
+ int32_t __s1 = __p1; \
+ int32x2_t __s2 = __p2; \
+ int32x2_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
+ __ret = (int64_t) __builtin_neon_vqdmlsls_lane_s32(__s0, __s1, __rev2, __p3); \
__ret; \
})
-#define vqshlub_n_s8(__p0, __p1) __extension__ ({ \
- int8_t __ret; \
- int8_t __s0 = __p0; \
- __ret = (int8_t) __builtin_neon_vqshlub_n_s8(__s0, __p1); \
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlslh_lane_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ int32_t __ret; \
+ int32_t __s0 = __p0; \
+ int16_t __s1 = __p1; \
+ int16x4_t __s2 = __p2; \
+ __ret = (int32_t) __builtin_neon_vqdmlslh_lane_s16(__s0, __s1, __s2, __p3); \
__ret; \
})
-#define vqshlus_n_s32(__p0, __p1) __extension__ ({ \
+#else
+#define vqdmlslh_lane_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
int32_t __ret; \
int32_t __s0 = __p0; \
- __ret = (int32_t) __builtin_neon_vqshlus_n_s32(__s0, __p1); \
+ int16_t __s1 = __p1; \
+ int16x4_t __s2 = __p2; \
+ int16x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+ __ret = (int32_t) __builtin_neon_vqdmlslh_lane_s16(__s0, __s1, __rev2, __p3); \
__ret; \
})
-#define vqshlud_n_s64(__p0, __p1) __extension__ ({ \
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlsls_laneq_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
int64_t __ret; \
int64_t __s0 = __p0; \
- __ret = (int64_t) __builtin_neon_vqshlud_n_s64(__s0, __p1); \
+ int32_t __s1 = __p1; \
+ int32x4_t __s2 = __p2; \
+ __ret = (int64_t) __builtin_neon_vqdmlsls_laneq_s32(__s0, __s1, __s2, __p3); \
__ret; \
})
-#define vqshluh_n_s16(__p0, __p1) __extension__ ({ \
- int16_t __ret; \
- int16_t __s0 = __p0; \
- __ret = (int16_t) __builtin_neon_vqshluh_n_s16(__s0, __p1); \
+#else
+#define vqdmlsls_laneq_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
+ int64_t __ret; \
+ int64_t __s0 = __p0; \
+ int32_t __s1 = __p1; \
+ int32x4_t __s2 = __p2; \
+ int32x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+ __ret = (int64_t) __builtin_neon_vqdmlsls_laneq_s32(__s0, __s1, __rev2, __p3); \
__ret; \
})
+#endif
+
#ifdef __LITTLE_ENDIAN__
-#define vqshrn_high_n_u32(__p0_685, __p1_685, __p2_685) __extension__ ({ \
- uint16x8_t __ret_685; \
- uint16x4_t __s0_685 = __p0_685; \
- uint32x4_t __s1_685 = __p1_685; \
- __ret_685 = (uint16x8_t)(vcombine_u16((uint16x4_t)(__s0_685), (uint16x4_t)(vqshrn_n_u32(__s1_685, __p2_685)))); \
- __ret_685; \
+#define vqdmlslh_laneq_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ int32_t __ret; \
+ int32_t __s0 = __p0; \
+ int16_t __s1 = __p1; \
+ int16x8_t __s2 = __p2; \
+ __ret = (int32_t) __builtin_neon_vqdmlslh_laneq_s16(__s0, __s1, __s2, __p3); \
+ __ret; \
})
#else
-#define vqshrn_high_n_u32(__p0_686, __p1_686, __p2_686) __extension__ ({ \
- uint16x8_t __ret_686; \
- uint16x4_t __s0_686 = __p0_686; \
- uint32x4_t __s1_686 = __p1_686; \
- uint16x4_t __rev0_686; __rev0_686 = __builtin_shufflevector(__s0_686, __s0_686, 3, 2, 1, 0); \
- uint32x4_t __rev1_686; __rev1_686 = __builtin_shufflevector(__s1_686, __s1_686, 3, 2, 1, 0); \
- __ret_686 = (uint16x8_t)(__noswap_vcombine_u16((uint16x4_t)(__rev0_686), (uint16x4_t)(__noswap_vqshrn_n_u32(__rev1_686, __p2_686)))); \
- __ret_686 = __builtin_shufflevector(__ret_686, __ret_686, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_686; \
+#define vqdmlslh_laneq_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
+ int32_t __ret; \
+ int32_t __s0 = __p0; \
+ int16_t __s1 = __p1; \
+ int16x8_t __s2 = __p2; \
+ int16x8_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int32_t) __builtin_neon_vqdmlslh_laneq_s16(__s0, __s1, __rev2, __p3); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshrn_high_n_u64(__p0_687, __p1_687, __p2_687) __extension__ ({ \
- uint32x4_t __ret_687; \
- uint32x2_t __s0_687 = __p0_687; \
- uint64x2_t __s1_687 = __p1_687; \
- __ret_687 = (uint32x4_t)(vcombine_u32((uint32x2_t)(__s0_687), (uint32x2_t)(vqshrn_n_u64(__s1_687, __p2_687)))); \
- __ret_687; \
+#define vqdmlsl_laneq_s32(__p0_648, __p1_648, __p2_648, __p3_648) __extension__ ({ \
+ int64x2_t __ret_648; \
+ int64x2_t __s0_648 = __p0_648; \
+ int32x2_t __s1_648 = __p1_648; \
+ int32x4_t __s2_648 = __p2_648; \
+ __ret_648 = vqdmlsl_s32(__s0_648, __s1_648, splat_laneq_s32(__s2_648, __p3_648)); \
+ __ret_648; \
})
#else
-#define vqshrn_high_n_u64(__p0_688, __p1_688, __p2_688) __extension__ ({ \
- uint32x4_t __ret_688; \
- uint32x2_t __s0_688 = __p0_688; \
- uint64x2_t __s1_688 = __p1_688; \
- uint32x2_t __rev0_688; __rev0_688 = __builtin_shufflevector(__s0_688, __s0_688, 1, 0); \
- uint64x2_t __rev1_688; __rev1_688 = __builtin_shufflevector(__s1_688, __s1_688, 1, 0); \
- __ret_688 = (uint32x4_t)(__noswap_vcombine_u32((uint32x2_t)(__rev0_688), (uint32x2_t)(__noswap_vqshrn_n_u64(__rev1_688, __p2_688)))); \
- __ret_688 = __builtin_shufflevector(__ret_688, __ret_688, 3, 2, 1, 0); \
- __ret_688; \
+#define vqdmlsl_laneq_s32(__p0_649, __p1_649, __p2_649, __p3_649) __extension__ ({ \
+ int64x2_t __ret_649; \
+ int64x2_t __s0_649 = __p0_649; \
+ int32x2_t __s1_649 = __p1_649; \
+ int32x4_t __s2_649 = __p2_649; \
+ int64x2_t __rev0_649; __rev0_649 = __builtin_shufflevector(__s0_649, __s0_649, 1, 0); \
+ int32x2_t __rev1_649; __rev1_649 = __builtin_shufflevector(__s1_649, __s1_649, 1, 0); \
+ int32x4_t __rev2_649; __rev2_649 = __builtin_shufflevector(__s2_649, __s2_649, 3, 2, 1, 0); \
+ __ret_649 = __noswap_vqdmlsl_s32(__rev0_649, __rev1_649, __noswap_splat_laneq_s32(__rev2_649, __p3_649)); \
+ __ret_649 = __builtin_shufflevector(__ret_649, __ret_649, 1, 0); \
+ __ret_649; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshrn_high_n_u16(__p0_689, __p1_689, __p2_689) __extension__ ({ \
- uint8x16_t __ret_689; \
- uint8x8_t __s0_689 = __p0_689; \
- uint16x8_t __s1_689 = __p1_689; \
- __ret_689 = (uint8x16_t)(vcombine_u8((uint8x8_t)(__s0_689), (uint8x8_t)(vqshrn_n_u16(__s1_689, __p2_689)))); \
- __ret_689; \
+#define vqdmlsl_laneq_s16(__p0_650, __p1_650, __p2_650, __p3_650) __extension__ ({ \
+ int32x4_t __ret_650; \
+ int32x4_t __s0_650 = __p0_650; \
+ int16x4_t __s1_650 = __p1_650; \
+ int16x8_t __s2_650 = __p2_650; \
+ __ret_650 = vqdmlsl_s16(__s0_650, __s1_650, splat_laneq_s16(__s2_650, __p3_650)); \
+ __ret_650; \
})
#else
-#define vqshrn_high_n_u16(__p0_690, __p1_690, __p2_690) __extension__ ({ \
- uint8x16_t __ret_690; \
- uint8x8_t __s0_690 = __p0_690; \
- uint16x8_t __s1_690 = __p1_690; \
- uint8x8_t __rev0_690; __rev0_690 = __builtin_shufflevector(__s0_690, __s0_690, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x8_t __rev1_690; __rev1_690 = __builtin_shufflevector(__s1_690, __s1_690, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_690 = (uint8x16_t)(__noswap_vcombine_u8((uint8x8_t)(__rev0_690), (uint8x8_t)(__noswap_vqshrn_n_u16(__rev1_690, __p2_690)))); \
- __ret_690 = __builtin_shufflevector(__ret_690, __ret_690, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_690; \
+#define vqdmlsl_laneq_s16(__p0_651, __p1_651, __p2_651, __p3_651) __extension__ ({ \
+ int32x4_t __ret_651; \
+ int32x4_t __s0_651 = __p0_651; \
+ int16x4_t __s1_651 = __p1_651; \
+ int16x8_t __s2_651 = __p2_651; \
+ int32x4_t __rev0_651; __rev0_651 = __builtin_shufflevector(__s0_651, __s0_651, 3, 2, 1, 0); \
+ int16x4_t __rev1_651; __rev1_651 = __builtin_shufflevector(__s1_651, __s1_651, 3, 2, 1, 0); \
+ int16x8_t __rev2_651; __rev2_651 = __builtin_shufflevector(__s2_651, __s2_651, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_651 = __noswap_vqdmlsl_s16(__rev0_651, __rev1_651, __noswap_splat_laneq_s16(__rev2_651, __p3_651)); \
+ __ret_651 = __builtin_shufflevector(__ret_651, __ret_651, 3, 2, 1, 0); \
+ __ret_651; \
})
#endif
+__ai __attribute__((target("neon"))) int32_t vqdmulhs_s32(int32_t __p0, int32_t __p1) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vqdmulhs_s32(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16_t vqdmulhh_s16(int16_t __p0, int16_t __p1) {
+ int16_t __ret;
+ __ret = (int16_t) __builtin_neon_vqdmulhh_s16(__p0, __p1);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-#define vqshrn_high_n_s32(__p0_691, __p1_691, __p2_691) __extension__ ({ \
- int16x8_t __ret_691; \
- int16x4_t __s0_691 = __p0_691; \
- int32x4_t __s1_691 = __p1_691; \
- __ret_691 = (int16x8_t)(vcombine_s16((int16x4_t)(__s0_691), (int16x4_t)(vqshrn_n_s32(__s1_691, __p2_691)))); \
- __ret_691; \
+#define vqdmulhq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x2_t __s1 = __p1; \
+ __ret = (int32x4_t) __builtin_neon_vqdmulhq_lane_v((int8x16_t)__s0, (int8x8_t)__s1, __p2, 2); \
+ __ret; \
})
#else
-#define vqshrn_high_n_s32(__p0_692, __p1_692, __p2_692) __extension__ ({ \
- int16x8_t __ret_692; \
- int16x4_t __s0_692 = __p0_692; \
- int32x4_t __s1_692 = __p1_692; \
- int16x4_t __rev0_692; __rev0_692 = __builtin_shufflevector(__s0_692, __s0_692, 3, 2, 1, 0); \
- int32x4_t __rev1_692; __rev1_692 = __builtin_shufflevector(__s1_692, __s1_692, 3, 2, 1, 0); \
- __ret_692 = (int16x8_t)(__noswap_vcombine_s16((int16x4_t)(__rev0_692), (int16x4_t)(__noswap_vqshrn_n_s32(__rev1_692, __p2_692)))); \
- __ret_692 = __builtin_shufflevector(__ret_692, __ret_692, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_692; \
+#define vqdmulhq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x2_t __s1 = __p1; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (int32x4_t) __builtin_neon_vqdmulhq_lane_v((int8x16_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshrn_high_n_s64(__p0_693, __p1_693, __p2_693) __extension__ ({ \
- int32x4_t __ret_693; \
- int32x2_t __s0_693 = __p0_693; \
- int64x2_t __s1_693 = __p1_693; \
- __ret_693 = (int32x4_t)(vcombine_s32((int32x2_t)(__s0_693), (int32x2_t)(vqshrn_n_s64(__s1_693, __p2_693)))); \
- __ret_693; \
+#define vqdmulhq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x4_t __s1 = __p1; \
+ __ret = (int16x8_t) __builtin_neon_vqdmulhq_lane_v((int8x16_t)__s0, (int8x8_t)__s1, __p2, 1); \
+ __ret; \
})
#else
-#define vqshrn_high_n_s64(__p0_694, __p1_694, __p2_694) __extension__ ({ \
- int32x4_t __ret_694; \
- int32x2_t __s0_694 = __p0_694; \
- int64x2_t __s1_694 = __p1_694; \
- int32x2_t __rev0_694; __rev0_694 = __builtin_shufflevector(__s0_694, __s0_694, 1, 0); \
- int64x2_t __rev1_694; __rev1_694 = __builtin_shufflevector(__s1_694, __s1_694, 1, 0); \
- __ret_694 = (int32x4_t)(__noswap_vcombine_s32((int32x2_t)(__rev0_694), (int32x2_t)(__noswap_vqshrn_n_s64(__rev1_694, __p2_694)))); \
- __ret_694 = __builtin_shufflevector(__ret_694, __ret_694, 3, 2, 1, 0); \
- __ret_694; \
+#define vqdmulhq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x4_t __s1 = __p1; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (int16x8_t) __builtin_neon_vqdmulhq_lane_v((int8x16_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshrn_high_n_s16(__p0_695, __p1_695, __p2_695) __extension__ ({ \
- int8x16_t __ret_695; \
- int8x8_t __s0_695 = __p0_695; \
- int16x8_t __s1_695 = __p1_695; \
- __ret_695 = (int8x16_t)(vcombine_s8((int8x8_t)(__s0_695), (int8x8_t)(vqshrn_n_s16(__s1_695, __p2_695)))); \
- __ret_695; \
+#define vqdmulh_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __s1 = __p1; \
+ __ret = (int32x2_t) __builtin_neon_vqdmulh_lane_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
+ __ret; \
})
#else
-#define vqshrn_high_n_s16(__p0_696, __p1_696, __p2_696) __extension__ ({ \
- int8x16_t __ret_696; \
- int8x8_t __s0_696 = __p0_696; \
- int16x8_t __s1_696 = __p1_696; \
- int8x8_t __rev0_696; __rev0_696 = __builtin_shufflevector(__s0_696, __s0_696, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1_696; __rev1_696 = __builtin_shufflevector(__s1_696, __s1_696, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_696 = (int8x16_t)(__noswap_vcombine_s8((int8x8_t)(__rev0_696), (int8x8_t)(__noswap_vqshrn_n_s16(__rev1_696, __p2_696)))); \
- __ret_696 = __builtin_shufflevector(__ret_696, __ret_696, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_696; \
+#define vqdmulh_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __s1 = __p1; \
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (int32x2_t) __builtin_neon_vqdmulh_lane_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
})
#endif
-#define vqshrns_n_u32(__p0, __p1) __extension__ ({ \
- uint16_t __ret; \
- uint32_t __s0 = __p0; \
- __ret = (uint16_t) __builtin_neon_vqshrns_n_u32(__s0, __p1); \
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulh_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __s1 = __p1; \
+ __ret = (int16x4_t) __builtin_neon_vqdmulh_lane_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
__ret; \
})
-#define vqshrnd_n_u64(__p0, __p1) __extension__ ({ \
- uint32_t __ret; \
- uint64_t __s0 = __p0; \
- __ret = (uint32_t) __builtin_neon_vqshrnd_n_u64(__s0, __p1); \
+#else
+#define vqdmulh_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __s1 = __p1; \
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (int16x4_t) __builtin_neon_vqdmulh_lane_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
__ret; \
})
-#define vqshrnh_n_u16(__p0, __p1) __extension__ ({ \
- uint8_t __ret; \
- uint16_t __s0 = __p0; \
- __ret = (uint8_t) __builtin_neon_vqshrnh_n_u16(__s0, __p1); \
- __ret; \
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulhs_lane_s32(__p0_652, __p1_652, __p2_652) __extension__ ({ \
+ int32_t __ret_652; \
+ int32_t __s0_652 = __p0_652; \
+ int32x2_t __s1_652 = __p1_652; \
+ __ret_652 = vqdmulhs_s32(__s0_652, vget_lane_s32(__s1_652, __p2_652)); \
+ __ret_652; \
})
-#define vqshrns_n_s32(__p0, __p1) __extension__ ({ \
- int16_t __ret; \
- int32_t __s0 = __p0; \
- __ret = (int16_t) __builtin_neon_vqshrns_n_s32(__s0, __p1); \
- __ret; \
+#else
+#define vqdmulhs_lane_s32(__p0_653, __p1_653, __p2_653) __extension__ ({ \
+ int32_t __ret_653; \
+ int32_t __s0_653 = __p0_653; \
+ int32x2_t __s1_653 = __p1_653; \
+ int32x2_t __rev1_653; __rev1_653 = __builtin_shufflevector(__s1_653, __s1_653, 1, 0); \
+ __ret_653 = vqdmulhs_s32(__s0_653, __noswap_vget_lane_s32(__rev1_653, __p2_653)); \
+ __ret_653; \
})
-#define vqshrnd_n_s64(__p0, __p1) __extension__ ({ \
- int32_t __ret; \
- int64_t __s0 = __p0; \
- __ret = (int32_t) __builtin_neon_vqshrnd_n_s64(__s0, __p1); \
- __ret; \
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulhh_lane_s16(__p0_654, __p1_654, __p2_654) __extension__ ({ \
+ int16_t __ret_654; \
+ int16_t __s0_654 = __p0_654; \
+ int16x4_t __s1_654 = __p1_654; \
+ __ret_654 = vqdmulhh_s16(__s0_654, vget_lane_s16(__s1_654, __p2_654)); \
+ __ret_654; \
})
-#define vqshrnh_n_s16(__p0, __p1) __extension__ ({ \
- int8_t __ret; \
- int16_t __s0 = __p0; \
- __ret = (int8_t) __builtin_neon_vqshrnh_n_s16(__s0, __p1); \
- __ret; \
+#else
+#define vqdmulhh_lane_s16(__p0_655, __p1_655, __p2_655) __extension__ ({ \
+ int16_t __ret_655; \
+ int16_t __s0_655 = __p0_655; \
+ int16x4_t __s1_655 = __p1_655; \
+ int16x4_t __rev1_655; __rev1_655 = __builtin_shufflevector(__s1_655, __s1_655, 3, 2, 1, 0); \
+ __ret_655 = vqdmulhh_s16(__s0_655, __noswap_vget_lane_s16(__rev1_655, __p2_655)); \
+ __ret_655; \
})
+#endif
+
#ifdef __LITTLE_ENDIAN__
-#define vqshrun_high_n_s32(__p0_697, __p1_697, __p2_697) __extension__ ({ \
- int16x8_t __ret_697; \
- int16x4_t __s0_697 = __p0_697; \
- int32x4_t __s1_697 = __p1_697; \
- __ret_697 = (int16x8_t)(vcombine_s16((int16x4_t)(__s0_697), (int16x4_t)(vqshrun_n_s32(__s1_697, __p2_697)))); \
- __ret_697; \
+#define vqdmulhs_laneq_s32(__p0_656, __p1_656, __p2_656) __extension__ ({ \
+ int32_t __ret_656; \
+ int32_t __s0_656 = __p0_656; \
+ int32x4_t __s1_656 = __p1_656; \
+ __ret_656 = vqdmulhs_s32(__s0_656, vgetq_lane_s32(__s1_656, __p2_656)); \
+ __ret_656; \
})
#else
-#define vqshrun_high_n_s32(__p0_698, __p1_698, __p2_698) __extension__ ({ \
- int16x8_t __ret_698; \
- int16x4_t __s0_698 = __p0_698; \
- int32x4_t __s1_698 = __p1_698; \
- int16x4_t __rev0_698; __rev0_698 = __builtin_shufflevector(__s0_698, __s0_698, 3, 2, 1, 0); \
- int32x4_t __rev1_698; __rev1_698 = __builtin_shufflevector(__s1_698, __s1_698, 3, 2, 1, 0); \
- __ret_698 = (int16x8_t)(__noswap_vcombine_s16((int16x4_t)(__rev0_698), (int16x4_t)(__noswap_vqshrun_n_s32(__rev1_698, __p2_698)))); \
- __ret_698 = __builtin_shufflevector(__ret_698, __ret_698, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_698; \
+#define vqdmulhs_laneq_s32(__p0_657, __p1_657, __p2_657) __extension__ ({ \
+ int32_t __ret_657; \
+ int32_t __s0_657 = __p0_657; \
+ int32x4_t __s1_657 = __p1_657; \
+ int32x4_t __rev1_657; __rev1_657 = __builtin_shufflevector(__s1_657, __s1_657, 3, 2, 1, 0); \
+ __ret_657 = vqdmulhs_s32(__s0_657, __noswap_vgetq_lane_s32(__rev1_657, __p2_657)); \
+ __ret_657; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshrun_high_n_s64(__p0_699, __p1_699, __p2_699) __extension__ ({ \
- int32x4_t __ret_699; \
- int32x2_t __s0_699 = __p0_699; \
- int64x2_t __s1_699 = __p1_699; \
- __ret_699 = (int32x4_t)(vcombine_s32((int32x2_t)(__s0_699), (int32x2_t)(vqshrun_n_s64(__s1_699, __p2_699)))); \
- __ret_699; \
+#define vqdmulhh_laneq_s16(__p0_658, __p1_658, __p2_658) __extension__ ({ \
+ int16_t __ret_658; \
+ int16_t __s0_658 = __p0_658; \
+ int16x8_t __s1_658 = __p1_658; \
+ __ret_658 = vqdmulhh_s16(__s0_658, vgetq_lane_s16(__s1_658, __p2_658)); \
+ __ret_658; \
})
#else
-#define vqshrun_high_n_s64(__p0_700, __p1_700, __p2_700) __extension__ ({ \
- int32x4_t __ret_700; \
- int32x2_t __s0_700 = __p0_700; \
- int64x2_t __s1_700 = __p1_700; \
- int32x2_t __rev0_700; __rev0_700 = __builtin_shufflevector(__s0_700, __s0_700, 1, 0); \
- int64x2_t __rev1_700; __rev1_700 = __builtin_shufflevector(__s1_700, __s1_700, 1, 0); \
- __ret_700 = (int32x4_t)(__noswap_vcombine_s32((int32x2_t)(__rev0_700), (int32x2_t)(__noswap_vqshrun_n_s64(__rev1_700, __p2_700)))); \
- __ret_700 = __builtin_shufflevector(__ret_700, __ret_700, 3, 2, 1, 0); \
- __ret_700; \
+#define vqdmulhh_laneq_s16(__p0_659, __p1_659, __p2_659) __extension__ ({ \
+ int16_t __ret_659; \
+ int16_t __s0_659 = __p0_659; \
+ int16x8_t __s1_659 = __p1_659; \
+ int16x8_t __rev1_659; __rev1_659 = __builtin_shufflevector(__s1_659, __s1_659, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_659 = vqdmulhh_s16(__s0_659, __noswap_vgetq_lane_s16(__rev1_659, __p2_659)); \
+ __ret_659; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqshrun_high_n_s16(__p0_701, __p1_701, __p2_701) __extension__ ({ \
- int8x16_t __ret_701; \
- int8x8_t __s0_701 = __p0_701; \
- int16x8_t __s1_701 = __p1_701; \
- __ret_701 = (int8x16_t)(vcombine_s8((int8x8_t)(__s0_701), (int8x8_t)(vqshrun_n_s16(__s1_701, __p2_701)))); \
- __ret_701; \
+#define vqdmulhq_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __s1 = __p1; \
+ __ret = (int32x4_t) __builtin_neon_vqdmulhq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
+ __ret; \
})
#else
-#define vqshrun_high_n_s16(__p0_702, __p1_702, __p2_702) __extension__ ({ \
- int8x16_t __ret_702; \
- int8x8_t __s0_702 = __p0_702; \
- int16x8_t __s1_702 = __p1_702; \
- int8x8_t __rev0_702; __rev0_702 = __builtin_shufflevector(__s0_702, __s0_702, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1_702; __rev1_702 = __builtin_shufflevector(__s1_702, __s1_702, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_702 = (int8x16_t)(__noswap_vcombine_s8((int8x8_t)(__rev0_702), (int8x8_t)(__noswap_vqshrun_n_s16(__rev1_702, __p2_702)))); \
- __ret_702 = __builtin_shufflevector(__ret_702, __ret_702, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_702; \
+#define vqdmulhq_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __s1 = __p1; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (int32x4_t) __builtin_neon_vqdmulhq_laneq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
})
#endif
-#define vqshruns_n_s32(__p0, __p1) __extension__ ({ \
- int16_t __ret; \
- int32_t __s0 = __p0; \
- __ret = (int16_t) __builtin_neon_vqshruns_n_s32(__s0, __p1); \
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulhq_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __s1 = __p1; \
+ __ret = (int16x8_t) __builtin_neon_vqdmulhq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
__ret; \
})
-#define vqshrund_n_s64(__p0, __p1) __extension__ ({ \
- int32_t __ret; \
- int64_t __s0 = __p0; \
- __ret = (int32_t) __builtin_neon_vqshrund_n_s64(__s0, __p1); \
+#else
+#define vqdmulhq_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __s1 = __p1; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int16x8_t) __builtin_neon_vqdmulhq_laneq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
__ret; \
})
-#define vqshrunh_n_s16(__p0, __p1) __extension__ ({ \
- int8_t __ret; \
- int16_t __s0 = __p0; \
- __ret = (int8_t) __builtin_neon_vqshrunh_n_s16(__s0, __p1); \
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulh_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x4_t __s1 = __p1; \
+ __ret = (int32x2_t) __builtin_neon_vqdmulh_laneq_v((int8x8_t)__s0, (int8x16_t)__s1, __p2, 2); \
__ret; \
})
-__ai uint8_t vqsubb_u8(uint8_t __p0, uint8_t __p1) {
- uint8_t __ret;
- __ret = (uint8_t) __builtin_neon_vqsubb_u8(__p0, __p1);
- return __ret;
-}
-__ai uint32_t vqsubs_u32(uint32_t __p0, uint32_t __p1) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vqsubs_u32(__p0, __p1);
- return __ret;
-}
-__ai uint64_t vqsubd_u64(uint64_t __p0, uint64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vqsubd_u64(__p0, __p1);
- return __ret;
-}
-__ai uint16_t vqsubh_u16(uint16_t __p0, uint16_t __p1) {
- uint16_t __ret;
- __ret = (uint16_t) __builtin_neon_vqsubh_u16(__p0, __p1);
- return __ret;
-}
-__ai int8_t vqsubb_s8(int8_t __p0, int8_t __p1) {
- int8_t __ret;
- __ret = (int8_t) __builtin_neon_vqsubb_s8(__p0, __p1);
+#else
+#define vqdmulh_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x4_t __s1 = __p1; \
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (int32x2_t) __builtin_neon_vqdmulh_laneq_v((int8x8_t)__rev0, (int8x16_t)__rev1, __p2, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulh_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x8_t __s1 = __p1; \
+ __ret = (int16x4_t) __builtin_neon_vqdmulh_laneq_v((int8x8_t)__s0, (int8x16_t)__s1, __p2, 1); \
+ __ret; \
+})
+#else
+#define vqdmulh_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x8_t __s1 = __p1; \
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int16x4_t) __builtin_neon_vqdmulh_laneq_v((int8x8_t)__rev0, (int8x16_t)__rev1, __p2, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
+#endif
+
+__ai __attribute__((target("neon"))) int64_t vqdmulls_s32(int32_t __p0, int32_t __p1) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vqdmulls_s32(__p0, __p1);
return __ret;
}
-__ai int32_t vqsubs_s32(int32_t __p0, int32_t __p1) {
+__ai __attribute__((target("neon"))) int32_t vqdmullh_s16(int16_t __p0, int16_t __p1) {
int32_t __ret;
- __ret = (int32_t) __builtin_neon_vqsubs_s32(__p0, __p1);
+ __ret = (int32_t) __builtin_neon_vqdmullh_s16(__p0, __p1);
return __ret;
}
-__ai int64_t vqsubd_s64(int64_t __p0, int64_t __p1) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vqsubd_s64(__p0, __p1);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqdmull_high_s32(int32x4_t __p0, int32x4_t __p1) {
+ int64x2_t __ret;
+ __ret = vqdmull_s32(vget_high_s32(__p0), vget_high_s32(__p1));
return __ret;
}
-__ai int16_t vqsubh_s16(int16_t __p0, int16_t __p1) {
- int16_t __ret;
- __ret = (int16_t) __builtin_neon_vqsubh_s16(__p0, __p1);
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqdmull_high_s32(int32x4_t __p0, int32x4_t __p1) {
+ int64x2_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __noswap_vqdmull_s32(__noswap_vget_high_s32(__rev0), __noswap_vget_high_s32(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
+#endif
+
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vqtbl1_p8(poly8x16_t __p0, uint8x8_t __p1) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vqtbl1_v((int8x16_t)__p0, (int8x8_t)__p1, 4);
+__ai __attribute__((target("neon"))) int32x4_t vqdmull_high_s16(int16x8_t __p0, int16x8_t __p1) {
+ int32x4_t __ret;
+ __ret = vqdmull_s16(vget_high_s16(__p0), vget_high_s16(__p1));
return __ret;
}
#else
-__ai poly8x8_t vqtbl1_p8(poly8x16_t __p0, uint8x8_t __p1) {
- poly8x8_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vqtbl1_v((int8x16_t)__rev0, (int8x8_t)__rev1, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x4_t vqdmull_high_s16(int16x8_t __p0, int16x8_t __p1) {
+ int32x4_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vqdmull_s16(__noswap_vget_high_s16(__rev0), __noswap_vget_high_s16(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vqtbl1q_p8(poly8x16_t __p0, uint8x16_t __p1) {
- poly8x16_t __ret;
- __ret = (poly8x16_t) __builtin_neon_vqtbl1q_v((int8x16_t)__p0, (int8x16_t)__p1, 36);
- return __ret;
-}
+#define vqdmull_high_lane_s32(__p0_660, __p1_660, __p2_660) __extension__ ({ \
+ int64x2_t __ret_660; \
+ int32x4_t __s0_660 = __p0_660; \
+ int32x2_t __s1_660 = __p1_660; \
+ __ret_660 = vqdmull_s32(vget_high_s32(__s0_660), splat_lane_s32(__s1_660, __p2_660)); \
+ __ret_660; \
+})
#else
-__ai poly8x16_t vqtbl1q_p8(poly8x16_t __p0, uint8x16_t __p1) {
- poly8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x16_t) __builtin_neon_vqtbl1q_v((int8x16_t)__rev0, (int8x16_t)__rev1, 36);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqdmull_high_lane_s32(__p0_661, __p1_661, __p2_661) __extension__ ({ \
+ int64x2_t __ret_661; \
+ int32x4_t __s0_661 = __p0_661; \
+ int32x2_t __s1_661 = __p1_661; \
+ int32x4_t __rev0_661; __rev0_661 = __builtin_shufflevector(__s0_661, __s0_661, 3, 2, 1, 0); \
+ int32x2_t __rev1_661; __rev1_661 = __builtin_shufflevector(__s1_661, __s1_661, 1, 0); \
+ __ret_661 = __noswap_vqdmull_s32(__noswap_vget_high_s32(__rev0_661), __noswap_splat_lane_s32(__rev1_661, __p2_661)); \
+ __ret_661 = __builtin_shufflevector(__ret_661, __ret_661, 1, 0); \
+ __ret_661; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vqtbl1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vqtbl1q_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
- return __ret;
-}
+#define vqdmull_high_lane_s16(__p0_662, __p1_662, __p2_662) __extension__ ({ \
+ int32x4_t __ret_662; \
+ int16x8_t __s0_662 = __p0_662; \
+ int16x4_t __s1_662 = __p1_662; \
+ __ret_662 = vqdmull_s16(vget_high_s16(__s0_662), splat_lane_s16(__s1_662, __p2_662)); \
+ __ret_662; \
+})
#else
-__ai uint8x16_t vqtbl1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vqtbl1q_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqdmull_high_lane_s16(__p0_663, __p1_663, __p2_663) __extension__ ({ \
+ int32x4_t __ret_663; \
+ int16x8_t __s0_663 = __p0_663; \
+ int16x4_t __s1_663 = __p1_663; \
+ int16x8_t __rev0_663; __rev0_663 = __builtin_shufflevector(__s0_663, __s0_663, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x4_t __rev1_663; __rev1_663 = __builtin_shufflevector(__s1_663, __s1_663, 3, 2, 1, 0); \
+ __ret_663 = __noswap_vqdmull_s16(__noswap_vget_high_s16(__rev0_663), __noswap_splat_lane_s16(__rev1_663, __p2_663)); \
+ __ret_663 = __builtin_shufflevector(__ret_663, __ret_663, 3, 2, 1, 0); \
+ __ret_663; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vqtbl1q_s8(int8x16_t __p0, uint8x16_t __p1) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vqtbl1q_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
- return __ret;
-}
+#define vqdmull_high_laneq_s32(__p0_664, __p1_664, __p2_664) __extension__ ({ \
+ int64x2_t __ret_664; \
+ int32x4_t __s0_664 = __p0_664; \
+ int32x4_t __s1_664 = __p1_664; \
+ __ret_664 = vqdmull_s32(vget_high_s32(__s0_664), splat_laneq_s32(__s1_664, __p2_664)); \
+ __ret_664; \
+})
#else
-__ai int8x16_t vqtbl1q_s8(int8x16_t __p0, uint8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vqtbl1q_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqdmull_high_laneq_s32(__p0_665, __p1_665, __p2_665) __extension__ ({ \
+ int64x2_t __ret_665; \
+ int32x4_t __s0_665 = __p0_665; \
+ int32x4_t __s1_665 = __p1_665; \
+ int32x4_t __rev0_665; __rev0_665 = __builtin_shufflevector(__s0_665, __s0_665, 3, 2, 1, 0); \
+ int32x4_t __rev1_665; __rev1_665 = __builtin_shufflevector(__s1_665, __s1_665, 3, 2, 1, 0); \
+ __ret_665 = __noswap_vqdmull_s32(__noswap_vget_high_s32(__rev0_665), __noswap_splat_laneq_s32(__rev1_665, __p2_665)); \
+ __ret_665 = __builtin_shufflevector(__ret_665, __ret_665, 1, 0); \
+ __ret_665; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vqtbl1_u8(uint8x16_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vqtbl1_v((int8x16_t)__p0, (int8x8_t)__p1, 16);
- return __ret;
-}
+#define vqdmull_high_laneq_s16(__p0_666, __p1_666, __p2_666) __extension__ ({ \
+ int32x4_t __ret_666; \
+ int16x8_t __s0_666 = __p0_666; \
+ int16x8_t __s1_666 = __p1_666; \
+ __ret_666 = vqdmull_s16(vget_high_s16(__s0_666), splat_laneq_s16(__s1_666, __p2_666)); \
+ __ret_666; \
+})
#else
-__ai uint8x8_t vqtbl1_u8(uint8x16_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vqtbl1_v((int8x16_t)__rev0, (int8x8_t)__rev1, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqdmull_high_laneq_s16(__p0_667, __p1_667, __p2_667) __extension__ ({ \
+ int32x4_t __ret_667; \
+ int16x8_t __s0_667 = __p0_667; \
+ int16x8_t __s1_667 = __p1_667; \
+ int16x8_t __rev0_667; __rev0_667 = __builtin_shufflevector(__s0_667, __s0_667, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1_667; __rev1_667 = __builtin_shufflevector(__s1_667, __s1_667, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_667 = __noswap_vqdmull_s16(__noswap_vget_high_s16(__rev0_667), __noswap_splat_laneq_s16(__rev1_667, __p2_667)); \
+ __ret_667 = __builtin_shufflevector(__ret_667, __ret_667, 3, 2, 1, 0); \
+ __ret_667; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vqtbl1_s8(int8x16_t __p0, uint8x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vqtbl1_v((int8x16_t)__p0, (int8x8_t)__p1, 0);
+__ai __attribute__((target("neon"))) int64x2_t vqdmull_high_n_s32(int32x4_t __p0, int32_t __p1) {
+ int64x2_t __ret;
+ __ret = vqdmull_n_s32(vget_high_s32(__p0), __p1);
return __ret;
}
#else
-__ai int8x8_t vqtbl1_s8(int8x16_t __p0, uint8x8_t __p1) {
- int8x8_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vqtbl1_v((int8x16_t)__rev0, (int8x8_t)__rev1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int64x2_t vqdmull_high_n_s32(int32x4_t __p0, int32_t __p1) {
+ int64x2_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = __noswap_vqdmull_n_s32(__noswap_vget_high_s32(__rev0), __p1);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vqtbl2_p8(poly8x16x2_t __p0, uint8x8_t __p1) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vqtbl2_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x8_t)__p1, 4);
+__ai __attribute__((target("neon"))) int32x4_t vqdmull_high_n_s16(int16x8_t __p0, int16_t __p1) {
+ int32x4_t __ret;
+ __ret = vqdmull_n_s16(vget_high_s16(__p0), __p1);
return __ret;
}
#else
-__ai poly8x8_t vqtbl2_p8(poly8x16x2_t __p0, uint8x8_t __p1) {
- poly8x8_t __ret;
- poly8x16x2_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vqtbl2_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x8_t)__rev1, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x4_t vqdmull_high_n_s16(int16x8_t __p0, int16_t __p1) {
+ int32x4_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vqdmull_n_s16(__noswap_vget_high_s16(__rev0), __p1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vqtbl2q_p8(poly8x16x2_t __p0, uint8x16_t __p1) {
- poly8x16_t __ret;
- __ret = (poly8x16_t) __builtin_neon_vqtbl2q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p1, 36);
- return __ret;
-}
+#define vqdmulls_lane_s32(__p0_668, __p1_668, __p2_668) __extension__ ({ \
+ int64_t __ret_668; \
+ int32_t __s0_668 = __p0_668; \
+ int32x2_t __s1_668 = __p1_668; \
+ __ret_668 = vqdmulls_s32(__s0_668, vget_lane_s32(__s1_668, __p2_668)); \
+ __ret_668; \
+})
#else
-__ai poly8x16_t vqtbl2q_p8(poly8x16x2_t __p0, uint8x16_t __p1) {
- poly8x16_t __ret;
- poly8x16x2_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x16_t) __builtin_neon_vqtbl2q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev1, 36);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqdmulls_lane_s32(__p0_669, __p1_669, __p2_669) __extension__ ({ \
+ int64_t __ret_669; \
+ int32_t __s0_669 = __p0_669; \
+ int32x2_t __s1_669 = __p1_669; \
+ int32x2_t __rev1_669; __rev1_669 = __builtin_shufflevector(__s1_669, __s1_669, 1, 0); \
+ __ret_669 = vqdmulls_s32(__s0_669, __noswap_vget_lane_s32(__rev1_669, __p2_669)); \
+ __ret_669; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vqtbl2q_u8(uint8x16x2_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vqtbl2q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p1, 48);
- return __ret;
-}
+#define vqdmullh_lane_s16(__p0_670, __p1_670, __p2_670) __extension__ ({ \
+ int32_t __ret_670; \
+ int16_t __s0_670 = __p0_670; \
+ int16x4_t __s1_670 = __p1_670; \
+ __ret_670 = vqdmullh_s16(__s0_670, vget_lane_s16(__s1_670, __p2_670)); \
+ __ret_670; \
+})
#else
-__ai uint8x16_t vqtbl2q_u8(uint8x16x2_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16x2_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vqtbl2q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqdmullh_lane_s16(__p0_671, __p1_671, __p2_671) __extension__ ({ \
+ int32_t __ret_671; \
+ int16_t __s0_671 = __p0_671; \
+ int16x4_t __s1_671 = __p1_671; \
+ int16x4_t __rev1_671; __rev1_671 = __builtin_shufflevector(__s1_671, __s1_671, 3, 2, 1, 0); \
+ __ret_671 = vqdmullh_s16(__s0_671, __noswap_vget_lane_s16(__rev1_671, __p2_671)); \
+ __ret_671; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vqtbl2q_s8(int8x16x2_t __p0, uint8x16_t __p1) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vqtbl2q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p1, 32);
- return __ret;
-}
+#define vqdmulls_laneq_s32(__p0_672, __p1_672, __p2_672) __extension__ ({ \
+ int64_t __ret_672; \
+ int32_t __s0_672 = __p0_672; \
+ int32x4_t __s1_672 = __p1_672; \
+ __ret_672 = vqdmulls_s32(__s0_672, vgetq_lane_s32(__s1_672, __p2_672)); \
+ __ret_672; \
+})
#else
-__ai int8x16_t vqtbl2q_s8(int8x16x2_t __p0, uint8x16_t __p1) {
- int8x16_t __ret;
- int8x16x2_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vqtbl2q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev1, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqdmulls_laneq_s32(__p0_673, __p1_673, __p2_673) __extension__ ({ \
+ int64_t __ret_673; \
+ int32_t __s0_673 = __p0_673; \
+ int32x4_t __s1_673 = __p1_673; \
+ int32x4_t __rev1_673; __rev1_673 = __builtin_shufflevector(__s1_673, __s1_673, 3, 2, 1, 0); \
+ __ret_673 = vqdmulls_s32(__s0_673, __noswap_vgetq_lane_s32(__rev1_673, __p2_673)); \
+ __ret_673; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vqtbl2_u8(uint8x16x2_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vqtbl2_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x8_t)__p1, 16);
- return __ret;
-}
+#define vqdmullh_laneq_s16(__p0_674, __p1_674, __p2_674) __extension__ ({ \
+ int32_t __ret_674; \
+ int16_t __s0_674 = __p0_674; \
+ int16x8_t __s1_674 = __p1_674; \
+ __ret_674 = vqdmullh_s16(__s0_674, vgetq_lane_s16(__s1_674, __p2_674)); \
+ __ret_674; \
+})
#else
-__ai uint8x8_t vqtbl2_u8(uint8x16x2_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x16x2_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vqtbl2_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x8_t)__rev1, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqdmullh_laneq_s16(__p0_675, __p1_675, __p2_675) __extension__ ({ \
+ int32_t __ret_675; \
+ int16_t __s0_675 = __p0_675; \
+ int16x8_t __s1_675 = __p1_675; \
+ int16x8_t __rev1_675; __rev1_675 = __builtin_shufflevector(__s1_675, __s1_675, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_675 = vqdmullh_s16(__s0_675, __noswap_vgetq_lane_s16(__rev1_675, __p2_675)); \
+ __ret_675; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vqtbl2_s8(int8x16x2_t __p0, uint8x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vqtbl2_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x8_t)__p1, 0);
- return __ret;
-}
+#define vqdmull_laneq_s32(__p0_676, __p1_676, __p2_676) __extension__ ({ \
+ int64x2_t __ret_676; \
+ int32x2_t __s0_676 = __p0_676; \
+ int32x4_t __s1_676 = __p1_676; \
+ __ret_676 = vqdmull_s32(__s0_676, splat_laneq_s32(__s1_676, __p2_676)); \
+ __ret_676; \
+})
#else
-__ai int8x8_t vqtbl2_s8(int8x16x2_t __p0, uint8x8_t __p1) {
- int8x8_t __ret;
- int8x16x2_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vqtbl2_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x8_t)__rev1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqdmull_laneq_s32(__p0_677, __p1_677, __p2_677) __extension__ ({ \
+ int64x2_t __ret_677; \
+ int32x2_t __s0_677 = __p0_677; \
+ int32x4_t __s1_677 = __p1_677; \
+ int32x2_t __rev0_677; __rev0_677 = __builtin_shufflevector(__s0_677, __s0_677, 1, 0); \
+ int32x4_t __rev1_677; __rev1_677 = __builtin_shufflevector(__s1_677, __s1_677, 3, 2, 1, 0); \
+ __ret_677 = __noswap_vqdmull_s32(__rev0_677, __noswap_splat_laneq_s32(__rev1_677, __p2_677)); \
+ __ret_677 = __builtin_shufflevector(__ret_677, __ret_677, 1, 0); \
+ __ret_677; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vqtbl3_p8(poly8x16x3_t __p0, uint8x8_t __p1) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vqtbl3_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x8_t)__p1, 4);
- return __ret;
-}
+#define vqdmull_laneq_s16(__p0_678, __p1_678, __p2_678) __extension__ ({ \
+ int32x4_t __ret_678; \
+ int16x4_t __s0_678 = __p0_678; \
+ int16x8_t __s1_678 = __p1_678; \
+ __ret_678 = vqdmull_s16(__s0_678, splat_laneq_s16(__s1_678, __p2_678)); \
+ __ret_678; \
+})
#else
-__ai poly8x8_t vqtbl3_p8(poly8x16x3_t __p0, uint8x8_t __p1) {
- poly8x8_t __ret;
- poly8x16x3_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vqtbl3_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x8_t)__rev1, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqdmull_laneq_s16(__p0_679, __p1_679, __p2_679) __extension__ ({ \
+ int32x4_t __ret_679; \
+ int16x4_t __s0_679 = __p0_679; \
+ int16x8_t __s1_679 = __p1_679; \
+ int16x4_t __rev0_679; __rev0_679 = __builtin_shufflevector(__s0_679, __s0_679, 3, 2, 1, 0); \
+ int16x8_t __rev1_679; __rev1_679 = __builtin_shufflevector(__s1_679, __s1_679, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_679 = __noswap_vqdmull_s16(__rev0_679, __noswap_splat_laneq_s16(__rev1_679, __p2_679)); \
+ __ret_679 = __builtin_shufflevector(__ret_679, __ret_679, 3, 2, 1, 0); \
+ __ret_679; \
+})
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vqtbl3q_p8(poly8x16x3_t __p0, uint8x16_t __p1) {
- poly8x16_t __ret;
- __ret = (poly8x16_t) __builtin_neon_vqtbl3q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p1, 36);
+__ai __attribute__((target("neon"))) int16_t vqmovns_s32(int32_t __p0) {
+ int16_t __ret;
+ __ret = (int16_t) __builtin_neon_vqmovns_s32(__p0);
return __ret;
}
-#else
-__ai poly8x16_t vqtbl3q_p8(poly8x16x3_t __p0, uint8x16_t __p1) {
- poly8x16_t __ret;
- poly8x16x3_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x16_t) __builtin_neon_vqtbl3q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev1, 36);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32_t vqmovnd_s64(int64_t __p0) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vqmovnd_s64(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vqtbl3q_u8(uint8x16x3_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vqtbl3q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p1, 48);
+__ai __attribute__((target("neon"))) int8_t vqmovnh_s16(int16_t __p0) {
+ int8_t __ret;
+ __ret = (int8_t) __builtin_neon_vqmovnh_s16(__p0);
return __ret;
}
-#else
-__ai uint8x16_t vqtbl3q_u8(uint8x16x3_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16x3_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vqtbl3q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint16_t vqmovns_u32(uint32_t __p0) {
+ uint16_t __ret;
+ __ret = (uint16_t) __builtin_neon_vqmovns_u32(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vqtbl3q_s8(int8x16x3_t __p0, uint8x16_t __p1) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vqtbl3q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p1, 32);
+__ai __attribute__((target("neon"))) uint32_t vqmovnd_u64(uint64_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vqmovnd_u64(__p0);
return __ret;
}
-#else
-__ai int8x16_t vqtbl3q_s8(int8x16x3_t __p0, uint8x16_t __p1) {
- int8x16_t __ret;
- int8x16x3_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vqtbl3q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev1, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8_t vqmovnh_u16(uint16_t __p0) {
+ uint8_t __ret;
+ __ret = (uint8_t) __builtin_neon_vqmovnh_u16(__p0);
return __ret;
}
-#endif
-
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vqtbl3_u8(uint8x16x3_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vqtbl3_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x8_t)__p1, 16);
+__ai __attribute__((target("neon"))) uint16x8_t vqmovn_high_u32(uint16x4_t __p0, uint32x4_t __p1) {
+ uint16x8_t __ret;
+ __ret = vcombine_u16(__p0, vqmovn_u32(__p1));
return __ret;
}
#else
-__ai uint8x8_t vqtbl3_u8(uint8x16x3_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x16x3_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vqtbl3_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x8_t)__rev1, 16);
+__ai __attribute__((target("neon"))) uint16x8_t vqmovn_high_u32(uint16x4_t __p0, uint32x4_t __p1) {
+ uint16x8_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_u16(__rev0, __noswap_vqmovn_u32(__rev1));
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vqtbl3_s8(int8x16x3_t __p0, uint8x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vqtbl3_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x8_t)__p1, 0);
+__ai __attribute__((target("neon"))) uint32x4_t vqmovn_high_u64(uint32x2_t __p0, uint64x2_t __p1) {
+ uint32x4_t __ret;
+ __ret = vcombine_u32(__p0, vqmovn_u64(__p1));
return __ret;
}
#else
-__ai int8x8_t vqtbl3_s8(int8x16x3_t __p0, uint8x8_t __p1) {
- int8x8_t __ret;
- int8x16x3_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vqtbl3_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x8_t)__rev1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x4_t vqmovn_high_u64(uint32x2_t __p0, uint64x2_t __p1) {
+ uint32x4_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __noswap_vcombine_u32(__rev0, __noswap_vqmovn_u64(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vqtbl4_p8(poly8x16x4_t __p0, uint8x8_t __p1) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vqtbl4_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p0.val[3], (int8x8_t)__p1, 4);
+__ai __attribute__((target("neon"))) uint8x16_t vqmovn_high_u16(uint8x8_t __p0, uint16x8_t __p1) {
+ uint8x16_t __ret;
+ __ret = vcombine_u8(__p0, vqmovn_u16(__p1));
return __ret;
}
#else
-__ai poly8x8_t vqtbl4_p8(poly8x16x4_t __p0, uint8x8_t __p1) {
- poly8x8_t __ret;
- poly8x16x4_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vqtbl4_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev0.val[3], (int8x8_t)__rev1, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vqmovn_high_u16(uint8x8_t __p0, uint16x8_t __p1) {
+ uint8x16_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_u8(__rev0, __noswap_vqmovn_u16(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vqtbl4q_p8(poly8x16x4_t __p0, uint8x16_t __p1) {
- poly8x16_t __ret;
- __ret = (poly8x16_t) __builtin_neon_vqtbl4q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p0.val[3], (int8x16_t)__p1, 36);
+__ai __attribute__((target("neon"))) int16x8_t vqmovn_high_s32(int16x4_t __p0, int32x4_t __p1) {
+ int16x8_t __ret;
+ __ret = vcombine_s16(__p0, vqmovn_s32(__p1));
return __ret;
}
#else
-__ai poly8x16_t vqtbl4q_p8(poly8x16x4_t __p0, uint8x16_t __p1) {
- poly8x16_t __ret;
- poly8x16x4_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x16_t) __builtin_neon_vqtbl4q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev0.val[3], (int8x16_t)__rev1, 36);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16x8_t vqmovn_high_s32(int16x4_t __p0, int32x4_t __p1) {
+ int16x8_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_s16(__rev0, __noswap_vqmovn_s32(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vqtbl4q_u8(uint8x16x4_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vqtbl4q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p0.val[3], (int8x16_t)__p1, 48);
+__ai __attribute__((target("neon"))) int32x4_t vqmovn_high_s64(int32x2_t __p0, int64x2_t __p1) {
+ int32x4_t __ret;
+ __ret = vcombine_s32(__p0, vqmovn_s64(__p1));
return __ret;
}
#else
-__ai uint8x16_t vqtbl4q_u8(uint8x16x4_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16x4_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vqtbl4q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev0.val[3], (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x4_t vqmovn_high_s64(int32x2_t __p0, int64x2_t __p1) {
+ int32x4_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __noswap_vcombine_s32(__rev0, __noswap_vqmovn_s64(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vqtbl4q_s8(int8x16x4_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) int8x16_t vqmovn_high_s16(int8x8_t __p0, int16x8_t __p1) {
int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vqtbl4q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p0.val[3], (int8x16_t)__p1, 32);
+ __ret = vcombine_s8(__p0, vqmovn_s16(__p1));
return __ret;
}
#else
-__ai int8x16_t vqtbl4q_s8(int8x16x4_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) int8x16_t vqmovn_high_s16(int8x8_t __p0, int16x8_t __p1) {
int8x16_t __ret;
- int8x16x4_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vqtbl4q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev0.val[3], (int8x16_t)__rev1, 32);
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_s8(__rev0, __noswap_vqmovn_s16(__rev1));
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vqtbl4_u8(uint8x16x4_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vqtbl4_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p0.val[3], (int8x8_t)__p1, 16);
- return __ret;
-}
-#else
-__ai uint8x8_t vqtbl4_u8(uint8x16x4_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x16x4_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vqtbl4_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev0.val[3], (int8x8_t)__rev1, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint16_t vqmovuns_s32(int32_t __p0) {
+ uint16_t __ret;
+ __ret = (uint16_t) __builtin_neon_vqmovuns_s32(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vqtbl4_s8(int8x16x4_t __p0, uint8x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vqtbl4_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p0.val[3], (int8x8_t)__p1, 0);
+__ai __attribute__((target("neon"))) uint32_t vqmovund_s64(int64_t __p0) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vqmovund_s64(__p0);
return __ret;
}
-#else
-__ai int8x8_t vqtbl4_s8(int8x16x4_t __p0, uint8x8_t __p1) {
- int8x8_t __ret;
- int8x16x4_t __rev0;
- __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vqtbl4_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev0.val[3], (int8x8_t)__rev1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8_t vqmovunh_s16(int16_t __p0) {
+ uint8_t __ret;
+ __ret = (uint8_t) __builtin_neon_vqmovunh_s16(__p0);
return __ret;
}
-#endif
-
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vqtbx1_p8(poly8x8_t __p0, poly8x16_t __p1, uint8x8_t __p2) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vqtbx1_v((int8x8_t)__p0, (int8x16_t)__p1, (int8x8_t)__p2, 4);
+__ai __attribute__((target("neon"))) uint16x8_t vqmovun_high_s32(uint16x4_t __p0, int32x4_t __p1) {
+ uint16x8_t __ret;
+ __ret = vcombine_u16((uint16x4_t)(__p0), vqmovun_s32(__p1));
return __ret;
}
#else
-__ai poly8x8_t vqtbx1_p8(poly8x8_t __p0, poly8x16_t __p1, uint8x8_t __p2) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vqtbx1_v((int8x8_t)__rev0, (int8x16_t)__rev1, (int8x8_t)__rev2, 4);
+__ai __attribute__((target("neon"))) uint16x8_t vqmovun_high_s32(uint16x4_t __p0, int32x4_t __p1) {
+ uint16x8_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_u16((uint16x4_t)(__rev0), __noswap_vqmovun_s32(__rev1));
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vqtbx1q_p8(poly8x16_t __p0, poly8x16_t __p1, uint8x16_t __p2) {
- poly8x16_t __ret;
- __ret = (poly8x16_t) __builtin_neon_vqtbx1q_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 36);
+__ai __attribute__((target("neon"))) uint32x4_t vqmovun_high_s64(uint32x2_t __p0, int64x2_t __p1) {
+ uint32x4_t __ret;
+ __ret = vcombine_u32((uint32x2_t)(__p0), vqmovun_s64(__p1));
return __ret;
}
#else
-__ai poly8x16_t vqtbx1q_p8(poly8x16_t __p0, poly8x16_t __p1, uint8x16_t __p2) {
- poly8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x16_t) __builtin_neon_vqtbx1q_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 36);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x4_t vqmovun_high_s64(uint32x2_t __p0, int64x2_t __p1) {
+ uint32x4_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __noswap_vcombine_u32((uint32x2_t)(__rev0), __noswap_vqmovun_s64(__rev1));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vqtbx1q_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+__ai __attribute__((target("neon"))) uint8x16_t vqmovun_high_s16(uint8x8_t __p0, int16x8_t __p1) {
uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vqtbx1q_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 48);
+ __ret = vcombine_u8((uint8x8_t)(__p0), vqmovun_s16(__p1));
return __ret;
}
#else
-__ai uint8x16_t vqtbx1q_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+__ai __attribute__((target("neon"))) uint8x16_t vqmovun_high_s16(uint8x8_t __p0, int16x8_t __p1) {
uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vqtbx1q_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 48);
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_u8((uint8x8_t)(__rev0), __noswap_vqmovun_s16(__rev1));
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vqtbx1q_s8(int8x16_t __p0, int8x16_t __p1, uint8x16_t __p2) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vqtbx1q_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 32);
+__ai __attribute__((target("neon"))) int64x2_t vqnegq_s64(int64x2_t __p0) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vqnegq_v((int8x16_t)__p0, 35);
return __ret;
}
#else
-__ai int8x16_t vqtbx1q_s8(int8x16_t __p0, int8x16_t __p1, uint8x16_t __p2) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vqtbx1q_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int64x2_t vqnegq_s64(int64x2_t __p0) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vqnegq_v((int8x16_t)__rev0, 35);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vqtbx1_u8(uint8x8_t __p0, uint8x16_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vqtbx1_v((int8x8_t)__p0, (int8x16_t)__p1, (int8x8_t)__p2, 16);
- return __ret;
-}
-#else
-__ai uint8x8_t vqtbx1_u8(uint8x8_t __p0, uint8x16_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vqtbx1_v((int8x8_t)__rev0, (int8x16_t)__rev1, (int8x8_t)__rev2, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int64x1_t vqneg_s64(int64x1_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t) __builtin_neon_vqneg_v((int8x8_t)__p0, 3);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vqtbx1_s8(int8x8_t __p0, int8x16_t __p1, uint8x8_t __p2) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vqtbx1_v((int8x8_t)__p0, (int8x16_t)__p1, (int8x8_t)__p2, 0);
+__ai __attribute__((target("neon"))) int8_t vqnegb_s8(int8_t __p0) {
+ int8_t __ret;
+ __ret = (int8_t) __builtin_neon_vqnegb_s8(__p0);
return __ret;
}
-#else
-__ai int8x8_t vqtbx1_s8(int8x8_t __p0, int8x16_t __p1, uint8x8_t __p2) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vqtbx1_v((int8x8_t)__rev0, (int8x16_t)__rev1, (int8x8_t)__rev2, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32_t vqnegs_s32(int32_t __p0) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vqnegs_s32(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vqtbx2_p8(poly8x8_t __p0, poly8x16x2_t __p1, uint8x8_t __p2) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vqtbx2_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x8_t)__p2, 4);
+__ai __attribute__((target("neon"))) int64_t vqnegd_s64(int64_t __p0) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vqnegd_s64(__p0);
return __ret;
}
-#else
-__ai poly8x8_t vqtbx2_p8(poly8x8_t __p0, poly8x16x2_t __p1, uint8x8_t __p2) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16x2_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vqtbx2_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x8_t)__rev2, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16_t vqnegh_s16(int16_t __p0) {
+ int16_t __ret;
+ __ret = (int16_t) __builtin_neon_vqnegh_s16(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vqtbx2q_p8(poly8x16_t __p0, poly8x16x2_t __p1, uint8x16_t __p2) {
- poly8x16_t __ret;
- __ret = (poly8x16_t) __builtin_neon_vqtbx2q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p2, 36);
+__ai __attribute__((target("neon"))) int32_t vqrdmulhs_s32(int32_t __p0, int32_t __p1) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vqrdmulhs_s32(__p0, __p1);
return __ret;
}
-#else
-__ai poly8x16_t vqtbx2q_p8(poly8x16_t __p0, poly8x16x2_t __p1, uint8x16_t __p2) {
- poly8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16x2_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x16_t) __builtin_neon_vqtbx2q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev2, 36);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16_t vqrdmulhh_s16(int16_t __p0, int16_t __p1) {
+ int16_t __ret;
+ __ret = (int16_t) __builtin_neon_vqrdmulhh_s16(__p0, __p1);
return __ret;
}
-#endif
-
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vqtbx2q_u8(uint8x16_t __p0, uint8x16x2_t __p1, uint8x16_t __p2) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vqtbx2q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p2, 48);
- return __ret;
-}
+#define vqrdmulhq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x2_t __s1 = __p1; \
+ __ret = (int32x4_t) __builtin_neon_vqrdmulhq_lane_v((int8x16_t)__s0, (int8x8_t)__s1, __p2, 2); \
+ __ret; \
+})
#else
-__ai uint8x16_t vqtbx2q_u8(uint8x16_t __p0, uint8x16x2_t __p1, uint8x16_t __p2) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16x2_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vqtbx2q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev2, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrdmulhq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x2_t __s1 = __p1; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (int32x4_t) __builtin_neon_vqrdmulhq_lane_v((int8x16_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vqtbx2q_s8(int8x16_t __p0, int8x16x2_t __p1, uint8x16_t __p2) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vqtbx2q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p2, 32);
- return __ret;
-}
+#define vqrdmulhq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x4_t __s1 = __p1; \
+ __ret = (int16x8_t) __builtin_neon_vqrdmulhq_lane_v((int8x16_t)__s0, (int8x8_t)__s1, __p2, 1); \
+ __ret; \
+})
#else
-__ai int8x16_t vqtbx2q_s8(int8x16_t __p0, int8x16x2_t __p1, uint8x16_t __p2) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16x2_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vqtbx2q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev2, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrdmulhq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x4_t __s1 = __p1; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (int16x8_t) __builtin_neon_vqrdmulhq_lane_v((int8x16_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vqtbx2_u8(uint8x8_t __p0, uint8x16x2_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vqtbx2_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x8_t)__p2, 16);
- return __ret;
-}
+#define vqrdmulh_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __s1 = __p1; \
+ __ret = (int32x2_t) __builtin_neon_vqrdmulh_lane_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
+ __ret; \
+})
#else
-__ai uint8x8_t vqtbx2_u8(uint8x8_t __p0, uint8x16x2_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16x2_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vqtbx2_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x8_t)__rev2, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrdmulh_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x2_t __s1 = __p1; \
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (int32x2_t) __builtin_neon_vqrdmulh_lane_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vqtbx2_s8(int8x8_t __p0, int8x16x2_t __p1, uint8x8_t __p2) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vqtbx2_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x8_t)__p2, 0);
- return __ret;
-}
+#define vqrdmulh_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __s1 = __p1; \
+ __ret = (int16x4_t) __builtin_neon_vqrdmulh_lane_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
+ __ret; \
+})
#else
-__ai int8x8_t vqtbx2_s8(int8x8_t __p0, int8x16x2_t __p1, uint8x8_t __p2) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16x2_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vqtbx2_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x8_t)__rev2, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrdmulh_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x4_t __s1 = __p1; \
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (int16x4_t) __builtin_neon_vqrdmulh_lane_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vqtbx3_p8(poly8x8_t __p0, poly8x16x3_t __p1, uint8x8_t __p2) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vqtbx3_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x8_t)__p2, 4);
- return __ret;
-}
+#define vqrdmulhs_lane_s32(__p0_680, __p1_680, __p2_680) __extension__ ({ \
+ int32_t __ret_680; \
+ int32_t __s0_680 = __p0_680; \
+ int32x2_t __s1_680 = __p1_680; \
+ __ret_680 = vqrdmulhs_s32(__s0_680, vget_lane_s32(__s1_680, __p2_680)); \
+ __ret_680; \
+})
#else
-__ai poly8x8_t vqtbx3_p8(poly8x8_t __p0, poly8x16x3_t __p1, uint8x8_t __p2) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16x3_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vqtbx3_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x8_t)__rev2, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrdmulhs_lane_s32(__p0_681, __p1_681, __p2_681) __extension__ ({ \
+ int32_t __ret_681; \
+ int32_t __s0_681 = __p0_681; \
+ int32x2_t __s1_681 = __p1_681; \
+ int32x2_t __rev1_681; __rev1_681 = __builtin_shufflevector(__s1_681, __s1_681, 1, 0); \
+ __ret_681 = vqrdmulhs_s32(__s0_681, __noswap_vget_lane_s32(__rev1_681, __p2_681)); \
+ __ret_681; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vqtbx3q_p8(poly8x16_t __p0, poly8x16x3_t __p1, uint8x16_t __p2) {
- poly8x16_t __ret;
- __ret = (poly8x16_t) __builtin_neon_vqtbx3q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p2, 36);
- return __ret;
-}
+#define vqrdmulhh_lane_s16(__p0_682, __p1_682, __p2_682) __extension__ ({ \
+ int16_t __ret_682; \
+ int16_t __s0_682 = __p0_682; \
+ int16x4_t __s1_682 = __p1_682; \
+ __ret_682 = vqrdmulhh_s16(__s0_682, vget_lane_s16(__s1_682, __p2_682)); \
+ __ret_682; \
+})
#else
-__ai poly8x16_t vqtbx3q_p8(poly8x16_t __p0, poly8x16x3_t __p1, uint8x16_t __p2) {
- poly8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16x3_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x16_t) __builtin_neon_vqtbx3q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev2, 36);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrdmulhh_lane_s16(__p0_683, __p1_683, __p2_683) __extension__ ({ \
+ int16_t __ret_683; \
+ int16_t __s0_683 = __p0_683; \
+ int16x4_t __s1_683 = __p1_683; \
+ int16x4_t __rev1_683; __rev1_683 = __builtin_shufflevector(__s1_683, __s1_683, 3, 2, 1, 0); \
+ __ret_683 = vqrdmulhh_s16(__s0_683, __noswap_vget_lane_s16(__rev1_683, __p2_683)); \
+ __ret_683; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vqtbx3q_u8(uint8x16_t __p0, uint8x16x3_t __p1, uint8x16_t __p2) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vqtbx3q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p2, 48);
- return __ret;
-}
+#define vqrdmulhs_laneq_s32(__p0_684, __p1_684, __p2_684) __extension__ ({ \
+ int32_t __ret_684; \
+ int32_t __s0_684 = __p0_684; \
+ int32x4_t __s1_684 = __p1_684; \
+ __ret_684 = vqrdmulhs_s32(__s0_684, vgetq_lane_s32(__s1_684, __p2_684)); \
+ __ret_684; \
+})
#else
-__ai uint8x16_t vqtbx3q_u8(uint8x16_t __p0, uint8x16x3_t __p1, uint8x16_t __p2) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16x3_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vqtbx3q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev2, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrdmulhs_laneq_s32(__p0_685, __p1_685, __p2_685) __extension__ ({ \
+ int32_t __ret_685; \
+ int32_t __s0_685 = __p0_685; \
+ int32x4_t __s1_685 = __p1_685; \
+ int32x4_t __rev1_685; __rev1_685 = __builtin_shufflevector(__s1_685, __s1_685, 3, 2, 1, 0); \
+ __ret_685 = vqrdmulhs_s32(__s0_685, __noswap_vgetq_lane_s32(__rev1_685, __p2_685)); \
+ __ret_685; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vqtbx3q_s8(int8x16_t __p0, int8x16x3_t __p1, uint8x16_t __p2) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vqtbx3q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p2, 32);
- return __ret;
-}
+#define vqrdmulhh_laneq_s16(__p0_686, __p1_686, __p2_686) __extension__ ({ \
+ int16_t __ret_686; \
+ int16_t __s0_686 = __p0_686; \
+ int16x8_t __s1_686 = __p1_686; \
+ __ret_686 = vqrdmulhh_s16(__s0_686, vgetq_lane_s16(__s1_686, __p2_686)); \
+ __ret_686; \
+})
#else
-__ai int8x16_t vqtbx3q_s8(int8x16_t __p0, int8x16x3_t __p1, uint8x16_t __p2) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16x3_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vqtbx3q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev2, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrdmulhh_laneq_s16(__p0_687, __p1_687, __p2_687) __extension__ ({ \
+ int16_t __ret_687; \
+ int16_t __s0_687 = __p0_687; \
+ int16x8_t __s1_687 = __p1_687; \
+ int16x8_t __rev1_687; __rev1_687 = __builtin_shufflevector(__s1_687, __s1_687, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_687 = vqrdmulhh_s16(__s0_687, __noswap_vgetq_lane_s16(__rev1_687, __p2_687)); \
+ __ret_687; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vqtbx3_u8(uint8x8_t __p0, uint8x16x3_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vqtbx3_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x8_t)__p2, 16);
- return __ret;
-}
+#define vqrdmulhq_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __s1 = __p1; \
+ __ret = (int32x4_t) __builtin_neon_vqrdmulhq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
+ __ret; \
+})
#else
-__ai uint8x8_t vqtbx3_u8(uint8x8_t __p0, uint8x16x3_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16x3_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vqtbx3_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x8_t)__rev2, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrdmulhq_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x4_t __ret; \
+ int32x4_t __s0 = __p0; \
+ int32x4_t __s1 = __p1; \
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (int32x4_t) __builtin_neon_vqrdmulhq_laneq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vqtbx3_s8(int8x8_t __p0, int8x16x3_t __p1, uint8x8_t __p2) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vqtbx3_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x8_t)__p2, 0);
- return __ret;
-}
+#define vqrdmulhq_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __s1 = __p1; \
+ __ret = (int16x8_t) __builtin_neon_vqrdmulhq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
+ __ret; \
+})
#else
-__ai int8x8_t vqtbx3_s8(int8x8_t __p0, int8x16x3_t __p1, uint8x8_t __p2) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16x3_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vqtbx3_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x8_t)__rev2, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrdmulhq_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x8_t __ret; \
+ int16x8_t __s0 = __p0; \
+ int16x8_t __s1 = __p1; \
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int16x8_t) __builtin_neon_vqrdmulhq_laneq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vqtbx4_p8(poly8x8_t __p0, poly8x16x4_t __p1, uint8x8_t __p2) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vqtbx4_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p1.val[3], (int8x8_t)__p2, 4);
- return __ret;
-}
+#define vqrdmulh_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x4_t __s1 = __p1; \
+ __ret = (int32x2_t) __builtin_neon_vqrdmulh_laneq_v((int8x8_t)__s0, (int8x16_t)__s1, __p2, 2); \
+ __ret; \
+})
#else
-__ai poly8x8_t vqtbx4_p8(poly8x8_t __p0, poly8x16x4_t __p1, uint8x8_t __p2) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16x4_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vqtbx4_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], (int8x8_t)__rev2, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrdmulh_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
+ int32x2_t __ret; \
+ int32x2_t __s0 = __p0; \
+ int32x4_t __s1 = __p1; \
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+ __ret = (int32x2_t) __builtin_neon_vqrdmulh_laneq_v((int8x8_t)__rev0, (int8x16_t)__rev1, __p2, 2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vqtbx4q_p8(poly8x16_t __p0, poly8x16x4_t __p1, uint8x16_t __p2) {
- poly8x16_t __ret;
- __ret = (poly8x16_t) __builtin_neon_vqtbx4q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p1.val[3], (int8x16_t)__p2, 36);
- return __ret;
-}
+#define vqrdmulh_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x8_t __s1 = __p1; \
+ __ret = (int16x4_t) __builtin_neon_vqrdmulh_laneq_v((int8x8_t)__s0, (int8x16_t)__s1, __p2, 1); \
+ __ret; \
+})
#else
-__ai poly8x16_t vqtbx4q_p8(poly8x16_t __p0, poly8x16x4_t __p1, uint8x16_t __p2) {
- poly8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16x4_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x16_t) __builtin_neon_vqtbx4q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], (int8x16_t)__rev2, 36);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrdmulh_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
+ int16x4_t __ret; \
+ int16x4_t __s0 = __p0; \
+ int16x8_t __s1 = __p1; \
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret = (int16x4_t) __builtin_neon_vqrdmulh_laneq_v((int8x8_t)__rev0, (int8x16_t)__rev1, __p2, 1); \
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+ __ret; \
+})
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vqtbx4q_u8(uint8x16_t __p0, uint8x16x4_t __p1, uint8x16_t __p2) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vqtbx4q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p1.val[3], (int8x16_t)__p2, 48);
+__ai __attribute__((target("neon"))) uint8_t vqrshlb_u8(uint8_t __p0, int8_t __p1) {
+ uint8_t __ret;
+ __ret = (uint8_t) __builtin_neon_vqrshlb_u8(__p0, __p1);
return __ret;
}
-#else
-__ai uint8x16_t vqtbx4q_u8(uint8x16_t __p0, uint8x16x4_t __p1, uint8x16_t __p2) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16x4_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vqtbx4q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], (int8x16_t)__rev2, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32_t vqrshls_u32(uint32_t __p0, int32_t __p1) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vqrshls_u32(__p0, __p1);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vqtbx4q_s8(int8x16_t __p0, int8x16x4_t __p1, uint8x16_t __p2) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vqtbx4q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p1.val[3], (int8x16_t)__p2, 32);
+__ai __attribute__((target("neon"))) uint64_t vqrshld_u64(uint64_t __p0, int64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vqrshld_u64(__p0, __p1);
return __ret;
}
-#else
-__ai int8x16_t vqtbx4q_s8(int8x16_t __p0, int8x16x4_t __p1, uint8x16_t __p2) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16x4_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vqtbx4q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], (int8x16_t)__rev2, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint16_t vqrshlh_u16(uint16_t __p0, int16_t __p1) {
+ uint16_t __ret;
+ __ret = (uint16_t) __builtin_neon_vqrshlh_u16(__p0, __p1);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vqtbx4_u8(uint8x8_t __p0, uint8x16x4_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vqtbx4_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p1.val[3], (int8x8_t)__p2, 16);
+__ai __attribute__((target("neon"))) int8_t vqrshlb_s8(int8_t __p0, int8_t __p1) {
+ int8_t __ret;
+ __ret = (int8_t) __builtin_neon_vqrshlb_s8(__p0, __p1);
return __ret;
}
-#else
-__ai uint8x8_t vqtbx4_u8(uint8x8_t __p0, uint8x16x4_t __p1, uint8x8_t __p2) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16x4_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vqtbx4_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], (int8x8_t)__rev2, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32_t vqrshls_s32(int32_t __p0, int32_t __p1) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vqrshls_s32(__p0, __p1);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vqtbx4_s8(int8x8_t __p0, int8x16x4_t __p1, uint8x8_t __p2) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vqtbx4_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p1.val[3], (int8x8_t)__p2, 0);
+__ai __attribute__((target("neon"))) int64_t vqrshld_s64(int64_t __p0, int64_t __p1) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vqrshld_s64(__p0, __p1);
return __ret;
}
-#else
-__ai int8x8_t vqtbx4_s8(int8x8_t __p0, int8x16x4_t __p1, uint8x8_t __p2) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16x4_t __rev1;
- __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vqtbx4_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], (int8x8_t)__rev2, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int16_t vqrshlh_s16(int16_t __p0, int16_t __p1) {
+ int16_t __ret;
+ __ret = (int16_t) __builtin_neon_vqrshlh_s16(__p0, __p1);
return __ret;
}
-#endif
-
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vraddhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
- uint16x8_t __ret;
- __ret = vcombine_u16(__p0, vraddhn_u32(__p1, __p2));
- return __ret;
-}
+#define vqrshrn_high_n_u32(__p0_688, __p1_688, __p2_688) __extension__ ({ \
+ uint16x8_t __ret_688; \
+ uint16x4_t __s0_688 = __p0_688; \
+ uint32x4_t __s1_688 = __p1_688; \
+ __ret_688 = (uint16x8_t)(vcombine_u16((uint16x4_t)(__s0_688), (uint16x4_t)(vqrshrn_n_u32(__s1_688, __p2_688)))); \
+ __ret_688; \
+})
#else
-__ai uint16x8_t vraddhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
- uint16x8_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- uint32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __noswap_vcombine_u16(__rev0, __noswap_vraddhn_u32(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrshrn_high_n_u32(__p0_689, __p1_689, __p2_689) __extension__ ({ \
+ uint16x8_t __ret_689; \
+ uint16x4_t __s0_689 = __p0_689; \
+ uint32x4_t __s1_689 = __p1_689; \
+ uint16x4_t __rev0_689; __rev0_689 = __builtin_shufflevector(__s0_689, __s0_689, 3, 2, 1, 0); \
+ uint32x4_t __rev1_689; __rev1_689 = __builtin_shufflevector(__s1_689, __s1_689, 3, 2, 1, 0); \
+ __ret_689 = (uint16x8_t)(__noswap_vcombine_u16((uint16x4_t)(__rev0_689), (uint16x4_t)(__noswap_vqrshrn_n_u32(__rev1_689, __p2_689)))); \
+ __ret_689 = __builtin_shufflevector(__ret_689, __ret_689, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_689; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vraddhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
- uint32x4_t __ret;
- __ret = vcombine_u32(__p0, vraddhn_u64(__p1, __p2));
- return __ret;
-}
+#define vqrshrn_high_n_u64(__p0_690, __p1_690, __p2_690) __extension__ ({ \
+ uint32x4_t __ret_690; \
+ uint32x2_t __s0_690 = __p0_690; \
+ uint64x2_t __s1_690 = __p1_690; \
+ __ret_690 = (uint32x4_t)(vcombine_u32((uint32x2_t)(__s0_690), (uint32x2_t)(vqrshrn_n_u64(__s1_690, __p2_690)))); \
+ __ret_690; \
+})
#else
-__ai uint32x4_t vraddhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
- uint32x4_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- uint64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = __noswap_vcombine_u32(__rev0, __noswap_vraddhn_u64(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrshrn_high_n_u64(__p0_691, __p1_691, __p2_691) __extension__ ({ \
+ uint32x4_t __ret_691; \
+ uint32x2_t __s0_691 = __p0_691; \
+ uint64x2_t __s1_691 = __p1_691; \
+ uint32x2_t __rev0_691; __rev0_691 = __builtin_shufflevector(__s0_691, __s0_691, 1, 0); \
+ uint64x2_t __rev1_691; __rev1_691 = __builtin_shufflevector(__s1_691, __s1_691, 1, 0); \
+ __ret_691 = (uint32x4_t)(__noswap_vcombine_u32((uint32x2_t)(__rev0_691), (uint32x2_t)(__noswap_vqrshrn_n_u64(__rev1_691, __p2_691)))); \
+ __ret_691 = __builtin_shufflevector(__ret_691, __ret_691, 3, 2, 1, 0); \
+ __ret_691; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vraddhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
- uint8x16_t __ret;
- __ret = vcombine_u8(__p0, vraddhn_u16(__p1, __p2));
- return __ret;
-}
+#define vqrshrn_high_n_u16(__p0_692, __p1_692, __p2_692) __extension__ ({ \
+ uint8x16_t __ret_692; \
+ uint8x8_t __s0_692 = __p0_692; \
+ uint16x8_t __s1_692 = __p1_692; \
+ __ret_692 = (uint8x16_t)(vcombine_u8((uint8x8_t)(__s0_692), (uint8x8_t)(vqrshrn_n_u16(__s1_692, __p2_692)))); \
+ __ret_692; \
+})
#else
-__ai uint8x16_t vraddhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
- uint8x16_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vcombine_u8(__rev0, __noswap_vraddhn_u16(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrshrn_high_n_u16(__p0_693, __p1_693, __p2_693) __extension__ ({ \
+ uint8x16_t __ret_693; \
+ uint8x8_t __s0_693 = __p0_693; \
+ uint16x8_t __s1_693 = __p1_693; \
+ uint8x8_t __rev0_693; __rev0_693 = __builtin_shufflevector(__s0_693, __s0_693, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev1_693; __rev1_693 = __builtin_shufflevector(__s1_693, __s1_693, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_693 = (uint8x16_t)(__noswap_vcombine_u8((uint8x8_t)(__rev0_693), (uint8x8_t)(__noswap_vqrshrn_n_u16(__rev1_693, __p2_693)))); \
+ __ret_693 = __builtin_shufflevector(__ret_693, __ret_693, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_693; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vraddhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int16x8_t __ret;
- __ret = vcombine_s16(__p0, vraddhn_s32(__p1, __p2));
- return __ret;
-}
+#define vqrshrn_high_n_s32(__p0_694, __p1_694, __p2_694) __extension__ ({ \
+ int16x8_t __ret_694; \
+ int16x4_t __s0_694 = __p0_694; \
+ int32x4_t __s1_694 = __p1_694; \
+ __ret_694 = (int16x8_t)(vcombine_s16((int16x4_t)(__s0_694), (int16x4_t)(vqrshrn_n_s32(__s1_694, __p2_694)))); \
+ __ret_694; \
+})
#else
-__ai int16x8_t vraddhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int16x8_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __noswap_vcombine_s16(__rev0, __noswap_vraddhn_s32(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrshrn_high_n_s32(__p0_695, __p1_695, __p2_695) __extension__ ({ \
+ int16x8_t __ret_695; \
+ int16x4_t __s0_695 = __p0_695; \
+ int32x4_t __s1_695 = __p1_695; \
+ int16x4_t __rev0_695; __rev0_695 = __builtin_shufflevector(__s0_695, __s0_695, 3, 2, 1, 0); \
+ int32x4_t __rev1_695; __rev1_695 = __builtin_shufflevector(__s1_695, __s1_695, 3, 2, 1, 0); \
+ __ret_695 = (int16x8_t)(__noswap_vcombine_s16((int16x4_t)(__rev0_695), (int16x4_t)(__noswap_vqrshrn_n_s32(__rev1_695, __p2_695)))); \
+ __ret_695 = __builtin_shufflevector(__ret_695, __ret_695, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_695; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vraddhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
- int32x4_t __ret;
- __ret = vcombine_s32(__p0, vraddhn_s64(__p1, __p2));
- return __ret;
-}
+#define vqrshrn_high_n_s64(__p0_696, __p1_696, __p2_696) __extension__ ({ \
+ int32x4_t __ret_696; \
+ int32x2_t __s0_696 = __p0_696; \
+ int64x2_t __s1_696 = __p1_696; \
+ __ret_696 = (int32x4_t)(vcombine_s32((int32x2_t)(__s0_696), (int32x2_t)(vqrshrn_n_s64(__s1_696, __p2_696)))); \
+ __ret_696; \
+})
#else
-__ai int32x4_t vraddhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
- int32x4_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- int64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = __noswap_vcombine_s32(__rev0, __noswap_vraddhn_s64(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrshrn_high_n_s64(__p0_697, __p1_697, __p2_697) __extension__ ({ \
+ int32x4_t __ret_697; \
+ int32x2_t __s0_697 = __p0_697; \
+ int64x2_t __s1_697 = __p1_697; \
+ int32x2_t __rev0_697; __rev0_697 = __builtin_shufflevector(__s0_697, __s0_697, 1, 0); \
+ int64x2_t __rev1_697; __rev1_697 = __builtin_shufflevector(__s1_697, __s1_697, 1, 0); \
+ __ret_697 = (int32x4_t)(__noswap_vcombine_s32((int32x2_t)(__rev0_697), (int32x2_t)(__noswap_vqrshrn_n_s64(__rev1_697, __p2_697)))); \
+ __ret_697 = __builtin_shufflevector(__ret_697, __ret_697, 3, 2, 1, 0); \
+ __ret_697; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vraddhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int8x16_t __ret;
- __ret = vcombine_s8(__p0, vraddhn_s16(__p1, __p2));
- return __ret;
-}
+#define vqrshrn_high_n_s16(__p0_698, __p1_698, __p2_698) __extension__ ({ \
+ int8x16_t __ret_698; \
+ int8x8_t __s0_698 = __p0_698; \
+ int16x8_t __s1_698 = __p1_698; \
+ __ret_698 = (int8x16_t)(vcombine_s8((int8x8_t)(__s0_698), (int8x8_t)(vqrshrn_n_s16(__s1_698, __p2_698)))); \
+ __ret_698; \
+})
#else
-__ai int8x16_t vraddhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int8x16_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vcombine_s8(__rev0, __noswap_vraddhn_s16(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vqrshrn_high_n_s16(__p0_699, __p1_699, __p2_699) __extension__ ({ \
+ int8x16_t __ret_699; \
+ int8x8_t __s0_699 = __p0_699; \
+ int16x8_t __s1_699 = __p1_699; \
+ int8x8_t __rev0_699; __rev0_699 = __builtin_shufflevector(__s0_699, __s0_699, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1_699; __rev1_699 = __builtin_shufflevector(__s1_699, __s1_699, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_699 = (int8x16_t)(__noswap_vcombine_s8((int8x8_t)(__rev0_699), (int8x8_t)(__noswap_vqrshrn_n_s16(__rev1_699, __p2_699)))); \
+ __ret_699 = __builtin_shufflevector(__ret_699, __ret_699, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_699; \
+})
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vrbit_p8(poly8x8_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t) __builtin_neon_vrbit_v((int8x8_t)__p0, 4);
- return __ret;
-}
-#else
-__ai poly8x8_t vrbit_p8(poly8x8_t __p0) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x8_t) __builtin_neon_vrbit_v((int8x8_t)__rev0, 4);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+#define vqrshrns_n_u32(__p0, __p1) __extension__ ({ \
+ uint16_t __ret; \
+ uint32_t __s0 = __p0; \
+ __ret = (uint16_t) __builtin_neon_vqrshrns_n_u32(__s0, __p1); \
+ __ret; \
+})
+#define vqrshrnd_n_u64(__p0, __p1) __extension__ ({ \
+ uint32_t __ret; \
+ uint64_t __s0 = __p0; \
+ __ret = (uint32_t) __builtin_neon_vqrshrnd_n_u64(__s0, __p1); \
+ __ret; \
+})
+#define vqrshrnh_n_u16(__p0, __p1) __extension__ ({ \
+ uint8_t __ret; \
+ uint16_t __s0 = __p0; \
+ __ret = (uint8_t) __builtin_neon_vqrshrnh_n_u16(__s0, __p1); \
+ __ret; \
+})
+#define vqrshrns_n_s32(__p0, __p1) __extension__ ({ \
+ int16_t __ret; \
+ int32_t __s0 = __p0; \
+ __ret = (int16_t) __builtin_neon_vqrshrns_n_s32(__s0, __p1); \
+ __ret; \
+})
+#define vqrshrnd_n_s64(__p0, __p1) __extension__ ({ \
+ int32_t __ret; \
+ int64_t __s0 = __p0; \
+ __ret = (int32_t) __builtin_neon_vqrshrnd_n_s64(__s0, __p1); \
+ __ret; \
+})
+#define vqrshrnh_n_s16(__p0, __p1) __extension__ ({ \
+ int8_t __ret; \
+ int16_t __s0 = __p0; \
+ __ret = (int8_t) __builtin_neon_vqrshrnh_n_s16(__s0, __p1); \
+ __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrun_high_n_s32(__p0_700, __p1_700, __p2_700) __extension__ ({ \
+ int16x8_t __ret_700; \
+ int16x4_t __s0_700 = __p0_700; \
+ int32x4_t __s1_700 = __p1_700; \
+ __ret_700 = (int16x8_t)(vcombine_s16((int16x4_t)(__s0_700), (int16x4_t)(vqrshrun_n_s32(__s1_700, __p2_700)))); \
+ __ret_700; \
+})
+#else
+#define vqrshrun_high_n_s32(__p0_701, __p1_701, __p2_701) __extension__ ({ \
+ int16x8_t __ret_701; \
+ int16x4_t __s0_701 = __p0_701; \
+ int32x4_t __s1_701 = __p1_701; \
+ int16x4_t __rev0_701; __rev0_701 = __builtin_shufflevector(__s0_701, __s0_701, 3, 2, 1, 0); \
+ int32x4_t __rev1_701; __rev1_701 = __builtin_shufflevector(__s1_701, __s1_701, 3, 2, 1, 0); \
+ __ret_701 = (int16x8_t)(__noswap_vcombine_s16((int16x4_t)(__rev0_701), (int16x4_t)(__noswap_vqrshrun_n_s32(__rev1_701, __p2_701)))); \
+ __ret_701 = __builtin_shufflevector(__ret_701, __ret_701, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_701; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrun_high_n_s64(__p0_702, __p1_702, __p2_702) __extension__ ({ \
+ int32x4_t __ret_702; \
+ int32x2_t __s0_702 = __p0_702; \
+ int64x2_t __s1_702 = __p1_702; \
+ __ret_702 = (int32x4_t)(vcombine_s32((int32x2_t)(__s0_702), (int32x2_t)(vqrshrun_n_s64(__s1_702, __p2_702)))); \
+ __ret_702; \
+})
+#else
+#define vqrshrun_high_n_s64(__p0_703, __p1_703, __p2_703) __extension__ ({ \
+ int32x4_t __ret_703; \
+ int32x2_t __s0_703 = __p0_703; \
+ int64x2_t __s1_703 = __p1_703; \
+ int32x2_t __rev0_703; __rev0_703 = __builtin_shufflevector(__s0_703, __s0_703, 1, 0); \
+ int64x2_t __rev1_703; __rev1_703 = __builtin_shufflevector(__s1_703, __s1_703, 1, 0); \
+ __ret_703 = (int32x4_t)(__noswap_vcombine_s32((int32x2_t)(__rev0_703), (int32x2_t)(__noswap_vqrshrun_n_s64(__rev1_703, __p2_703)))); \
+ __ret_703 = __builtin_shufflevector(__ret_703, __ret_703, 3, 2, 1, 0); \
+ __ret_703; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrun_high_n_s16(__p0_704, __p1_704, __p2_704) __extension__ ({ \
+ int8x16_t __ret_704; \
+ int8x8_t __s0_704 = __p0_704; \
+ int16x8_t __s1_704 = __p1_704; \
+ __ret_704 = (int8x16_t)(vcombine_s8((int8x8_t)(__s0_704), (int8x8_t)(vqrshrun_n_s16(__s1_704, __p2_704)))); \
+ __ret_704; \
+})
+#else
+#define vqrshrun_high_n_s16(__p0_705, __p1_705, __p2_705) __extension__ ({ \
+ int8x16_t __ret_705; \
+ int8x8_t __s0_705 = __p0_705; \
+ int16x8_t __s1_705 = __p1_705; \
+ int8x8_t __rev0_705; __rev0_705 = __builtin_shufflevector(__s0_705, __s0_705, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1_705; __rev1_705 = __builtin_shufflevector(__s1_705, __s1_705, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_705 = (int8x16_t)(__noswap_vcombine_s8((int8x8_t)(__rev0_705), (int8x8_t)(__noswap_vqrshrun_n_s16(__rev1_705, __p2_705)))); \
+ __ret_705 = __builtin_shufflevector(__ret_705, __ret_705, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_705; \
+})
+#endif
+
+#define vqrshruns_n_s32(__p0, __p1) __extension__ ({ \
+ uint16_t __ret; \
+ int32_t __s0 = __p0; \
+ __ret = (uint16_t) __builtin_neon_vqrshruns_n_s32(__s0, __p1); \
+ __ret; \
+})
+#define vqrshrund_n_s64(__p0, __p1) __extension__ ({ \
+ uint32_t __ret; \
+ int64_t __s0 = __p0; \
+ __ret = (uint32_t) __builtin_neon_vqrshrund_n_s64(__s0, __p1); \
+ __ret; \
+})
+#define vqrshrunh_n_s16(__p0, __p1) __extension__ ({ \
+ uint8_t __ret; \
+ int16_t __s0 = __p0; \
+ __ret = (uint8_t) __builtin_neon_vqrshrunh_n_s16(__s0, __p1); \
+ __ret; \
+})
+__ai __attribute__((target("neon"))) uint8_t vqshlb_u8(uint8_t __p0, int8_t __p1) {
+ uint8_t __ret;
+ __ret = (uint8_t) __builtin_neon_vqshlb_u8(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vqshls_u32(uint32_t __p0, int32_t __p1) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vqshls_u32(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vqshld_u64(uint64_t __p0, int64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vqshld_u64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16_t vqshlh_u16(uint16_t __p0, int16_t __p1) {
+ uint16_t __ret;
+ __ret = (uint16_t) __builtin_neon_vqshlh_u16(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8_t vqshlb_s8(int8_t __p0, int8_t __p1) {
+ int8_t __ret;
+ __ret = (int8_t) __builtin_neon_vqshlb_s8(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vqshls_s32(int32_t __p0, int32_t __p1) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vqshls_s32(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vqshld_s64(int64_t __p0, int64_t __p1) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vqshld_s64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16_t vqshlh_s16(int16_t __p0, int16_t __p1) {
+ int16_t __ret;
+ __ret = (int16_t) __builtin_neon_vqshlh_s16(__p0, __p1);
+ return __ret;
+}
+#define vqshlb_n_u8(__p0, __p1) __extension__ ({ \
+ uint8_t __ret; \
+ uint8_t __s0 = __p0; \
+ __ret = (uint8_t) __builtin_neon_vqshlb_n_u8(__s0, __p1); \
+ __ret; \
+})
+#define vqshls_n_u32(__p0, __p1) __extension__ ({ \
+ uint32_t __ret; \
+ uint32_t __s0 = __p0; \
+ __ret = (uint32_t) __builtin_neon_vqshls_n_u32(__s0, __p1); \
+ __ret; \
+})
+#define vqshld_n_u64(__p0, __p1) __extension__ ({ \
+ uint64_t __ret; \
+ uint64_t __s0 = __p0; \
+ __ret = (uint64_t) __builtin_neon_vqshld_n_u64(__s0, __p1); \
+ __ret; \
+})
+#define vqshlh_n_u16(__p0, __p1) __extension__ ({ \
+ uint16_t __ret; \
+ uint16_t __s0 = __p0; \
+ __ret = (uint16_t) __builtin_neon_vqshlh_n_u16(__s0, __p1); \
+ __ret; \
+})
+#define vqshlb_n_s8(__p0, __p1) __extension__ ({ \
+ int8_t __ret; \
+ int8_t __s0 = __p0; \
+ __ret = (int8_t) __builtin_neon_vqshlb_n_s8(__s0, __p1); \
+ __ret; \
+})
+#define vqshls_n_s32(__p0, __p1) __extension__ ({ \
+ int32_t __ret; \
+ int32_t __s0 = __p0; \
+ __ret = (int32_t) __builtin_neon_vqshls_n_s32(__s0, __p1); \
+ __ret; \
+})
+#define vqshld_n_s64(__p0, __p1) __extension__ ({ \
+ int64_t __ret; \
+ int64_t __s0 = __p0; \
+ __ret = (int64_t) __builtin_neon_vqshld_n_s64(__s0, __p1); \
+ __ret; \
+})
+#define vqshlh_n_s16(__p0, __p1) __extension__ ({ \
+ int16_t __ret; \
+ int16_t __s0 = __p0; \
+ __ret = (int16_t) __builtin_neon_vqshlh_n_s16(__s0, __p1); \
+ __ret; \
+})
+#define vqshlub_n_s8(__p0, __p1) __extension__ ({ \
+ int8_t __ret; \
+ int8_t __s0 = __p0; \
+ __ret = (int8_t) __builtin_neon_vqshlub_n_s8(__s0, __p1); \
+ __ret; \
+})
+#define vqshlus_n_s32(__p0, __p1) __extension__ ({ \
+ int32_t __ret; \
+ int32_t __s0 = __p0; \
+ __ret = (int32_t) __builtin_neon_vqshlus_n_s32(__s0, __p1); \
+ __ret; \
+})
+#define vqshlud_n_s64(__p0, __p1) __extension__ ({ \
+ int64_t __ret; \
+ int64_t __s0 = __p0; \
+ __ret = (int64_t) __builtin_neon_vqshlud_n_s64(__s0, __p1); \
+ __ret; \
+})
+#define vqshluh_n_s16(__p0, __p1) __extension__ ({ \
+ int16_t __ret; \
+ int16_t __s0 = __p0; \
+ __ret = (int16_t) __builtin_neon_vqshluh_n_s16(__s0, __p1); \
+ __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_high_n_u32(__p0_706, __p1_706, __p2_706) __extension__ ({ \
+ uint16x8_t __ret_706; \
+ uint16x4_t __s0_706 = __p0_706; \
+ uint32x4_t __s1_706 = __p1_706; \
+ __ret_706 = (uint16x8_t)(vcombine_u16((uint16x4_t)(__s0_706), (uint16x4_t)(vqshrn_n_u32(__s1_706, __p2_706)))); \
+ __ret_706; \
+})
+#else
+#define vqshrn_high_n_u32(__p0_707, __p1_707, __p2_707) __extension__ ({ \
+ uint16x8_t __ret_707; \
+ uint16x4_t __s0_707 = __p0_707; \
+ uint32x4_t __s1_707 = __p1_707; \
+ uint16x4_t __rev0_707; __rev0_707 = __builtin_shufflevector(__s0_707, __s0_707, 3, 2, 1, 0); \
+ uint32x4_t __rev1_707; __rev1_707 = __builtin_shufflevector(__s1_707, __s1_707, 3, 2, 1, 0); \
+ __ret_707 = (uint16x8_t)(__noswap_vcombine_u16((uint16x4_t)(__rev0_707), (uint16x4_t)(__noswap_vqshrn_n_u32(__rev1_707, __p2_707)))); \
+ __ret_707 = __builtin_shufflevector(__ret_707, __ret_707, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_707; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_high_n_u64(__p0_708, __p1_708, __p2_708) __extension__ ({ \
+ uint32x4_t __ret_708; \
+ uint32x2_t __s0_708 = __p0_708; \
+ uint64x2_t __s1_708 = __p1_708; \
+ __ret_708 = (uint32x4_t)(vcombine_u32((uint32x2_t)(__s0_708), (uint32x2_t)(vqshrn_n_u64(__s1_708, __p2_708)))); \
+ __ret_708; \
+})
+#else
+#define vqshrn_high_n_u64(__p0_709, __p1_709, __p2_709) __extension__ ({ \
+ uint32x4_t __ret_709; \
+ uint32x2_t __s0_709 = __p0_709; \
+ uint64x2_t __s1_709 = __p1_709; \
+ uint32x2_t __rev0_709; __rev0_709 = __builtin_shufflevector(__s0_709, __s0_709, 1, 0); \
+ uint64x2_t __rev1_709; __rev1_709 = __builtin_shufflevector(__s1_709, __s1_709, 1, 0); \
+ __ret_709 = (uint32x4_t)(__noswap_vcombine_u32((uint32x2_t)(__rev0_709), (uint32x2_t)(__noswap_vqshrn_n_u64(__rev1_709, __p2_709)))); \
+ __ret_709 = __builtin_shufflevector(__ret_709, __ret_709, 3, 2, 1, 0); \
+ __ret_709; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_high_n_u16(__p0_710, __p1_710, __p2_710) __extension__ ({ \
+ uint8x16_t __ret_710; \
+ uint8x8_t __s0_710 = __p0_710; \
+ uint16x8_t __s1_710 = __p1_710; \
+ __ret_710 = (uint8x16_t)(vcombine_u8((uint8x8_t)(__s0_710), (uint8x8_t)(vqshrn_n_u16(__s1_710, __p2_710)))); \
+ __ret_710; \
+})
+#else
+#define vqshrn_high_n_u16(__p0_711, __p1_711, __p2_711) __extension__ ({ \
+ uint8x16_t __ret_711; \
+ uint8x8_t __s0_711 = __p0_711; \
+ uint16x8_t __s1_711 = __p1_711; \
+ uint8x8_t __rev0_711; __rev0_711 = __builtin_shufflevector(__s0_711, __s0_711, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev1_711; __rev1_711 = __builtin_shufflevector(__s1_711, __s1_711, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_711 = (uint8x16_t)(__noswap_vcombine_u8((uint8x8_t)(__rev0_711), (uint8x8_t)(__noswap_vqshrn_n_u16(__rev1_711, __p2_711)))); \
+ __ret_711 = __builtin_shufflevector(__ret_711, __ret_711, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_711; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_high_n_s32(__p0_712, __p1_712, __p2_712) __extension__ ({ \
+ int16x8_t __ret_712; \
+ int16x4_t __s0_712 = __p0_712; \
+ int32x4_t __s1_712 = __p1_712; \
+ __ret_712 = (int16x8_t)(vcombine_s16((int16x4_t)(__s0_712), (int16x4_t)(vqshrn_n_s32(__s1_712, __p2_712)))); \
+ __ret_712; \
+})
+#else
+#define vqshrn_high_n_s32(__p0_713, __p1_713, __p2_713) __extension__ ({ \
+ int16x8_t __ret_713; \
+ int16x4_t __s0_713 = __p0_713; \
+ int32x4_t __s1_713 = __p1_713; \
+ int16x4_t __rev0_713; __rev0_713 = __builtin_shufflevector(__s0_713, __s0_713, 3, 2, 1, 0); \
+ int32x4_t __rev1_713; __rev1_713 = __builtin_shufflevector(__s1_713, __s1_713, 3, 2, 1, 0); \
+ __ret_713 = (int16x8_t)(__noswap_vcombine_s16((int16x4_t)(__rev0_713), (int16x4_t)(__noswap_vqshrn_n_s32(__rev1_713, __p2_713)))); \
+ __ret_713 = __builtin_shufflevector(__ret_713, __ret_713, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_713; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_high_n_s64(__p0_714, __p1_714, __p2_714) __extension__ ({ \
+ int32x4_t __ret_714; \
+ int32x2_t __s0_714 = __p0_714; \
+ int64x2_t __s1_714 = __p1_714; \
+ __ret_714 = (int32x4_t)(vcombine_s32((int32x2_t)(__s0_714), (int32x2_t)(vqshrn_n_s64(__s1_714, __p2_714)))); \
+ __ret_714; \
+})
+#else
+#define vqshrn_high_n_s64(__p0_715, __p1_715, __p2_715) __extension__ ({ \
+ int32x4_t __ret_715; \
+ int32x2_t __s0_715 = __p0_715; \
+ int64x2_t __s1_715 = __p1_715; \
+ int32x2_t __rev0_715; __rev0_715 = __builtin_shufflevector(__s0_715, __s0_715, 1, 0); \
+ int64x2_t __rev1_715; __rev1_715 = __builtin_shufflevector(__s1_715, __s1_715, 1, 0); \
+ __ret_715 = (int32x4_t)(__noswap_vcombine_s32((int32x2_t)(__rev0_715), (int32x2_t)(__noswap_vqshrn_n_s64(__rev1_715, __p2_715)))); \
+ __ret_715 = __builtin_shufflevector(__ret_715, __ret_715, 3, 2, 1, 0); \
+ __ret_715; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_high_n_s16(__p0_716, __p1_716, __p2_716) __extension__ ({ \
+ int8x16_t __ret_716; \
+ int8x8_t __s0_716 = __p0_716; \
+ int16x8_t __s1_716 = __p1_716; \
+ __ret_716 = (int8x16_t)(vcombine_s8((int8x8_t)(__s0_716), (int8x8_t)(vqshrn_n_s16(__s1_716, __p2_716)))); \
+ __ret_716; \
+})
+#else
+#define vqshrn_high_n_s16(__p0_717, __p1_717, __p2_717) __extension__ ({ \
+ int8x16_t __ret_717; \
+ int8x8_t __s0_717 = __p0_717; \
+ int16x8_t __s1_717 = __p1_717; \
+ int8x8_t __rev0_717; __rev0_717 = __builtin_shufflevector(__s0_717, __s0_717, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1_717; __rev1_717 = __builtin_shufflevector(__s1_717, __s1_717, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_717 = (int8x16_t)(__noswap_vcombine_s8((int8x8_t)(__rev0_717), (int8x8_t)(__noswap_vqshrn_n_s16(__rev1_717, __p2_717)))); \
+ __ret_717 = __builtin_shufflevector(__ret_717, __ret_717, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_717; \
+})
+#endif
+
+#define vqshrns_n_u32(__p0, __p1) __extension__ ({ \
+ uint16_t __ret; \
+ uint32_t __s0 = __p0; \
+ __ret = (uint16_t) __builtin_neon_vqshrns_n_u32(__s0, __p1); \
+ __ret; \
+})
+#define vqshrnd_n_u64(__p0, __p1) __extension__ ({ \
+ uint32_t __ret; \
+ uint64_t __s0 = __p0; \
+ __ret = (uint32_t) __builtin_neon_vqshrnd_n_u64(__s0, __p1); \
+ __ret; \
+})
+#define vqshrnh_n_u16(__p0, __p1) __extension__ ({ \
+ uint8_t __ret; \
+ uint16_t __s0 = __p0; \
+ __ret = (uint8_t) __builtin_neon_vqshrnh_n_u16(__s0, __p1); \
+ __ret; \
+})
+#define vqshrns_n_s32(__p0, __p1) __extension__ ({ \
+ int16_t __ret; \
+ int32_t __s0 = __p0; \
+ __ret = (int16_t) __builtin_neon_vqshrns_n_s32(__s0, __p1); \
+ __ret; \
+})
+#define vqshrnd_n_s64(__p0, __p1) __extension__ ({ \
+ int32_t __ret; \
+ int64_t __s0 = __p0; \
+ __ret = (int32_t) __builtin_neon_vqshrnd_n_s64(__s0, __p1); \
+ __ret; \
+})
+#define vqshrnh_n_s16(__p0, __p1) __extension__ ({ \
+ int8_t __ret; \
+ int16_t __s0 = __p0; \
+ __ret = (int8_t) __builtin_neon_vqshrnh_n_s16(__s0, __p1); \
+ __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vqshrun_high_n_s32(__p0_718, __p1_718, __p2_718) __extension__ ({ \
+ int16x8_t __ret_718; \
+ int16x4_t __s0_718 = __p0_718; \
+ int32x4_t __s1_718 = __p1_718; \
+ __ret_718 = (int16x8_t)(vcombine_s16((int16x4_t)(__s0_718), (int16x4_t)(vqshrun_n_s32(__s1_718, __p2_718)))); \
+ __ret_718; \
+})
+#else
+#define vqshrun_high_n_s32(__p0_719, __p1_719, __p2_719) __extension__ ({ \
+ int16x8_t __ret_719; \
+ int16x4_t __s0_719 = __p0_719; \
+ int32x4_t __s1_719 = __p1_719; \
+ int16x4_t __rev0_719; __rev0_719 = __builtin_shufflevector(__s0_719, __s0_719, 3, 2, 1, 0); \
+ int32x4_t __rev1_719; __rev1_719 = __builtin_shufflevector(__s1_719, __s1_719, 3, 2, 1, 0); \
+ __ret_719 = (int16x8_t)(__noswap_vcombine_s16((int16x4_t)(__rev0_719), (int16x4_t)(__noswap_vqshrun_n_s32(__rev1_719, __p2_719)))); \
+ __ret_719 = __builtin_shufflevector(__ret_719, __ret_719, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_719; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrun_high_n_s64(__p0_720, __p1_720, __p2_720) __extension__ ({ \
+ int32x4_t __ret_720; \
+ int32x2_t __s0_720 = __p0_720; \
+ int64x2_t __s1_720 = __p1_720; \
+ __ret_720 = (int32x4_t)(vcombine_s32((int32x2_t)(__s0_720), (int32x2_t)(vqshrun_n_s64(__s1_720, __p2_720)))); \
+ __ret_720; \
+})
+#else
+#define vqshrun_high_n_s64(__p0_721, __p1_721, __p2_721) __extension__ ({ \
+ int32x4_t __ret_721; \
+ int32x2_t __s0_721 = __p0_721; \
+ int64x2_t __s1_721 = __p1_721; \
+ int32x2_t __rev0_721; __rev0_721 = __builtin_shufflevector(__s0_721, __s0_721, 1, 0); \
+ int64x2_t __rev1_721; __rev1_721 = __builtin_shufflevector(__s1_721, __s1_721, 1, 0); \
+ __ret_721 = (int32x4_t)(__noswap_vcombine_s32((int32x2_t)(__rev0_721), (int32x2_t)(__noswap_vqshrun_n_s64(__rev1_721, __p2_721)))); \
+ __ret_721 = __builtin_shufflevector(__ret_721, __ret_721, 3, 2, 1, 0); \
+ __ret_721; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrun_high_n_s16(__p0_722, __p1_722, __p2_722) __extension__ ({ \
+ int8x16_t __ret_722; \
+ int8x8_t __s0_722 = __p0_722; \
+ int16x8_t __s1_722 = __p1_722; \
+ __ret_722 = (int8x16_t)(vcombine_s8((int8x8_t)(__s0_722), (int8x8_t)(vqshrun_n_s16(__s1_722, __p2_722)))); \
+ __ret_722; \
+})
+#else
+#define vqshrun_high_n_s16(__p0_723, __p1_723, __p2_723) __extension__ ({ \
+ int8x16_t __ret_723; \
+ int8x8_t __s0_723 = __p0_723; \
+ int16x8_t __s1_723 = __p1_723; \
+ int8x8_t __rev0_723; __rev0_723 = __builtin_shufflevector(__s0_723, __s0_723, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1_723; __rev1_723 = __builtin_shufflevector(__s1_723, __s1_723, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_723 = (int8x16_t)(__noswap_vcombine_s8((int8x8_t)(__rev0_723), (int8x8_t)(__noswap_vqshrun_n_s16(__rev1_723, __p2_723)))); \
+ __ret_723 = __builtin_shufflevector(__ret_723, __ret_723, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_723; \
+})
+#endif
+
+#define vqshruns_n_s32(__p0, __p1) __extension__ ({ \
+ uint16_t __ret; \
+ int32_t __s0 = __p0; \
+ __ret = (uint16_t) __builtin_neon_vqshruns_n_s32(__s0, __p1); \
+ __ret; \
+})
+#define vqshrund_n_s64(__p0, __p1) __extension__ ({ \
+ uint32_t __ret; \
+ int64_t __s0 = __p0; \
+ __ret = (uint32_t) __builtin_neon_vqshrund_n_s64(__s0, __p1); \
+ __ret; \
+})
+#define vqshrunh_n_s16(__p0, __p1) __extension__ ({ \
+ uint8_t __ret; \
+ int16_t __s0 = __p0; \
+ __ret = (uint8_t) __builtin_neon_vqshrunh_n_s16(__s0, __p1); \
+ __ret; \
+})
+__ai __attribute__((target("neon"))) uint8_t vqsubb_u8(uint8_t __p0, uint8_t __p1) {
+ uint8_t __ret;
+ __ret = (uint8_t) __builtin_neon_vqsubb_u8(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vqsubs_u32(uint32_t __p0, uint32_t __p1) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vqsubs_u32(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vqsubd_u64(uint64_t __p0, uint64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vqsubd_u64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16_t vqsubh_u16(uint16_t __p0, uint16_t __p1) {
+ uint16_t __ret;
+ __ret = (uint16_t) __builtin_neon_vqsubh_u16(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8_t vqsubb_s8(int8_t __p0, int8_t __p1) {
+ int8_t __ret;
+ __ret = (int8_t) __builtin_neon_vqsubb_s8(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vqsubs_s32(int32_t __p0, int32_t __p1) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vqsubs_s32(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vqsubd_s64(int64_t __p0, int64_t __p1) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vqsubd_s64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16_t vqsubh_s16(int16_t __p0, int16_t __p1) {
+ int16_t __ret;
+ __ret = (int16_t) __builtin_neon_vqsubh_s16(__p0, __p1);
+ return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vqtbl1_p8(poly8x16_t __p0, uint8x8_t __p1) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) __builtin_neon_vqtbl1_v((int8x16_t)__p0, (int8x8_t)__p1, 4);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vqtbl1_p8(poly8x16_t __p0, uint8x8_t __p1) {
+ poly8x8_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vqtbl1_v((int8x16_t)__rev0, (int8x8_t)__rev1, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vrbitq_p8(poly8x16_t __p0) {
+__ai __attribute__((target("neon"))) poly8x16_t vqtbl1q_p8(poly8x16_t __p0, uint8x16_t __p1) {
poly8x16_t __ret;
- __ret = (poly8x16_t) __builtin_neon_vrbitq_v((int8x16_t)__p0, 36);
+ __ret = (poly8x16_t) __builtin_neon_vqtbl1q_v((int8x16_t)__p0, (int8x16_t)__p1, 36);
return __ret;
}
#else
-__ai poly8x16_t vrbitq_p8(poly8x16_t __p0) {
+__ai __attribute__((target("neon"))) poly8x16_t vqtbl1q_p8(poly8x16_t __p0, uint8x16_t __p1) {
poly8x16_t __ret;
poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (poly8x16_t) __builtin_neon_vrbitq_v((int8x16_t)__rev0, 36);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x16_t) __builtin_neon_vqtbl1q_v((int8x16_t)__rev0, (int8x16_t)__rev1, 36);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vrbitq_u8(uint8x16_t __p0) {
+__ai __attribute__((target("neon"))) uint8x16_t vqtbl1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vrbitq_v((int8x16_t)__p0, 48);
+ __ret = (uint8x16_t) __builtin_neon_vqtbl1q_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
return __ret;
}
#else
-__ai uint8x16_t vrbitq_u8(uint8x16_t __p0) {
+__ai __attribute__((target("neon"))) uint8x16_t vqtbl1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
uint8x16_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vrbitq_v((int8x16_t)__rev0, 48);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vqtbl1q_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vrbitq_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vqtbl1q_s8(int8x16_t __p0, uint8x16_t __p1) {
int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vrbitq_v((int8x16_t)__p0, 32);
+ __ret = (int8x16_t) __builtin_neon_vqtbl1q_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
return __ret;
}
#else
-__ai int8x16_t vrbitq_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vqtbl1q_s8(int8x16_t __p0, uint8x16_t __p1) {
int8x16_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vrbitq_v((int8x16_t)__rev0, 32);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vqtbl1q_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vrbit_u8(uint8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vqtbl1_u8(uint8x16_t __p0, uint8x8_t __p1) {
uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vrbit_v((int8x8_t)__p0, 16);
+ __ret = (uint8x8_t) __builtin_neon_vqtbl1_v((int8x16_t)__p0, (int8x8_t)__p1, 16);
return __ret;
}
#else
-__ai uint8x8_t vrbit_u8(uint8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vqtbl1_u8(uint8x16_t __p0, uint8x8_t __p1) {
uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vrbit_v((int8x8_t)__rev0, 16);
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vqtbl1_v((int8x16_t)__rev0, (int8x8_t)__rev1, 16);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vrbit_s8(int8x8_t __p0) {
+__ai __attribute__((target("neon"))) int8x8_t vqtbl1_s8(int8x16_t __p0, uint8x8_t __p1) {
int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vrbit_v((int8x8_t)__p0, 0);
+ __ret = (int8x8_t) __builtin_neon_vqtbl1_v((int8x16_t)__p0, (int8x8_t)__p1, 0);
return __ret;
}
#else
-__ai int8x8_t vrbit_s8(int8x8_t __p0) {
+__ai __attribute__((target("neon"))) int8x8_t vqtbl1_s8(int8x16_t __p0, uint8x8_t __p1) {
int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vrbit_v((int8x8_t)__rev0, 0);
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vqtbl1_v((int8x16_t)__rev0, (int8x8_t)__rev1, 0);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vrecpeq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vrecpeq_v((int8x16_t)__p0, 42);
+__ai __attribute__((target("neon"))) poly8x8_t vqtbl2_p8(poly8x16x2_t __p0, uint8x8_t __p1) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) __builtin_neon_vqtbl2_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x8_t)__p1, 4);
return __ret;
}
#else
-__ai float64x2_t vrecpeq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vrecpeq_v((int8x16_t)__rev0, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) poly8x8_t vqtbl2_p8(poly8x16x2_t __p0, uint8x8_t __p1) {
+ poly8x8_t __ret;
+ poly8x16x2_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vqtbl2_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x8_t)__rev1, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai float64x1_t vrecpe_f64(float64x1_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vrecpe_v((int8x8_t)__p0, 10);
- return __ret;
-}
-__ai float64_t vrecped_f64(float64_t __p0) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vrecped_f64(__p0);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vqtbl2q_p8(poly8x16x2_t __p0, uint8x16_t __p1) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t) __builtin_neon_vqtbl2q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p1, 36);
return __ret;
}
-__ai float32_t vrecpes_f32(float32_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vrecpes_f32(__p0);
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vqtbl2q_p8(poly8x16x2_t __p0, uint8x16_t __p1) {
+ poly8x16_t __ret;
+ poly8x16x2_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x16_t) __builtin_neon_vqtbl2q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev1, 36);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
+#endif
+
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vrecpsq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vrecpsq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+__ai __attribute__((target("neon"))) uint8x16_t vqtbl2q_u8(uint8x16x2_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vqtbl2q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p1, 48);
return __ret;
}
#else
-__ai float64x2_t vrecpsq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vrecpsq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vqtbl2q_u8(uint8x16x2_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16x2_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vqtbl2q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai float64x1_t vrecps_f64(float64x1_t __p0, float64x1_t __p1) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vrecps_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
- return __ret;
-}
-__ai float64_t vrecpsd_f64(float64_t __p0, float64_t __p1) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vrecpsd_f64(__p0, __p1);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqtbl2q_s8(int8x16x2_t __p0, uint8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vqtbl2q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p1, 32);
return __ret;
}
-__ai float32_t vrecpss_f32(float32_t __p0, float32_t __p1) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vrecpss_f32(__p0, __p1);
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqtbl2q_s8(int8x16x2_t __p0, uint8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16x2_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vqtbl2q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev1, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai float64_t vrecpxd_f64(float64_t __p0) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vrecpxd_f64(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqtbl2_u8(uint8x16x2_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vqtbl2_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x8_t)__p1, 16);
return __ret;
}
-__ai float32_t vrecpxs_f32(float32_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vrecpxs_f32(__p0);
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqtbl2_u8(uint8x16x2_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x16x2_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vqtbl2_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_p64(poly64x1_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqtbl2_s8(int8x16x2_t __p0, uint8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vqtbl2_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x8_t)__p1, 0);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_p16(poly16x4_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqtbl2_s8(int8x16x2_t __p0, uint8x8_t __p1) {
+ int8x8_t __ret;
+ int8x16x2_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vqtbl2_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_u8(uint8x8_t __p0) {
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vqtbl3_p8(poly8x16x3_t __p0, uint8x8_t __p1) {
poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+ __ret = (poly8x8_t) __builtin_neon_vqtbl3_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x8_t)__p1, 4);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_u32(uint32x2_t __p0) {
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vqtbl3_p8(poly8x16x3_t __p0, uint8x8_t __p1) {
poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+ poly8x16x3_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vqtbl3_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x8_t)__rev1, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_u64(uint64x1_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vqtbl3q_p8(poly8x16x3_t __p0, uint8x16_t __p1) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t) __builtin_neon_vqtbl3q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p1, 36);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_u16(uint16x4_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vqtbl3q_p8(poly8x16x3_t __p0, uint8x16_t __p1) {
+ poly8x16_t __ret;
+ poly8x16x3_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x16_t) __builtin_neon_vqtbl3q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev1, 36);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_s8(int8x8_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqtbl3q_u8(uint8x16x3_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vqtbl3q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p1, 48);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_f64(float64x1_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqtbl3q_u8(uint8x16x3_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16x3_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vqtbl3q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_f32(float32x2_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqtbl3q_s8(int8x16x3_t __p0, uint8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vqtbl3q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p1, 32);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_f16(float16x4_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqtbl3q_s8(int8x16x3_t __p0, uint8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16x3_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vqtbl3q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev1, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_s32(int32x2_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqtbl3_u8(uint8x16x3_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vqtbl3_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x8_t)__p1, 16);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_s64(int64x1_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqtbl3_u8(uint8x16x3_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x16x3_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vqtbl3_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly8x8_t vreinterpret_p8_s16(int16x4_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqtbl3_s8(int8x16x3_t __p0, uint8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vqtbl3_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x8_t)__p1, 0);
return __ret;
}
-__ai poly64x1_t vreinterpret_p64_p8(poly8x8_t __p0) {
- poly64x1_t __ret;
- __ret = (poly64x1_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqtbl3_s8(int8x16x3_t __p0, uint8x8_t __p1) {
+ int8x8_t __ret;
+ int8x16x3_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vqtbl3_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly64x1_t vreinterpret_p64_p16(poly16x4_t __p0) {
- poly64x1_t __ret;
- __ret = (poly64x1_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vqtbl4_p8(poly8x16x4_t __p0, uint8x8_t __p1) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) __builtin_neon_vqtbl4_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p0.val[3], (int8x8_t)__p1, 4);
return __ret;
}
-__ai poly64x1_t vreinterpret_p64_u8(uint8x8_t __p0) {
- poly64x1_t __ret;
- __ret = (poly64x1_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vqtbl4_p8(poly8x16x4_t __p0, uint8x8_t __p1) {
+ poly8x8_t __ret;
+ poly8x16x4_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vqtbl4_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev0.val[3], (int8x8_t)__rev1, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly64x1_t vreinterpret_p64_u32(uint32x2_t __p0) {
- poly64x1_t __ret;
- __ret = (poly64x1_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vqtbl4q_p8(poly8x16x4_t __p0, uint8x16_t __p1) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t) __builtin_neon_vqtbl4q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p0.val[3], (int8x16_t)__p1, 36);
return __ret;
}
-__ai poly64x1_t vreinterpret_p64_u64(uint64x1_t __p0) {
- poly64x1_t __ret;
- __ret = (poly64x1_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vqtbl4q_p8(poly8x16x4_t __p0, uint8x16_t __p1) {
+ poly8x16_t __ret;
+ poly8x16x4_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x16_t) __builtin_neon_vqtbl4q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev0.val[3], (int8x16_t)__rev1, 36);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly64x1_t vreinterpret_p64_u16(uint16x4_t __p0) {
- poly64x1_t __ret;
- __ret = (poly64x1_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqtbl4q_u8(uint8x16x4_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vqtbl4q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p0.val[3], (int8x16_t)__p1, 48);
return __ret;
}
-__ai poly64x1_t vreinterpret_p64_s8(int8x8_t __p0) {
- poly64x1_t __ret;
- __ret = (poly64x1_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqtbl4q_u8(uint8x16x4_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16x4_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vqtbl4q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev0.val[3], (int8x16_t)__rev1, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly64x1_t vreinterpret_p64_f64(float64x1_t __p0) {
- poly64x1_t __ret;
- __ret = (poly64x1_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqtbl4q_s8(int8x16x4_t __p0, uint8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vqtbl4q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p0.val[3], (int8x16_t)__p1, 32);
return __ret;
}
-__ai poly64x1_t vreinterpret_p64_f32(float32x2_t __p0) {
- poly64x1_t __ret;
- __ret = (poly64x1_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqtbl4q_s8(int8x16x4_t __p0, uint8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16x4_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vqtbl4q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev0.val[3], (int8x16_t)__rev1, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly64x1_t vreinterpret_p64_f16(float16x4_t __p0) {
- poly64x1_t __ret;
- __ret = (poly64x1_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqtbl4_u8(uint8x16x4_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vqtbl4_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p0.val[3], (int8x8_t)__p1, 16);
return __ret;
}
-__ai poly64x1_t vreinterpret_p64_s32(int32x2_t __p0) {
- poly64x1_t __ret;
- __ret = (poly64x1_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqtbl4_u8(uint8x16x4_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x16x4_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vqtbl4_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev0.val[3], (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly64x1_t vreinterpret_p64_s64(int64x1_t __p0) {
- poly64x1_t __ret;
- __ret = (poly64x1_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqtbl4_s8(int8x16x4_t __p0, uint8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vqtbl4_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p0.val[3], (int8x8_t)__p1, 0);
return __ret;
}
-__ai poly64x1_t vreinterpret_p64_s16(int16x4_t __p0) {
- poly64x1_t __ret;
- __ret = (poly64x1_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqtbl4_s8(int8x16x4_t __p0, uint8x8_t __p1) {
+ int8x8_t __ret;
+ int8x16x4_t __rev0;
+ __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vqtbl4_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev0.val[3], (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_p8(poly8x8_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vqtbx1_p8(poly8x8_t __p0, poly8x16_t __p1, uint8x8_t __p2) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) __builtin_neon_vqtbx1_v((int8x8_t)__p0, (int8x16_t)__p1, (int8x8_t)__p2, 4);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_p64(poly64x1_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vqtbx1_p8(poly8x8_t __p0, poly8x16_t __p1, uint8x8_t __p2) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vqtbx1_v((int8x8_t)__rev0, (int8x16_t)__rev1, (int8x8_t)__rev2, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_u8(uint8x8_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vqtbx1q_p8(poly8x16_t __p0, poly8x16_t __p1, uint8x16_t __p2) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t) __builtin_neon_vqtbx1q_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 36);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_u32(uint32x2_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vqtbx1q_p8(poly8x16_t __p0, poly8x16_t __p1, uint8x16_t __p2) {
+ poly8x16_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x16_t) __builtin_neon_vqtbx1q_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 36);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_u64(uint64x1_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqtbx1q_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vqtbx1q_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 48);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_u16(uint16x4_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqtbx1q_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vqtbx1q_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_s8(int8x8_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqtbx1q_s8(int8x16_t __p0, int8x16_t __p1, uint8x16_t __p2) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vqtbx1q_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 32);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_f64(float64x1_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqtbx1q_s8(int8x16_t __p0, int8x16_t __p1, uint8x16_t __p2) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vqtbx1q_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_f32(float32x2_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqtbx1_u8(uint8x8_t __p0, uint8x16_t __p1, uint8x8_t __p2) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vqtbx1_v((int8x8_t)__p0, (int8x16_t)__p1, (int8x8_t)__p2, 16);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_f16(float16x4_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqtbx1_u8(uint8x8_t __p0, uint8x16_t __p1, uint8x8_t __p2) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vqtbx1_v((int8x8_t)__rev0, (int8x16_t)__rev1, (int8x8_t)__rev2, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_s32(int32x2_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqtbx1_s8(int8x8_t __p0, int8x16_t __p1, uint8x8_t __p2) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vqtbx1_v((int8x8_t)__p0, (int8x16_t)__p1, (int8x8_t)__p2, 0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_s64(int64x1_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqtbx1_s8(int8x8_t __p0, int8x16_t __p1, uint8x8_t __p2) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vqtbx1_v((int8x8_t)__rev0, (int8x16_t)__rev1, (int8x8_t)__rev2, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly16x4_t vreinterpret_p16_s16(int16x4_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vqtbx2_p8(poly8x8_t __p0, poly8x16x2_t __p1, uint8x8_t __p2) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) __builtin_neon_vqtbx2_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x8_t)__p2, 4);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_p128(poly128_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vqtbx2_p8(poly8x8_t __p0, poly8x16x2_t __p1, uint8x8_t __p2) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16x2_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vqtbx2_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x8_t)__rev2, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_p64(poly64x2_t __p0) {
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vqtbx2q_p8(poly8x16_t __p0, poly8x16x2_t __p1, uint8x16_t __p2) {
poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+ __ret = (poly8x16_t) __builtin_neon_vqtbx2q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p2, 36);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_p16(poly16x8_t __p0) {
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vqtbx2q_p8(poly8x16_t __p0, poly8x16x2_t __p1, uint8x16_t __p2) {
poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16x2_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x16_t) __builtin_neon_vqtbx2q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev2, 36);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_u8(uint8x16_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqtbx2q_u8(uint8x16_t __p0, uint8x16x2_t __p1, uint8x16_t __p2) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vqtbx2q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p2, 48);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_u32(uint32x4_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqtbx2q_u8(uint8x16_t __p0, uint8x16x2_t __p1, uint8x16_t __p2) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16x2_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vqtbx2q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev2, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_u64(uint64x2_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqtbx2q_s8(int8x16_t __p0, int8x16x2_t __p1, uint8x16_t __p2) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vqtbx2q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p2, 32);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_u16(uint16x8_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqtbx2q_s8(int8x16_t __p0, int8x16x2_t __p1, uint8x16_t __p2) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16x2_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vqtbx2q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev2, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_s8(int8x16_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqtbx2_u8(uint8x8_t __p0, uint8x16x2_t __p1, uint8x8_t __p2) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vqtbx2_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x8_t)__p2, 16);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_f64(float64x2_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqtbx2_u8(uint8x8_t __p0, uint8x16x2_t __p1, uint8x8_t __p2) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16x2_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vqtbx2_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x8_t)__rev2, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_f32(float32x4_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqtbx2_s8(int8x8_t __p0, int8x16x2_t __p1, uint8x8_t __p2) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vqtbx2_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x8_t)__p2, 0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_f16(float16x8_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqtbx2_s8(int8x8_t __p0, int8x16x2_t __p1, uint8x8_t __p2) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16x2_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vqtbx2_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x8_t)__rev2, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_s32(int32x4_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vqtbx3_p8(poly8x8_t __p0, poly8x16x3_t __p1, uint8x8_t __p2) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) __builtin_neon_vqtbx3_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x8_t)__p2, 4);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_s64(int64x2_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vqtbx3_p8(poly8x8_t __p0, poly8x16x3_t __p1, uint8x8_t __p2) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16x3_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vqtbx3_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x8_t)__rev2, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly8x16_t vreinterpretq_p8_s16(int16x8_t __p0) {
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vqtbx3q_p8(poly8x16_t __p0, poly8x16x3_t __p1, uint8x16_t __p2) {
poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
- return __ret;
-}
-__ai poly128_t vreinterpretq_p128_p8(poly8x16_t __p0) {
- poly128_t __ret;
- __ret = (poly128_t)(__p0);
- return __ret;
-}
-__ai poly128_t vreinterpretq_p128_p64(poly64x2_t __p0) {
- poly128_t __ret;
- __ret = (poly128_t)(__p0);
+ __ret = (poly8x16_t) __builtin_neon_vqtbx3q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p2, 36);
return __ret;
}
-__ai poly128_t vreinterpretq_p128_p16(poly16x8_t __p0) {
- poly128_t __ret;
- __ret = (poly128_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vqtbx3q_p8(poly8x16_t __p0, poly8x16x3_t __p1, uint8x16_t __p2) {
+ poly8x16_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16x3_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x16_t) __builtin_neon_vqtbx3q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev2, 36);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly128_t vreinterpretq_p128_u8(uint8x16_t __p0) {
- poly128_t __ret;
- __ret = (poly128_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqtbx3q_u8(uint8x16_t __p0, uint8x16x3_t __p1, uint8x16_t __p2) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vqtbx3q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p2, 48);
return __ret;
}
-__ai poly128_t vreinterpretq_p128_u32(uint32x4_t __p0) {
- poly128_t __ret;
- __ret = (poly128_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqtbx3q_u8(uint8x16_t __p0, uint8x16x3_t __p1, uint8x16_t __p2) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16x3_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vqtbx3q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev2, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly128_t vreinterpretq_p128_u64(uint64x2_t __p0) {
- poly128_t __ret;
- __ret = (poly128_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqtbx3q_s8(int8x16_t __p0, int8x16x3_t __p1, uint8x16_t __p2) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vqtbx3q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p2, 32);
return __ret;
}
-__ai poly128_t vreinterpretq_p128_u16(uint16x8_t __p0) {
- poly128_t __ret;
- __ret = (poly128_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqtbx3q_s8(int8x16_t __p0, int8x16x3_t __p1, uint8x16_t __p2) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16x3_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vqtbx3q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev2, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly128_t vreinterpretq_p128_s8(int8x16_t __p0) {
- poly128_t __ret;
- __ret = (poly128_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqtbx3_u8(uint8x8_t __p0, uint8x16x3_t __p1, uint8x8_t __p2) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vqtbx3_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x8_t)__p2, 16);
return __ret;
}
-__ai poly128_t vreinterpretq_p128_f64(float64x2_t __p0) {
- poly128_t __ret;
- __ret = (poly128_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqtbx3_u8(uint8x8_t __p0, uint8x16x3_t __p1, uint8x8_t __p2) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16x3_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vqtbx3_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x8_t)__rev2, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly128_t vreinterpretq_p128_f32(float32x4_t __p0) {
- poly128_t __ret;
- __ret = (poly128_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqtbx3_s8(int8x8_t __p0, int8x16x3_t __p1, uint8x8_t __p2) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vqtbx3_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x8_t)__p2, 0);
return __ret;
}
-__ai poly128_t vreinterpretq_p128_f16(float16x8_t __p0) {
- poly128_t __ret;
- __ret = (poly128_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqtbx3_s8(int8x8_t __p0, int8x16x3_t __p1, uint8x8_t __p2) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16x3_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vqtbx3_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x8_t)__rev2, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly128_t vreinterpretq_p128_s32(int32x4_t __p0) {
- poly128_t __ret;
- __ret = (poly128_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vqtbx4_p8(poly8x8_t __p0, poly8x16x4_t __p1, uint8x8_t __p2) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) __builtin_neon_vqtbx4_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p1.val[3], (int8x8_t)__p2, 4);
return __ret;
}
-__ai poly128_t vreinterpretq_p128_s64(int64x2_t __p0) {
- poly128_t __ret;
- __ret = (poly128_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vqtbx4_p8(poly8x8_t __p0, poly8x16x4_t __p1, uint8x8_t __p2) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16x4_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vqtbx4_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], (int8x8_t)__rev2, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly128_t vreinterpretq_p128_s16(int16x8_t __p0) {
- poly128_t __ret;
- __ret = (poly128_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vqtbx4q_p8(poly8x16_t __p0, poly8x16x4_t __p1, uint8x16_t __p2) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t) __builtin_neon_vqtbx4q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p1.val[3], (int8x16_t)__p2, 36);
return __ret;
}
-__ai poly64x2_t vreinterpretq_p64_p8(poly8x16_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vqtbx4q_p8(poly8x16_t __p0, poly8x16x4_t __p1, uint8x16_t __p2) {
+ poly8x16_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16x4_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x16_t) __builtin_neon_vqtbx4q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], (int8x16_t)__rev2, 36);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly64x2_t vreinterpretq_p64_p128(poly128_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqtbx4q_u8(uint8x16_t __p0, uint8x16x4_t __p1, uint8x16_t __p2) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vqtbx4q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p1.val[3], (int8x16_t)__p2, 48);
return __ret;
}
-__ai poly64x2_t vreinterpretq_p64_p16(poly16x8_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqtbx4q_u8(uint8x16_t __p0, uint8x16x4_t __p1, uint8x16_t __p2) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16x4_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vqtbx4q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], (int8x16_t)__rev2, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly64x2_t vreinterpretq_p64_u8(uint8x16_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqtbx4q_s8(int8x16_t __p0, int8x16x4_t __p1, uint8x16_t __p2) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vqtbx4q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p1.val[3], (int8x16_t)__p2, 32);
return __ret;
}
-__ai poly64x2_t vreinterpretq_p64_u32(uint32x4_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqtbx4q_s8(int8x16_t __p0, int8x16x4_t __p1, uint8x16_t __p2) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16x4_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vqtbx4q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], (int8x16_t)__rev2, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly64x2_t vreinterpretq_p64_u64(uint64x2_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqtbx4_u8(uint8x8_t __p0, uint8x16x4_t __p1, uint8x8_t __p2) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vqtbx4_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p1.val[3], (int8x8_t)__p2, 16);
return __ret;
}
-__ai poly64x2_t vreinterpretq_p64_u16(uint16x8_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqtbx4_u8(uint8x8_t __p0, uint8x16x4_t __p1, uint8x8_t __p2) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16x4_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vqtbx4_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], (int8x8_t)__rev2, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly64x2_t vreinterpretq_p64_s8(int8x16_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqtbx4_s8(int8x8_t __p0, int8x16x4_t __p1, uint8x8_t __p2) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vqtbx4_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p1.val[3], (int8x8_t)__p2, 0);
return __ret;
}
-__ai poly64x2_t vreinterpretq_p64_f64(float64x2_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqtbx4_s8(int8x8_t __p0, int8x16x4_t __p1, uint8x8_t __p2) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16x4_t __rev1;
+ __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vqtbx4_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], (int8x8_t)__rev2, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly64x2_t vreinterpretq_p64_f32(float32x4_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vraddhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+ uint16x8_t __ret;
+ __ret = vcombine_u16(__p0, vraddhn_u32(__p1, __p2));
return __ret;
}
-__ai poly64x2_t vreinterpretq_p64_f16(float16x8_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vraddhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+ uint16x8_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ uint32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_u16(__rev0, __noswap_vraddhn_u32(__rev1, __rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly64x2_t vreinterpretq_p64_s32(int32x4_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vraddhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+ uint32x4_t __ret;
+ __ret = vcombine_u32(__p0, vraddhn_u64(__p1, __p2));
return __ret;
}
-__ai poly64x2_t vreinterpretq_p64_s64(int64x2_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vraddhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+ uint32x4_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ uint64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = __noswap_vcombine_u32(__rev0, __noswap_vraddhn_u64(__rev1, __rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai poly64x2_t vreinterpretq_p64_s16(int16x8_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vraddhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+ uint8x16_t __ret;
+ __ret = vcombine_u8(__p0, vraddhn_u16(__p1, __p2));
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_p8(poly8x16_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vraddhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+ uint8x16_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_u8(__rev0, __noswap_vraddhn_u16(__rev1, __rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_p128(poly128_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vraddhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+ int16x8_t __ret;
+ __ret = vcombine_s16(__p0, vraddhn_s32(__p1, __p2));
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_p64(poly64x2_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int16x8_t vraddhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+ int16x8_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_s16(__rev0, __noswap_vraddhn_s32(__rev1, __rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_u8(uint8x16_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vraddhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+ int32x4_t __ret;
+ __ret = vcombine_s32(__p0, vraddhn_s64(__p1, __p2));
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_u32(uint32x4_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int32x4_t vraddhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+ int32x4_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ int64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = __noswap_vcombine_s32(__rev0, __noswap_vraddhn_s64(__rev1, __rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_u64(uint64x2_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vraddhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+ int8x16_t __ret;
+ __ret = vcombine_s8(__p0, vraddhn_s16(__p1, __p2));
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_u16(uint16x8_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int8x16_t vraddhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+ int8x16_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_s8(__rev0, __noswap_vraddhn_s16(__rev1, __rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_s8(int8x16_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vrbit_p8(poly8x8_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t) __builtin_neon_vrbit_v((int8x8_t)__p0, 4);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_f64(float64x2_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vrbit_p8(poly8x8_t __p0) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x8_t) __builtin_neon_vrbit_v((int8x8_t)__rev0, 4);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_f32(float32x4_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vrbitq_p8(poly8x16_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t) __builtin_neon_vrbitq_v((int8x16_t)__p0, 36);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_f16(float16x8_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vrbitq_p8(poly8x16_t __p0) {
+ poly8x16_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (poly8x16_t) __builtin_neon_vrbitq_v((int8x16_t)__rev0, 36);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_s32(int32x4_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vrbitq_u8(uint8x16_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t) __builtin_neon_vrbitq_v((int8x16_t)__p0, 48);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_s64(int64x2_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vrbitq_u8(uint8x16_t __p0) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vrbitq_v((int8x16_t)__rev0, 48);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai poly16x8_t vreinterpretq_p16_s16(int16x8_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vrbitq_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vrbitq_v((int8x16_t)__p0, 32);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_p8(poly8x16_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int8x16_t vrbitq_s8(int8x16_t __p0) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vrbitq_v((int8x16_t)__rev0, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_p128(poly128_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vrbit_u8(uint8x8_t __p0) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vrbit_v((int8x8_t)__p0, 16);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_p64(poly64x2_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vrbit_u8(uint8x8_t __p0) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vrbit_v((int8x8_t)__rev0, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_p16(poly16x8_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vrbit_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vrbit_v((int8x8_t)__p0, 0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_u32(uint32x4_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int8x8_t vrbit_s8(int8x8_t __p0) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vrbit_v((int8x8_t)__rev0, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_u64(uint64x2_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrecpeq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vrecpeq_v((int8x16_t)__p0, 42);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_u16(uint16x8_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrecpeq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vrecpeq_v((int8x16_t)__rev0, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_s8(int8x16_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrecpe_f64(float64x1_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vrecpe_v((int8x8_t)__p0, 10);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_f64(float64x2_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+__ai __attribute__((target("neon"))) float64_t vrecped_f64(float64_t __p0) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vrecped_f64(__p0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_f32(float32x4_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+__ai __attribute__((target("neon"))) float32_t vrecpes_f32(float32_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vrecpes_f32(__p0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_f16(float16x8_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrecpsq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vrecpsq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_s32(int32x4_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrecpsq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vrecpsq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_s64(int64x2_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrecps_f64(float64x1_t __p0, float64x1_t __p1) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vrecps_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
return __ret;
}
-__ai uint8x16_t vreinterpretq_u8_s16(int16x8_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
+__ai __attribute__((target("neon"))) float64_t vrecpsd_f64(float64_t __p0, float64_t __p1) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vrecpsd_f64(__p0, __p1);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_p8(poly8x16_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) float32_t vrecpss_f32(float32_t __p0, float32_t __p1) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vrecpss_f32(__p0, __p1);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_p128(poly128_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) float64_t vrecpxd_f64(float64_t __p0) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vrecpxd_f64(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_p64(poly64x2_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) float32_t vrecpxs_f32(float32_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vrecpxs_f32(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_p16(poly16x8_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_p64(poly64x1_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_u8(uint8x16_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_p16(poly16x4_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_u64(uint64x2_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_u8(uint8x8_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_u16(uint16x8_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_u32(uint32x2_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_s8(int8x16_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_u64(uint64x1_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_f64(float64x2_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_u16(uint16x4_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_f32(float32x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_s8(int8x8_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_f16(float16x8_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_f64(float64x1_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_s32(int32x4_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_f32(float32x2_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_s64(int64x2_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_f16(float16x4_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-__ai uint32x4_t vreinterpretq_u32_s16(int16x8_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_s32(int32x2_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_p8(poly8x16_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_s64(int64x1_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_p128(poly128_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_s16(int16x4_t __p0) {
+ poly8x8_t __ret;
+ __ret = (poly8x8_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_p64(poly64x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_p8(poly8x8_t __p0) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_p16(poly16x8_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_p16(poly16x4_t __p0) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_u8(uint8x16_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_u8(uint8x8_t __p0) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_u32(uint32x4_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_u32(uint32x2_t __p0) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_u16(uint16x8_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_u64(uint64x1_t __p0) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_s8(int8x16_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_u16(uint16x4_t __p0) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_f64(float64x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_s8(int8x8_t __p0) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_f32(float32x4_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_f64(float64x1_t __p0) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_f16(float16x8_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_f32(float32x2_t __p0) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_s32(int32x4_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_f16(float16x4_t __p0) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_s64(int64x2_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_s32(int32x2_t __p0) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t)(__p0);
return __ret;
}
-__ai uint64x2_t vreinterpretq_u64_s16(int16x8_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_s64(int64x1_t __p0) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_p8(poly8x16_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_s16(int16x4_t __p0) {
+ poly64x1_t __ret;
+ __ret = (poly64x1_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_p128(poly128_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_p8(poly8x8_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_p64(poly64x2_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_p64(poly64x1_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_p16(poly16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_u8(uint8x8_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_u8(uint8x16_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_u32(uint32x2_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_u32(uint32x4_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_u64(uint64x1_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_u64(uint64x2_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_u16(uint16x4_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_s8(int8x16_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_s8(int8x8_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_f64(float64x2_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_f64(float64x1_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_f32(float32x4_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_f32(float32x2_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_f16(float16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_f16(float16x4_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_s32(int32x4_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_s32(int32x2_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_s64(int64x2_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_s64(int64x1_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-__ai uint16x8_t vreinterpretq_u16_s16(int16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_s16(int16x4_t __p0) {
+ poly16x4_t __ret;
+ __ret = (poly16x4_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_p8(poly8x16_t __p0) {
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_p128(poly128_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_p64(poly64x2_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_p16(poly16x8_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_u8(uint8x16_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_u32(uint32x4_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_u64(uint64x2_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_u16(uint16x8_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_s8(int8x16_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_f64(float64x2_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_f32(float32x4_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_f16(float16x8_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_s32(int32x4_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_s64(int64x2_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_s16(int16x8_t __p0) {
+ poly8x16_t __ret;
+ __ret = (poly8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_p8(poly8x16_t __p0) {
+ poly128_t __ret;
+ __ret = (poly128_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_p64(poly64x2_t __p0) {
+ poly128_t __ret;
+ __ret = (poly128_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_p16(poly16x8_t __p0) {
+ poly128_t __ret;
+ __ret = (poly128_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_u8(uint8x16_t __p0) {
+ poly128_t __ret;
+ __ret = (poly128_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_u32(uint32x4_t __p0) {
+ poly128_t __ret;
+ __ret = (poly128_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_u64(uint64x2_t __p0) {
+ poly128_t __ret;
+ __ret = (poly128_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_u16(uint16x8_t __p0) {
+ poly128_t __ret;
+ __ret = (poly128_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_s8(int8x16_t __p0) {
+ poly128_t __ret;
+ __ret = (poly128_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_f64(float64x2_t __p0) {
+ poly128_t __ret;
+ __ret = (poly128_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_f32(float32x4_t __p0) {
+ poly128_t __ret;
+ __ret = (poly128_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_f16(float16x8_t __p0) {
+ poly128_t __ret;
+ __ret = (poly128_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_s32(int32x4_t __p0) {
+ poly128_t __ret;
+ __ret = (poly128_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_s64(int64x2_t __p0) {
+ poly128_t __ret;
+ __ret = (poly128_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_s16(int16x8_t __p0) {
+ poly128_t __ret;
+ __ret = (poly128_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_p8(poly8x16_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_p128(poly128_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_p16(poly16x8_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_u8(uint8x16_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_u32(uint32x4_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_u64(uint64x2_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_u16(uint16x8_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_s8(int8x16_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_f64(float64x2_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_f32(float32x4_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_f16(float16x8_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_s32(int32x4_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_s64(int64x2_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_s16(int16x8_t __p0) {
+ poly64x2_t __ret;
+ __ret = (poly64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_p8(poly8x16_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_p128(poly128_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_p64(poly64x2_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_u8(uint8x16_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_u32(uint32x4_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_u64(uint64x2_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_u16(uint16x8_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_s8(int8x16_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_f64(float64x2_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_f32(float32x4_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_f16(float16x8_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_s32(int32x4_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_s64(int64x2_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_s16(int16x8_t __p0) {
+ poly16x8_t __ret;
+ __ret = (poly16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_p8(poly8x16_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_p128(poly128_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_p64(poly64x2_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_p16(poly16x8_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_u32(uint32x4_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_u64(uint64x2_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_u16(uint16x8_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_s8(int8x16_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_f64(float64x2_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_f32(float32x4_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_f16(float16x8_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_s32(int32x4_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_s64(int64x2_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_s16(int16x8_t __p0) {
+ uint8x16_t __ret;
+ __ret = (uint8x16_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_p8(poly8x16_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_p128(poly128_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_p64(poly64x2_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_p16(poly16x8_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_u8(uint8x16_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_u64(uint64x2_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_u16(uint16x8_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_s8(int8x16_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_f64(float64x2_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_f32(float32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_f16(float16x8_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_s32(int32x4_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_s64(int64x2_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_s16(int16x8_t __p0) {
+ uint32x4_t __ret;
+ __ret = (uint32x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_p8(poly8x16_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_p128(poly128_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_p64(poly64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_p16(poly16x8_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_u8(uint8x16_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_u32(uint32x4_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_u16(uint16x8_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_s8(int8x16_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_f64(float64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_f32(float32x4_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_f16(float16x8_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_s32(int32x4_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_s64(int64x2_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_s16(int16x8_t __p0) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_p8(poly8x16_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_p128(poly128_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_p64(poly64x2_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_p16(poly16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_u8(uint8x16_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_u32(uint32x4_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_u64(uint64x2_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_s8(int8x16_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_f64(float64x2_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_f32(float32x4_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_f16(float16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_s32(int32x4_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_s64(int64x2_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_s16(int16x8_t __p0) {
+ uint16x8_t __ret;
+ __ret = (uint16x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_p8(poly8x16_t __p0) {
int8x16_t __ret;
__ret = (int8x16_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_p128(poly128_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_p128(poly128_t __p0) {
int8x16_t __ret;
__ret = (int8x16_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_p64(poly64x2_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_p64(poly64x2_t __p0) {
int8x16_t __ret;
__ret = (int8x16_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_p16(poly16x8_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_p16(poly16x8_t __p0) {
int8x16_t __ret;
__ret = (int8x16_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_u8(uint8x16_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_u8(uint8x16_t __p0) {
int8x16_t __ret;
__ret = (int8x16_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_u32(uint32x4_t __p0) {
int8x16_t __ret;
__ret = (int8x16_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_u64(uint64x2_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_u64(uint64x2_t __p0) {
int8x16_t __ret;
__ret = (int8x16_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_u16(uint16x8_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_u16(uint16x8_t __p0) {
int8x16_t __ret;
__ret = (int8x16_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_f64(float64x2_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_f64(float64x2_t __p0) {
int8x16_t __ret;
__ret = (int8x16_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_f32(float32x4_t __p0) {
int8x16_t __ret;
__ret = (int8x16_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_f16(float16x8_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_f16(float16x8_t __p0) {
int8x16_t __ret;
__ret = (int8x16_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_s32(int32x4_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_s32(int32x4_t __p0) {
int8x16_t __ret;
__ret = (int8x16_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_s64(int64x2_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_s64(int64x2_t __p0) {
int8x16_t __ret;
__ret = (int8x16_t)(__p0);
return __ret;
}
-__ai int8x16_t vreinterpretq_s8_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_s16(int16x8_t __p0) {
int8x16_t __ret;
__ret = (int8x16_t)(__p0);
return __ret;
}
-__ai float64x2_t vreinterpretq_f64_p8(poly8x16_t __p0) {
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_p8(poly8x16_t __p0) {
float64x2_t __ret;
__ret = (float64x2_t)(__p0);
return __ret;
}
-__ai float64x2_t vreinterpretq_f64_p128(poly128_t __p0) {
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_p128(poly128_t __p0) {
float64x2_t __ret;
__ret = (float64x2_t)(__p0);
return __ret;
}
-__ai float64x2_t vreinterpretq_f64_p64(poly64x2_t __p0) {
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_p64(poly64x2_t __p0) {
float64x2_t __ret;
__ret = (float64x2_t)(__p0);
return __ret;
}
-__ai float64x2_t vreinterpretq_f64_p16(poly16x8_t __p0) {
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_p16(poly16x8_t __p0) {
float64x2_t __ret;
__ret = (float64x2_t)(__p0);
return __ret;
}
-__ai float64x2_t vreinterpretq_f64_u8(uint8x16_t __p0) {
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_u8(uint8x16_t __p0) {
float64x2_t __ret;
__ret = (float64x2_t)(__p0);
return __ret;
}
-__ai float64x2_t vreinterpretq_f64_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_u32(uint32x4_t __p0) {
float64x2_t __ret;
__ret = (float64x2_t)(__p0);
return __ret;
}
-__ai float64x2_t vreinterpretq_f64_u64(uint64x2_t __p0) {
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_u64(uint64x2_t __p0) {
float64x2_t __ret;
__ret = (float64x2_t)(__p0);
return __ret;
}
-__ai float64x2_t vreinterpretq_f64_u16(uint16x8_t __p0) {
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_u16(uint16x8_t __p0) {
float64x2_t __ret;
__ret = (float64x2_t)(__p0);
return __ret;
}
-__ai float64x2_t vreinterpretq_f64_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_s8(int8x16_t __p0) {
float64x2_t __ret;
__ret = (float64x2_t)(__p0);
return __ret;
}
-__ai float64x2_t vreinterpretq_f64_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_f32(float32x4_t __p0) {
float64x2_t __ret;
__ret = (float64x2_t)(__p0);
return __ret;
}
-__ai float64x2_t vreinterpretq_f64_f16(float16x8_t __p0) {
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_f16(float16x8_t __p0) {
float64x2_t __ret;
__ret = (float64x2_t)(__p0);
return __ret;
}
-__ai float64x2_t vreinterpretq_f64_s32(int32x4_t __p0) {
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_s32(int32x4_t __p0) {
float64x2_t __ret;
__ret = (float64x2_t)(__p0);
return __ret;
}
-__ai float64x2_t vreinterpretq_f64_s64(int64x2_t __p0) {
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_s64(int64x2_t __p0) {
float64x2_t __ret;
__ret = (float64x2_t)(__p0);
return __ret;
}
-__ai float64x2_t vreinterpretq_f64_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_s16(int16x8_t __p0) {
float64x2_t __ret;
__ret = (float64x2_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_p8(poly8x16_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_p8(poly8x16_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_p128(poly128_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_p128(poly128_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_p64(poly64x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_p64(poly64x2_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_p16(poly16x8_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_p16(poly16x8_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_u8(uint8x16_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_u8(uint8x16_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_u32(uint32x4_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_u64(uint64x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_u64(uint64x2_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_u16(uint16x8_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_u16(uint16x8_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_s8(int8x16_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_f64(float64x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_f64(float64x2_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_f16(float16x8_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_f16(float16x8_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_s32(int32x4_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_s32(int32x4_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_s64(int64x2_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_s64(int64x2_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t)(__p0);
return __ret;
}
-__ai float32x4_t vreinterpretq_f32_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_s16(int16x8_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t)(__p0);
return __ret;
}
-__ai float16x8_t vreinterpretq_f16_p8(poly8x16_t __p0) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_p8(poly8x16_t __p0) {
float16x8_t __ret;
__ret = (float16x8_t)(__p0);
return __ret;
}
-__ai float16x8_t vreinterpretq_f16_p128(poly128_t __p0) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_p128(poly128_t __p0) {
float16x8_t __ret;
__ret = (float16x8_t)(__p0);
return __ret;
}
-__ai float16x8_t vreinterpretq_f16_p64(poly64x2_t __p0) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_p64(poly64x2_t __p0) {
float16x8_t __ret;
__ret = (float16x8_t)(__p0);
return __ret;
}
-__ai float16x8_t vreinterpretq_f16_p16(poly16x8_t __p0) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_p16(poly16x8_t __p0) {
float16x8_t __ret;
__ret = (float16x8_t)(__p0);
return __ret;
}
-__ai float16x8_t vreinterpretq_f16_u8(uint8x16_t __p0) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_u8(uint8x16_t __p0) {
float16x8_t __ret;
__ret = (float16x8_t)(__p0);
return __ret;
}
-__ai float16x8_t vreinterpretq_f16_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_u32(uint32x4_t __p0) {
float16x8_t __ret;
__ret = (float16x8_t)(__p0);
return __ret;
}
-__ai float16x8_t vreinterpretq_f16_u64(uint64x2_t __p0) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_u64(uint64x2_t __p0) {
float16x8_t __ret;
__ret = (float16x8_t)(__p0);
return __ret;
}
-__ai float16x8_t vreinterpretq_f16_u16(uint16x8_t __p0) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_u16(uint16x8_t __p0) {
float16x8_t __ret;
__ret = (float16x8_t)(__p0);
return __ret;
}
-__ai float16x8_t vreinterpretq_f16_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_s8(int8x16_t __p0) {
float16x8_t __ret;
__ret = (float16x8_t)(__p0);
return __ret;
}
-__ai float16x8_t vreinterpretq_f16_f64(float64x2_t __p0) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_f64(float64x2_t __p0) {
float16x8_t __ret;
__ret = (float16x8_t)(__p0);
return __ret;
}
-__ai float16x8_t vreinterpretq_f16_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_f32(float32x4_t __p0) {
float16x8_t __ret;
__ret = (float16x8_t)(__p0);
return __ret;
}
-__ai float16x8_t vreinterpretq_f16_s32(int32x4_t __p0) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_s32(int32x4_t __p0) {
float16x8_t __ret;
__ret = (float16x8_t)(__p0);
return __ret;
}
-__ai float16x8_t vreinterpretq_f16_s64(int64x2_t __p0) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_s64(int64x2_t __p0) {
float16x8_t __ret;
__ret = (float16x8_t)(__p0);
return __ret;
}
-__ai float16x8_t vreinterpretq_f16_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_s16(int16x8_t __p0) {
float16x8_t __ret;
__ret = (float16x8_t)(__p0);
return __ret;
}
-__ai int32x4_t vreinterpretq_s32_p8(poly8x16_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_p8(poly8x16_t __p0) {
int32x4_t __ret;
__ret = (int32x4_t)(__p0);
return __ret;
}
-__ai int32x4_t vreinterpretq_s32_p128(poly128_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_p128(poly128_t __p0) {
int32x4_t __ret;
__ret = (int32x4_t)(__p0);
return __ret;
}
-__ai int32x4_t vreinterpretq_s32_p64(poly64x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_p64(poly64x2_t __p0) {
int32x4_t __ret;
__ret = (int32x4_t)(__p0);
return __ret;
}
-__ai int32x4_t vreinterpretq_s32_p16(poly16x8_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_p16(poly16x8_t __p0) {
int32x4_t __ret;
__ret = (int32x4_t)(__p0);
return __ret;
}
-__ai int32x4_t vreinterpretq_s32_u8(uint8x16_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_u8(uint8x16_t __p0) {
int32x4_t __ret;
__ret = (int32x4_t)(__p0);
return __ret;
}
-__ai int32x4_t vreinterpretq_s32_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_u32(uint32x4_t __p0) {
int32x4_t __ret;
__ret = (int32x4_t)(__p0);
return __ret;
}
-__ai int32x4_t vreinterpretq_s32_u64(uint64x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_u64(uint64x2_t __p0) {
int32x4_t __ret;
__ret = (int32x4_t)(__p0);
return __ret;
}
-__ai int32x4_t vreinterpretq_s32_u16(uint16x8_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_u16(uint16x8_t __p0) {
int32x4_t __ret;
__ret = (int32x4_t)(__p0);
return __ret;
}
-__ai int32x4_t vreinterpretq_s32_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_s8(int8x16_t __p0) {
int32x4_t __ret;
__ret = (int32x4_t)(__p0);
return __ret;
}
-__ai int32x4_t vreinterpretq_s32_f64(float64x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_f64(float64x2_t __p0) {
int32x4_t __ret;
__ret = (int32x4_t)(__p0);
return __ret;
}
-__ai int32x4_t vreinterpretq_s32_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_f32(float32x4_t __p0) {
int32x4_t __ret;
__ret = (int32x4_t)(__p0);
return __ret;
}
-__ai int32x4_t vreinterpretq_s32_f16(float16x8_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_f16(float16x8_t __p0) {
int32x4_t __ret;
__ret = (int32x4_t)(__p0);
return __ret;
}
-__ai int32x4_t vreinterpretq_s32_s64(int64x2_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_s64(int64x2_t __p0) {
int32x4_t __ret;
__ret = (int32x4_t)(__p0);
return __ret;
}
-__ai int32x4_t vreinterpretq_s32_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_s16(int16x8_t __p0) {
int32x4_t __ret;
__ret = (int32x4_t)(__p0);
return __ret;
}
-__ai int64x2_t vreinterpretq_s64_p8(poly8x16_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_p8(poly8x16_t __p0) {
int64x2_t __ret;
__ret = (int64x2_t)(__p0);
return __ret;
}
-__ai int64x2_t vreinterpretq_s64_p128(poly128_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_p128(poly128_t __p0) {
int64x2_t __ret;
__ret = (int64x2_t)(__p0);
return __ret;
}
-__ai int64x2_t vreinterpretq_s64_p64(poly64x2_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_p64(poly64x2_t __p0) {
int64x2_t __ret;
__ret = (int64x2_t)(__p0);
return __ret;
}
-__ai int64x2_t vreinterpretq_s64_p16(poly16x8_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_p16(poly16x8_t __p0) {
int64x2_t __ret;
__ret = (int64x2_t)(__p0);
return __ret;
}
-__ai int64x2_t vreinterpretq_s64_u8(uint8x16_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_u8(uint8x16_t __p0) {
int64x2_t __ret;
__ret = (int64x2_t)(__p0);
return __ret;
}
-__ai int64x2_t vreinterpretq_s64_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_u32(uint32x4_t __p0) {
int64x2_t __ret;
__ret = (int64x2_t)(__p0);
return __ret;
}
-__ai int64x2_t vreinterpretq_s64_u64(uint64x2_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_u64(uint64x2_t __p0) {
int64x2_t __ret;
__ret = (int64x2_t)(__p0);
return __ret;
}
-__ai int64x2_t vreinterpretq_s64_u16(uint16x8_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_u16(uint16x8_t __p0) {
int64x2_t __ret;
__ret = (int64x2_t)(__p0);
return __ret;
}
-__ai int64x2_t vreinterpretq_s64_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_s8(int8x16_t __p0) {
int64x2_t __ret;
__ret = (int64x2_t)(__p0);
return __ret;
}
-__ai int64x2_t vreinterpretq_s64_f64(float64x2_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_f64(float64x2_t __p0) {
int64x2_t __ret;
__ret = (int64x2_t)(__p0);
return __ret;
}
-__ai int64x2_t vreinterpretq_s64_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_f32(float32x4_t __p0) {
int64x2_t __ret;
__ret = (int64x2_t)(__p0);
return __ret;
}
-__ai int64x2_t vreinterpretq_s64_f16(float16x8_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_f16(float16x8_t __p0) {
int64x2_t __ret;
__ret = (int64x2_t)(__p0);
return __ret;
}
-__ai int64x2_t vreinterpretq_s64_s32(int32x4_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_s32(int32x4_t __p0) {
int64x2_t __ret;
__ret = (int64x2_t)(__p0);
return __ret;
}
-__ai int64x2_t vreinterpretq_s64_s16(int16x8_t __p0) {
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_s16(int16x8_t __p0) {
int64x2_t __ret;
__ret = (int64x2_t)(__p0);
return __ret;
}
-__ai int16x8_t vreinterpretq_s16_p8(poly8x16_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_p8(poly8x16_t __p0) {
int16x8_t __ret;
__ret = (int16x8_t)(__p0);
return __ret;
}
-__ai int16x8_t vreinterpretq_s16_p128(poly128_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_p128(poly128_t __p0) {
int16x8_t __ret;
__ret = (int16x8_t)(__p0);
return __ret;
}
-__ai int16x8_t vreinterpretq_s16_p64(poly64x2_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_p64(poly64x2_t __p0) {
int16x8_t __ret;
__ret = (int16x8_t)(__p0);
return __ret;
}
-__ai int16x8_t vreinterpretq_s16_p16(poly16x8_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_p16(poly16x8_t __p0) {
int16x8_t __ret;
__ret = (int16x8_t)(__p0);
return __ret;
}
-__ai int16x8_t vreinterpretq_s16_u8(uint8x16_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_u8(uint8x16_t __p0) {
int16x8_t __ret;
__ret = (int16x8_t)(__p0);
return __ret;
}
-__ai int16x8_t vreinterpretq_s16_u32(uint32x4_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_u32(uint32x4_t __p0) {
int16x8_t __ret;
__ret = (int16x8_t)(__p0);
return __ret;
}
-__ai int16x8_t vreinterpretq_s16_u64(uint64x2_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_u64(uint64x2_t __p0) {
int16x8_t __ret;
__ret = (int16x8_t)(__p0);
return __ret;
}
-__ai int16x8_t vreinterpretq_s16_u16(uint16x8_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_u16(uint16x8_t __p0) {
int16x8_t __ret;
__ret = (int16x8_t)(__p0);
return __ret;
}
-__ai int16x8_t vreinterpretq_s16_s8(int8x16_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_s8(int8x16_t __p0) {
int16x8_t __ret;
__ret = (int16x8_t)(__p0);
return __ret;
}
-__ai int16x8_t vreinterpretq_s16_f64(float64x2_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_f64(float64x2_t __p0) {
int16x8_t __ret;
__ret = (int16x8_t)(__p0);
return __ret;
}
-__ai int16x8_t vreinterpretq_s16_f32(float32x4_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_f32(float32x4_t __p0) {
int16x8_t __ret;
__ret = (int16x8_t)(__p0);
return __ret;
}
-__ai int16x8_t vreinterpretq_s16_f16(float16x8_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_f16(float16x8_t __p0) {
int16x8_t __ret;
__ret = (int16x8_t)(__p0);
return __ret;
}
-__ai int16x8_t vreinterpretq_s16_s32(int32x4_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_s32(int32x4_t __p0) {
int16x8_t __ret;
__ret = (int16x8_t)(__p0);
return __ret;
}
-__ai int16x8_t vreinterpretq_s16_s64(int64x2_t __p0) {
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_s64(int64x2_t __p0) {
int16x8_t __ret;
__ret = (int16x8_t)(__p0);
return __ret;
}
-__ai uint8x8_t vreinterpret_u8_p8(poly8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_p8(poly8x8_t __p0) {
uint8x8_t __ret;
__ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai uint8x8_t vreinterpret_u8_p64(poly64x1_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_p64(poly64x1_t __p0) {
uint8x8_t __ret;
__ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai uint8x8_t vreinterpret_u8_p16(poly16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_p16(poly16x4_t __p0) {
uint8x8_t __ret;
__ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai uint8x8_t vreinterpret_u8_u32(uint32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_u32(uint32x2_t __p0) {
uint8x8_t __ret;
__ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai uint8x8_t vreinterpret_u8_u64(uint64x1_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_u64(uint64x1_t __p0) {
uint8x8_t __ret;
__ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai uint8x8_t vreinterpret_u8_u16(uint16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_u16(uint16x4_t __p0) {
uint8x8_t __ret;
__ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai uint8x8_t vreinterpret_u8_s8(int8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_s8(int8x8_t __p0) {
uint8x8_t __ret;
__ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai uint8x8_t vreinterpret_u8_f64(float64x1_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_f64(float64x1_t __p0) {
uint8x8_t __ret;
__ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai uint8x8_t vreinterpret_u8_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_f32(float32x2_t __p0) {
uint8x8_t __ret;
__ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai uint8x8_t vreinterpret_u8_f16(float16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_f16(float16x4_t __p0) {
uint8x8_t __ret;
__ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai uint8x8_t vreinterpret_u8_s32(int32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_s32(int32x2_t __p0) {
uint8x8_t __ret;
__ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai uint8x8_t vreinterpret_u8_s64(int64x1_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_s64(int64x1_t __p0) {
uint8x8_t __ret;
__ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai uint8x8_t vreinterpret_u8_s16(int16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_s16(int16x4_t __p0) {
uint8x8_t __ret;
__ret = (uint8x8_t)(__p0);
return __ret;
}
-__ai uint32x2_t vreinterpret_u32_p8(poly8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_p8(poly8x8_t __p0) {
uint32x2_t __ret;
__ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai uint32x2_t vreinterpret_u32_p64(poly64x1_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_p64(poly64x1_t __p0) {
uint32x2_t __ret;
__ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai uint32x2_t vreinterpret_u32_p16(poly16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_p16(poly16x4_t __p0) {
uint32x2_t __ret;
__ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai uint32x2_t vreinterpret_u32_u8(uint8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_u8(uint8x8_t __p0) {
uint32x2_t __ret;
__ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai uint32x2_t vreinterpret_u32_u64(uint64x1_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_u64(uint64x1_t __p0) {
uint32x2_t __ret;
__ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai uint32x2_t vreinterpret_u32_u16(uint16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_u16(uint16x4_t __p0) {
uint32x2_t __ret;
__ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai uint32x2_t vreinterpret_u32_s8(int8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_s8(int8x8_t __p0) {
uint32x2_t __ret;
__ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai uint32x2_t vreinterpret_u32_f64(float64x1_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_f64(float64x1_t __p0) {
uint32x2_t __ret;
__ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai uint32x2_t vreinterpret_u32_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_f32(float32x2_t __p0) {
uint32x2_t __ret;
__ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai uint32x2_t vreinterpret_u32_f16(float16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_f16(float16x4_t __p0) {
uint32x2_t __ret;
__ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai uint32x2_t vreinterpret_u32_s32(int32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_s32(int32x2_t __p0) {
uint32x2_t __ret;
__ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai uint32x2_t vreinterpret_u32_s64(int64x1_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_s64(int64x1_t __p0) {
uint32x2_t __ret;
__ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai uint32x2_t vreinterpret_u32_s16(int16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_s16(int16x4_t __p0) {
uint32x2_t __ret;
__ret = (uint32x2_t)(__p0);
return __ret;
}
-__ai uint64x1_t vreinterpret_u64_p8(poly8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_p8(poly8x8_t __p0) {
uint64x1_t __ret;
__ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint64x1_t vreinterpret_u64_p64(poly64x1_t __p0) {
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_p64(poly64x1_t __p0) {
uint64x1_t __ret;
__ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint64x1_t vreinterpret_u64_p16(poly16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_p16(poly16x4_t __p0) {
uint64x1_t __ret;
__ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint64x1_t vreinterpret_u64_u8(uint8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_u8(uint8x8_t __p0) {
uint64x1_t __ret;
__ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint64x1_t vreinterpret_u64_u32(uint32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_u32(uint32x2_t __p0) {
uint64x1_t __ret;
__ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint64x1_t vreinterpret_u64_u16(uint16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_u16(uint16x4_t __p0) {
uint64x1_t __ret;
__ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint64x1_t vreinterpret_u64_s8(int8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_s8(int8x8_t __p0) {
uint64x1_t __ret;
__ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint64x1_t vreinterpret_u64_f64(float64x1_t __p0) {
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_f64(float64x1_t __p0) {
uint64x1_t __ret;
__ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint64x1_t vreinterpret_u64_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_f32(float32x2_t __p0) {
uint64x1_t __ret;
__ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint64x1_t vreinterpret_u64_f16(float16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_f16(float16x4_t __p0) {
uint64x1_t __ret;
__ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint64x1_t vreinterpret_u64_s32(int32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_s32(int32x2_t __p0) {
uint64x1_t __ret;
__ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint64x1_t vreinterpret_u64_s64(int64x1_t __p0) {
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_s64(int64x1_t __p0) {
uint64x1_t __ret;
__ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint64x1_t vreinterpret_u64_s16(int16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_s16(int16x4_t __p0) {
uint64x1_t __ret;
__ret = (uint64x1_t)(__p0);
return __ret;
}
-__ai uint16x4_t vreinterpret_u16_p8(poly8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_p8(poly8x8_t __p0) {
uint16x4_t __ret;
__ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint16x4_t vreinterpret_u16_p64(poly64x1_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_p64(poly64x1_t __p0) {
uint16x4_t __ret;
__ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint16x4_t vreinterpret_u16_p16(poly16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_p16(poly16x4_t __p0) {
uint16x4_t __ret;
__ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint16x4_t vreinterpret_u16_u8(uint8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_u8(uint8x8_t __p0) {
uint16x4_t __ret;
__ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint16x4_t vreinterpret_u16_u32(uint32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_u32(uint32x2_t __p0) {
uint16x4_t __ret;
__ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint16x4_t vreinterpret_u16_u64(uint64x1_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_u64(uint64x1_t __p0) {
uint16x4_t __ret;
__ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint16x4_t vreinterpret_u16_s8(int8x8_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_s8(int8x8_t __p0) {
uint16x4_t __ret;
__ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint16x4_t vreinterpret_u16_f64(float64x1_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_f64(float64x1_t __p0) {
uint16x4_t __ret;
__ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint16x4_t vreinterpret_u16_f32(float32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_f32(float32x2_t __p0) {
uint16x4_t __ret;
__ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint16x4_t vreinterpret_u16_f16(float16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_f16(float16x4_t __p0) {
uint16x4_t __ret;
__ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint16x4_t vreinterpret_u16_s32(int32x2_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_s32(int32x2_t __p0) {
uint16x4_t __ret;
__ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint16x4_t vreinterpret_u16_s64(int64x1_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_s64(int64x1_t __p0) {
uint16x4_t __ret;
__ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai uint16x4_t vreinterpret_u16_s16(int16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_s16(int16x4_t __p0) {
uint16x4_t __ret;
__ret = (uint16x4_t)(__p0);
return __ret;
}
-__ai int8x8_t vreinterpret_s8_p8(poly8x8_t __p0) {
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_p8(poly8x8_t __p0) {
int8x8_t __ret;
__ret = (int8x8_t)(__p0);
return __ret;
}
-__ai int8x8_t vreinterpret_s8_p64(poly64x1_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_p16(poly16x4_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_u8(uint8x8_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_u32(uint32x2_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_u64(uint64x1_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_u16(uint16x4_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_f64(float64x1_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_f32(float32x2_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_f16(float16x4_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_s32(int32x2_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_s64(int64x1_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai int8x8_t vreinterpret_s8_s16(int16x4_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai float64x1_t vreinterpret_f64_p8(poly8x8_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t)(__p0);
- return __ret;
-}
-__ai float64x1_t vreinterpret_f64_p64(poly64x1_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t)(__p0);
- return __ret;
-}
-__ai float64x1_t vreinterpret_f64_p16(poly16x4_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t)(__p0);
- return __ret;
-}
-__ai float64x1_t vreinterpret_f64_u8(uint8x8_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t)(__p0);
- return __ret;
-}
-__ai float64x1_t vreinterpret_f64_u32(uint32x2_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t)(__p0);
- return __ret;
-}
-__ai float64x1_t vreinterpret_f64_u64(uint64x1_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t)(__p0);
- return __ret;
-}
-__ai float64x1_t vreinterpret_f64_u16(uint16x4_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t)(__p0);
- return __ret;
-}
-__ai float64x1_t vreinterpret_f64_s8(int8x8_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t)(__p0);
- return __ret;
-}
-__ai float64x1_t vreinterpret_f64_f32(float32x2_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t)(__p0);
- return __ret;
-}
-__ai float64x1_t vreinterpret_f64_f16(float16x4_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t)(__p0);
- return __ret;
-}
-__ai float64x1_t vreinterpret_f64_s32(int32x2_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t)(__p0);
- return __ret;
-}
-__ai float64x1_t vreinterpret_f64_s64(int64x1_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t)(__p0);
- return __ret;
-}
-__ai float64x1_t vreinterpret_f64_s16(int16x4_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t)(__p0);
- return __ret;
-}
-__ai float32x2_t vreinterpret_f32_p8(poly8x8_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
- return __ret;
-}
-__ai float32x2_t vreinterpret_f32_p64(poly64x1_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
- return __ret;
-}
-__ai float32x2_t vreinterpret_f32_p16(poly16x4_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
- return __ret;
-}
-__ai float32x2_t vreinterpret_f32_u8(uint8x8_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
- return __ret;
-}
-__ai float32x2_t vreinterpret_f32_u32(uint32x2_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
- return __ret;
-}
-__ai float32x2_t vreinterpret_f32_u64(uint64x1_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
- return __ret;
-}
-__ai float32x2_t vreinterpret_f32_u16(uint16x4_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
- return __ret;
-}
-__ai float32x2_t vreinterpret_f32_s8(int8x8_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
- return __ret;
-}
-__ai float32x2_t vreinterpret_f32_f64(float64x1_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
- return __ret;
-}
-__ai float32x2_t vreinterpret_f32_f16(float16x4_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
- return __ret;
-}
-__ai float32x2_t vreinterpret_f32_s32(int32x2_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
- return __ret;
-}
-__ai float32x2_t vreinterpret_f32_s64(int64x1_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
- return __ret;
-}
-__ai float32x2_t vreinterpret_f32_s16(int16x4_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
- return __ret;
-}
-__ai float16x4_t vreinterpret_f16_p8(poly8x8_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
- return __ret;
-}
-__ai float16x4_t vreinterpret_f16_p64(poly64x1_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
- return __ret;
-}
-__ai float16x4_t vreinterpret_f16_p16(poly16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
- return __ret;
-}
-__ai float16x4_t vreinterpret_f16_u8(uint8x8_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
- return __ret;
-}
-__ai float16x4_t vreinterpret_f16_u32(uint32x2_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
- return __ret;
-}
-__ai float16x4_t vreinterpret_f16_u64(uint64x1_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
- return __ret;
-}
-__ai float16x4_t vreinterpret_f16_u16(uint16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
- return __ret;
-}
-__ai float16x4_t vreinterpret_f16_s8(int8x8_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
- return __ret;
-}
-__ai float16x4_t vreinterpret_f16_f64(float64x1_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
- return __ret;
-}
-__ai float16x4_t vreinterpret_f16_f32(float32x2_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
- return __ret;
-}
-__ai float16x4_t vreinterpret_f16_s32(int32x2_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
- return __ret;
-}
-__ai float16x4_t vreinterpret_f16_s64(int64x1_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
- return __ret;
-}
-__ai float16x4_t vreinterpret_f16_s16(int16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_p8(poly8x8_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_p64(poly64x1_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_p16(poly16x4_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_u8(uint8x8_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_u32(uint32x2_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_u64(uint64x1_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_u16(uint16x4_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_s8(int8x8_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_f64(float64x1_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_f32(float32x2_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_f16(float16x4_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_s64(int64x1_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int32x2_t vreinterpret_s32_s16(int16x4_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_p8(poly8x8_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_p64(poly64x1_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_p16(poly16x4_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_u8(uint8x8_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_u32(uint32x2_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_u64(uint64x1_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_u16(uint16x4_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_s8(int8x8_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_f64(float64x1_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_f32(float32x2_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_f16(float16x4_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_s32(int32x2_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int64x1_t vreinterpret_s64_s16(int16x4_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_p8(poly8x8_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_p64(poly64x1_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_p16(poly16x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_u8(uint8x8_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_u32(uint32x2_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_u64(uint64x1_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_u16(uint16x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_s8(int8x8_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_f64(float64x1_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_f32(float32x2_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_f16(float16x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_s32(int32x2_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai int16x4_t vreinterpret_s16_s64(int64x1_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai uint64_t vrshld_u64(uint64_t __p0, int64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vrshld_u64(__p0, __p1);
- return __ret;
-}
-__ai int64_t vrshld_s64(int64_t __p0, int64_t __p1) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vrshld_s64(__p0, __p1);
- return __ret;
-}
-#define vrshrd_n_u64(__p0, __p1) __extension__ ({ \
- uint64_t __ret; \
- uint64_t __s0 = __p0; \
- __ret = (uint64_t) __builtin_neon_vrshrd_n_u64(__s0, __p1); \
- __ret; \
-})
-#define vrshrd_n_s64(__p0, __p1) __extension__ ({ \
- int64_t __ret; \
- int64_t __s0 = __p0; \
- __ret = (int64_t) __builtin_neon_vrshrd_n_s64(__s0, __p1); \
- __ret; \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vrshrn_high_n_u32(__p0_703, __p1_703, __p2_703) __extension__ ({ \
- uint16x8_t __ret_703; \
- uint16x4_t __s0_703 = __p0_703; \
- uint32x4_t __s1_703 = __p1_703; \
- __ret_703 = (uint16x8_t)(vcombine_u16((uint16x4_t)(__s0_703), (uint16x4_t)(vrshrn_n_u32(__s1_703, __p2_703)))); \
- __ret_703; \
-})
-#else
-#define vrshrn_high_n_u32(__p0_704, __p1_704, __p2_704) __extension__ ({ \
- uint16x8_t __ret_704; \
- uint16x4_t __s0_704 = __p0_704; \
- uint32x4_t __s1_704 = __p1_704; \
- uint16x4_t __rev0_704; __rev0_704 = __builtin_shufflevector(__s0_704, __s0_704, 3, 2, 1, 0); \
- uint32x4_t __rev1_704; __rev1_704 = __builtin_shufflevector(__s1_704, __s1_704, 3, 2, 1, 0); \
- __ret_704 = (uint16x8_t)(__noswap_vcombine_u16((uint16x4_t)(__rev0_704), (uint16x4_t)(__noswap_vrshrn_n_u32(__rev1_704, __p2_704)))); \
- __ret_704 = __builtin_shufflevector(__ret_704, __ret_704, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_704; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vrshrn_high_n_u64(__p0_705, __p1_705, __p2_705) __extension__ ({ \
- uint32x4_t __ret_705; \
- uint32x2_t __s0_705 = __p0_705; \
- uint64x2_t __s1_705 = __p1_705; \
- __ret_705 = (uint32x4_t)(vcombine_u32((uint32x2_t)(__s0_705), (uint32x2_t)(vrshrn_n_u64(__s1_705, __p2_705)))); \
- __ret_705; \
-})
-#else
-#define vrshrn_high_n_u64(__p0_706, __p1_706, __p2_706) __extension__ ({ \
- uint32x4_t __ret_706; \
- uint32x2_t __s0_706 = __p0_706; \
- uint64x2_t __s1_706 = __p1_706; \
- uint32x2_t __rev0_706; __rev0_706 = __builtin_shufflevector(__s0_706, __s0_706, 1, 0); \
- uint64x2_t __rev1_706; __rev1_706 = __builtin_shufflevector(__s1_706, __s1_706, 1, 0); \
- __ret_706 = (uint32x4_t)(__noswap_vcombine_u32((uint32x2_t)(__rev0_706), (uint32x2_t)(__noswap_vrshrn_n_u64(__rev1_706, __p2_706)))); \
- __ret_706 = __builtin_shufflevector(__ret_706, __ret_706, 3, 2, 1, 0); \
- __ret_706; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vrshrn_high_n_u16(__p0_707, __p1_707, __p2_707) __extension__ ({ \
- uint8x16_t __ret_707; \
- uint8x8_t __s0_707 = __p0_707; \
- uint16x8_t __s1_707 = __p1_707; \
- __ret_707 = (uint8x16_t)(vcombine_u8((uint8x8_t)(__s0_707), (uint8x8_t)(vrshrn_n_u16(__s1_707, __p2_707)))); \
- __ret_707; \
-})
-#else
-#define vrshrn_high_n_u16(__p0_708, __p1_708, __p2_708) __extension__ ({ \
- uint8x16_t __ret_708; \
- uint8x8_t __s0_708 = __p0_708; \
- uint16x8_t __s1_708 = __p1_708; \
- uint8x8_t __rev0_708; __rev0_708 = __builtin_shufflevector(__s0_708, __s0_708, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x8_t __rev1_708; __rev1_708 = __builtin_shufflevector(__s1_708, __s1_708, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_708 = (uint8x16_t)(__noswap_vcombine_u8((uint8x8_t)(__rev0_708), (uint8x8_t)(__noswap_vrshrn_n_u16(__rev1_708, __p2_708)))); \
- __ret_708 = __builtin_shufflevector(__ret_708, __ret_708, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_708; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vrshrn_high_n_s32(__p0_709, __p1_709, __p2_709) __extension__ ({ \
- int16x8_t __ret_709; \
- int16x4_t __s0_709 = __p0_709; \
- int32x4_t __s1_709 = __p1_709; \
- __ret_709 = (int16x8_t)(vcombine_s16((int16x4_t)(__s0_709), (int16x4_t)(vrshrn_n_s32(__s1_709, __p2_709)))); \
- __ret_709; \
-})
-#else
-#define vrshrn_high_n_s32(__p0_710, __p1_710, __p2_710) __extension__ ({ \
- int16x8_t __ret_710; \
- int16x4_t __s0_710 = __p0_710; \
- int32x4_t __s1_710 = __p1_710; \
- int16x4_t __rev0_710; __rev0_710 = __builtin_shufflevector(__s0_710, __s0_710, 3, 2, 1, 0); \
- int32x4_t __rev1_710; __rev1_710 = __builtin_shufflevector(__s1_710, __s1_710, 3, 2, 1, 0); \
- __ret_710 = (int16x8_t)(__noswap_vcombine_s16((int16x4_t)(__rev0_710), (int16x4_t)(__noswap_vrshrn_n_s32(__rev1_710, __p2_710)))); \
- __ret_710 = __builtin_shufflevector(__ret_710, __ret_710, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_710; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vrshrn_high_n_s64(__p0_711, __p1_711, __p2_711) __extension__ ({ \
- int32x4_t __ret_711; \
- int32x2_t __s0_711 = __p0_711; \
- int64x2_t __s1_711 = __p1_711; \
- __ret_711 = (int32x4_t)(vcombine_s32((int32x2_t)(__s0_711), (int32x2_t)(vrshrn_n_s64(__s1_711, __p2_711)))); \
- __ret_711; \
-})
-#else
-#define vrshrn_high_n_s64(__p0_712, __p1_712, __p2_712) __extension__ ({ \
- int32x4_t __ret_712; \
- int32x2_t __s0_712 = __p0_712; \
- int64x2_t __s1_712 = __p1_712; \
- int32x2_t __rev0_712; __rev0_712 = __builtin_shufflevector(__s0_712, __s0_712, 1, 0); \
- int64x2_t __rev1_712; __rev1_712 = __builtin_shufflevector(__s1_712, __s1_712, 1, 0); \
- __ret_712 = (int32x4_t)(__noswap_vcombine_s32((int32x2_t)(__rev0_712), (int32x2_t)(__noswap_vrshrn_n_s64(__rev1_712, __p2_712)))); \
- __ret_712 = __builtin_shufflevector(__ret_712, __ret_712, 3, 2, 1, 0); \
- __ret_712; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vrshrn_high_n_s16(__p0_713, __p1_713, __p2_713) __extension__ ({ \
- int8x16_t __ret_713; \
- int8x8_t __s0_713 = __p0_713; \
- int16x8_t __s1_713 = __p1_713; \
- __ret_713 = (int8x16_t)(vcombine_s8((int8x8_t)(__s0_713), (int8x8_t)(vrshrn_n_s16(__s1_713, __p2_713)))); \
- __ret_713; \
-})
-#else
-#define vrshrn_high_n_s16(__p0_714, __p1_714, __p2_714) __extension__ ({ \
- int8x16_t __ret_714; \
- int8x8_t __s0_714 = __p0_714; \
- int16x8_t __s1_714 = __p1_714; \
- int8x8_t __rev0_714; __rev0_714 = __builtin_shufflevector(__s0_714, __s0_714, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1_714; __rev1_714 = __builtin_shufflevector(__s1_714, __s1_714, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_714 = (int8x16_t)(__noswap_vcombine_s8((int8x8_t)(__rev0_714), (int8x8_t)(__noswap_vrshrn_n_s16(__rev1_714, __p2_714)))); \
- __ret_714 = __builtin_shufflevector(__ret_714, __ret_714, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_714; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vrsqrteq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vrsqrteq_v((int8x16_t)__p0, 42);
- return __ret;
-}
-#else
-__ai float64x2_t vrsqrteq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vrsqrteq_v((int8x16_t)__rev0, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-__ai float64x1_t vrsqrte_f64(float64x1_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vrsqrte_v((int8x8_t)__p0, 10);
- return __ret;
-}
-__ai float64_t vrsqrted_f64(float64_t __p0) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vrsqrted_f64(__p0);
- return __ret;
-}
-__ai float32_t vrsqrtes_f32(float32_t __p0) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vrsqrtes_f32(__p0);
- return __ret;
-}
-#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vrsqrtsq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vrsqrtsq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
- return __ret;
-}
-#else
-__ai float64x2_t vrsqrtsq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vrsqrtsq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-__ai float64x1_t vrsqrts_f64(float64x1_t __p0, float64x1_t __p1) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vrsqrts_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
- return __ret;
-}
-__ai float64_t vrsqrtsd_f64(float64_t __p0, float64_t __p1) {
- float64_t __ret;
- __ret = (float64_t) __builtin_neon_vrsqrtsd_f64(__p0, __p1);
- return __ret;
-}
-__ai float32_t vrsqrtss_f32(float32_t __p0, float32_t __p1) {
- float32_t __ret;
- __ret = (float32_t) __builtin_neon_vrsqrtss_f32(__p0, __p1);
- return __ret;
-}
-#define vrsrad_n_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64_t __ret; \
- uint64_t __s0 = __p0; \
- uint64_t __s1 = __p1; \
- __ret = (uint64_t) __builtin_neon_vrsrad_n_u64(__s0, __s1, __p2); \
- __ret; \
-})
-#define vrsrad_n_s64(__p0, __p1, __p2) __extension__ ({ \
- int64_t __ret; \
- int64_t __s0 = __p0; \
- int64_t __s1 = __p1; \
- __ret = (int64_t) __builtin_neon_vrsrad_n_s64(__s0, __s1, __p2); \
- __ret; \
-})
-#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vrsubhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
- uint16x8_t __ret;
- __ret = vcombine_u16(__p0, vrsubhn_u32(__p1, __p2));
- return __ret;
-}
-#else
-__ai uint16x8_t vrsubhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
- uint16x8_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- uint32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __noswap_vcombine_u16(__rev0, __noswap_vrsubhn_u32(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vrsubhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
- uint32x4_t __ret;
- __ret = vcombine_u32(__p0, vrsubhn_u64(__p1, __p2));
- return __ret;
-}
-#else
-__ai uint32x4_t vrsubhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
- uint32x4_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- uint64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = __noswap_vcombine_u32(__rev0, __noswap_vrsubhn_u64(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vrsubhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
- uint8x16_t __ret;
- __ret = vcombine_u8(__p0, vrsubhn_u16(__p1, __p2));
- return __ret;
-}
-#else
-__ai uint8x16_t vrsubhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
- uint8x16_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vcombine_u8(__rev0, __noswap_vrsubhn_u16(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vrsubhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int16x8_t __ret;
- __ret = vcombine_s16(__p0, vrsubhn_s32(__p1, __p2));
- return __ret;
-}
-#else
-__ai int16x8_t vrsubhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int16x8_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __noswap_vcombine_s16(__rev0, __noswap_vrsubhn_s32(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vrsubhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
- int32x4_t __ret;
- __ret = vcombine_s32(__p0, vrsubhn_s64(__p1, __p2));
- return __ret;
-}
-#else
-__ai int32x4_t vrsubhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
- int32x4_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- int64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = __noswap_vcombine_s32(__rev0, __noswap_vrsubhn_s64(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vrsubhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int8x16_t __ret;
- __ret = vcombine_s8(__p0, vrsubhn_s16(__p1, __p2));
- return __ret;
-}
-#else
-__ai int8x16_t vrsubhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int8x16_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vcombine_s8(__rev0, __noswap_vrsubhn_s16(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#define vset_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x1_t __ret; \
- poly64_t __s0 = __p0; \
- poly64x1_t __s1 = __p1; \
- __ret = (poly64x1_t) __builtin_neon_vset_lane_i64(__s0, (poly64x1_t)__s1, __p2); \
- __ret; \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vsetq_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2_t __ret; \
- poly64_t __s0 = __p0; \
- poly64x2_t __s1 = __p1; \
- __ret = (poly64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (poly64x2_t)__s1, __p2); \
- __ret; \
-})
-#else
-#define vsetq_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2_t __ret; \
- poly64_t __s0 = __p0; \
- poly64x2_t __s1 = __p1; \
- poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (poly64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (poly64x2_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_vsetq_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2_t __ret; \
- poly64_t __s0 = __p0; \
- poly64x2_t __s1 = __p1; \
- __ret = (poly64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (poly64x2_t)__s1, __p2); \
- __ret; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vsetq_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2_t __ret; \
- float64_t __s0 = __p0; \
- float64x2_t __s1 = __p1; \
- __ret = (float64x2_t) __builtin_neon_vsetq_lane_f64(__s0, (float64x2_t)__s1, __p2); \
- __ret; \
-})
-#else
-#define vsetq_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2_t __ret; \
- float64_t __s0 = __p0; \
- float64x2_t __s1 = __p1; \
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (float64x2_t) __builtin_neon_vsetq_lane_f64(__s0, (float64x2_t)__rev1, __p2); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#define __noswap_vsetq_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2_t __ret; \
- float64_t __s0 = __p0; \
- float64x2_t __s1 = __p1; \
- __ret = (float64x2_t) __builtin_neon_vsetq_lane_f64(__s0, (float64x2_t)__s1, __p2); \
- __ret; \
-})
-#endif
-
-#define vset_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x1_t __ret; \
- float64_t __s0 = __p0; \
- float64x1_t __s1 = __p1; \
- __ret = (float64x1_t) __builtin_neon_vset_lane_f64(__s0, (float64x1_t)__s1, __p2); \
- __ret; \
-})
-__ai uint64_t vshld_u64(uint64_t __p0, int64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vshld_u64(__p0, __p1);
- return __ret;
-}
-__ai int64_t vshld_s64(int64_t __p0, int64_t __p1) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vshld_s64(__p0, __p1);
- return __ret;
-}
-#define vshld_n_u64(__p0, __p1) __extension__ ({ \
- uint64_t __ret; \
- uint64_t __s0 = __p0; \
- __ret = (uint64_t) __builtin_neon_vshld_n_u64(__s0, __p1); \
- __ret; \
-})
-#define vshld_n_s64(__p0, __p1) __extension__ ({ \
- int64_t __ret; \
- int64_t __s0 = __p0; \
- __ret = (int64_t) __builtin_neon_vshld_n_s64(__s0, __p1); \
- __ret; \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vshll_high_n_u8(__p0_715, __p1_715) __extension__ ({ \
- uint16x8_t __ret_715; \
- uint8x16_t __s0_715 = __p0_715; \
- __ret_715 = (uint16x8_t)(vshll_n_u8(vget_high_u8(__s0_715), __p1_715)); \
- __ret_715; \
-})
-#else
-#define vshll_high_n_u8(__p0_716, __p1_716) __extension__ ({ \
- uint16x8_t __ret_716; \
- uint8x16_t __s0_716 = __p0_716; \
- uint8x16_t __rev0_716; __rev0_716 = __builtin_shufflevector(__s0_716, __s0_716, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_716 = (uint16x8_t)(__noswap_vshll_n_u8(__noswap_vget_high_u8(__rev0_716), __p1_716)); \
- __ret_716 = __builtin_shufflevector(__ret_716, __ret_716, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_716; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vshll_high_n_u32(__p0_717, __p1_717) __extension__ ({ \
- uint64x2_t __ret_717; \
- uint32x4_t __s0_717 = __p0_717; \
- __ret_717 = (uint64x2_t)(vshll_n_u32(vget_high_u32(__s0_717), __p1_717)); \
- __ret_717; \
-})
-#else
-#define vshll_high_n_u32(__p0_718, __p1_718) __extension__ ({ \
- uint64x2_t __ret_718; \
- uint32x4_t __s0_718 = __p0_718; \
- uint32x4_t __rev0_718; __rev0_718 = __builtin_shufflevector(__s0_718, __s0_718, 3, 2, 1, 0); \
- __ret_718 = (uint64x2_t)(__noswap_vshll_n_u32(__noswap_vget_high_u32(__rev0_718), __p1_718)); \
- __ret_718 = __builtin_shufflevector(__ret_718, __ret_718, 1, 0); \
- __ret_718; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vshll_high_n_u16(__p0_719, __p1_719) __extension__ ({ \
- uint32x4_t __ret_719; \
- uint16x8_t __s0_719 = __p0_719; \
- __ret_719 = (uint32x4_t)(vshll_n_u16(vget_high_u16(__s0_719), __p1_719)); \
- __ret_719; \
-})
-#else
-#define vshll_high_n_u16(__p0_720, __p1_720) __extension__ ({ \
- uint32x4_t __ret_720; \
- uint16x8_t __s0_720 = __p0_720; \
- uint16x8_t __rev0_720; __rev0_720 = __builtin_shufflevector(__s0_720, __s0_720, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_720 = (uint32x4_t)(__noswap_vshll_n_u16(__noswap_vget_high_u16(__rev0_720), __p1_720)); \
- __ret_720 = __builtin_shufflevector(__ret_720, __ret_720, 3, 2, 1, 0); \
- __ret_720; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vshll_high_n_s8(__p0_721, __p1_721) __extension__ ({ \
- int16x8_t __ret_721; \
- int8x16_t __s0_721 = __p0_721; \
- __ret_721 = (int16x8_t)(vshll_n_s8(vget_high_s8(__s0_721), __p1_721)); \
- __ret_721; \
-})
-#else
-#define vshll_high_n_s8(__p0_722, __p1_722) __extension__ ({ \
- int16x8_t __ret_722; \
- int8x16_t __s0_722 = __p0_722; \
- int8x16_t __rev0_722; __rev0_722 = __builtin_shufflevector(__s0_722, __s0_722, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_722 = (int16x8_t)(__noswap_vshll_n_s8(__noswap_vget_high_s8(__rev0_722), __p1_722)); \
- __ret_722 = __builtin_shufflevector(__ret_722, __ret_722, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_722; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vshll_high_n_s32(__p0_723, __p1_723) __extension__ ({ \
- int64x2_t __ret_723; \
- int32x4_t __s0_723 = __p0_723; \
- __ret_723 = (int64x2_t)(vshll_n_s32(vget_high_s32(__s0_723), __p1_723)); \
- __ret_723; \
-})
-#else
-#define vshll_high_n_s32(__p0_724, __p1_724) __extension__ ({ \
- int64x2_t __ret_724; \
- int32x4_t __s0_724 = __p0_724; \
- int32x4_t __rev0_724; __rev0_724 = __builtin_shufflevector(__s0_724, __s0_724, 3, 2, 1, 0); \
- __ret_724 = (int64x2_t)(__noswap_vshll_n_s32(__noswap_vget_high_s32(__rev0_724), __p1_724)); \
- __ret_724 = __builtin_shufflevector(__ret_724, __ret_724, 1, 0); \
- __ret_724; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vshll_high_n_s16(__p0_725, __p1_725) __extension__ ({ \
- int32x4_t __ret_725; \
- int16x8_t __s0_725 = __p0_725; \
- __ret_725 = (int32x4_t)(vshll_n_s16(vget_high_s16(__s0_725), __p1_725)); \
- __ret_725; \
-})
-#else
-#define vshll_high_n_s16(__p0_726, __p1_726) __extension__ ({ \
- int32x4_t __ret_726; \
- int16x8_t __s0_726 = __p0_726; \
- int16x8_t __rev0_726; __rev0_726 = __builtin_shufflevector(__s0_726, __s0_726, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_726 = (int32x4_t)(__noswap_vshll_n_s16(__noswap_vget_high_s16(__rev0_726), __p1_726)); \
- __ret_726 = __builtin_shufflevector(__ret_726, __ret_726, 3, 2, 1, 0); \
- __ret_726; \
-})
-#endif
-
-#define vshrd_n_u64(__p0, __p1) __extension__ ({ \
- uint64_t __ret; \
- uint64_t __s0 = __p0; \
- __ret = (uint64_t) __builtin_neon_vshrd_n_u64(__s0, __p1); \
- __ret; \
-})
-#define vshrd_n_s64(__p0, __p1) __extension__ ({ \
- int64_t __ret; \
- int64_t __s0 = __p0; \
- __ret = (int64_t) __builtin_neon_vshrd_n_s64(__s0, __p1); \
- __ret; \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vshrn_high_n_u32(__p0_727, __p1_727, __p2_727) __extension__ ({ \
- uint16x8_t __ret_727; \
- uint16x4_t __s0_727 = __p0_727; \
- uint32x4_t __s1_727 = __p1_727; \
- __ret_727 = (uint16x8_t)(vcombine_u16((uint16x4_t)(__s0_727), (uint16x4_t)(vshrn_n_u32(__s1_727, __p2_727)))); \
- __ret_727; \
-})
-#else
-#define vshrn_high_n_u32(__p0_728, __p1_728, __p2_728) __extension__ ({ \
- uint16x8_t __ret_728; \
- uint16x4_t __s0_728 = __p0_728; \
- uint32x4_t __s1_728 = __p1_728; \
- uint16x4_t __rev0_728; __rev0_728 = __builtin_shufflevector(__s0_728, __s0_728, 3, 2, 1, 0); \
- uint32x4_t __rev1_728; __rev1_728 = __builtin_shufflevector(__s1_728, __s1_728, 3, 2, 1, 0); \
- __ret_728 = (uint16x8_t)(__noswap_vcombine_u16((uint16x4_t)(__rev0_728), (uint16x4_t)(__noswap_vshrn_n_u32(__rev1_728, __p2_728)))); \
- __ret_728 = __builtin_shufflevector(__ret_728, __ret_728, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_728; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vshrn_high_n_u64(__p0_729, __p1_729, __p2_729) __extension__ ({ \
- uint32x4_t __ret_729; \
- uint32x2_t __s0_729 = __p0_729; \
- uint64x2_t __s1_729 = __p1_729; \
- __ret_729 = (uint32x4_t)(vcombine_u32((uint32x2_t)(__s0_729), (uint32x2_t)(vshrn_n_u64(__s1_729, __p2_729)))); \
- __ret_729; \
-})
-#else
-#define vshrn_high_n_u64(__p0_730, __p1_730, __p2_730) __extension__ ({ \
- uint32x4_t __ret_730; \
- uint32x2_t __s0_730 = __p0_730; \
- uint64x2_t __s1_730 = __p1_730; \
- uint32x2_t __rev0_730; __rev0_730 = __builtin_shufflevector(__s0_730, __s0_730, 1, 0); \
- uint64x2_t __rev1_730; __rev1_730 = __builtin_shufflevector(__s1_730, __s1_730, 1, 0); \
- __ret_730 = (uint32x4_t)(__noswap_vcombine_u32((uint32x2_t)(__rev0_730), (uint32x2_t)(__noswap_vshrn_n_u64(__rev1_730, __p2_730)))); \
- __ret_730 = __builtin_shufflevector(__ret_730, __ret_730, 3, 2, 1, 0); \
- __ret_730; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vshrn_high_n_u16(__p0_731, __p1_731, __p2_731) __extension__ ({ \
- uint8x16_t __ret_731; \
- uint8x8_t __s0_731 = __p0_731; \
- uint16x8_t __s1_731 = __p1_731; \
- __ret_731 = (uint8x16_t)(vcombine_u8((uint8x8_t)(__s0_731), (uint8x8_t)(vshrn_n_u16(__s1_731, __p2_731)))); \
- __ret_731; \
-})
-#else
-#define vshrn_high_n_u16(__p0_732, __p1_732, __p2_732) __extension__ ({ \
- uint8x16_t __ret_732; \
- uint8x8_t __s0_732 = __p0_732; \
- uint16x8_t __s1_732 = __p1_732; \
- uint8x8_t __rev0_732; __rev0_732 = __builtin_shufflevector(__s0_732, __s0_732, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint16x8_t __rev1_732; __rev1_732 = __builtin_shufflevector(__s1_732, __s1_732, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_732 = (uint8x16_t)(__noswap_vcombine_u8((uint8x8_t)(__rev0_732), (uint8x8_t)(__noswap_vshrn_n_u16(__rev1_732, __p2_732)))); \
- __ret_732 = __builtin_shufflevector(__ret_732, __ret_732, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_732; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vshrn_high_n_s32(__p0_733, __p1_733, __p2_733) __extension__ ({ \
- int16x8_t __ret_733; \
- int16x4_t __s0_733 = __p0_733; \
- int32x4_t __s1_733 = __p1_733; \
- __ret_733 = (int16x8_t)(vcombine_s16((int16x4_t)(__s0_733), (int16x4_t)(vshrn_n_s32(__s1_733, __p2_733)))); \
- __ret_733; \
-})
-#else
-#define vshrn_high_n_s32(__p0_734, __p1_734, __p2_734) __extension__ ({ \
- int16x8_t __ret_734; \
- int16x4_t __s0_734 = __p0_734; \
- int32x4_t __s1_734 = __p1_734; \
- int16x4_t __rev0_734; __rev0_734 = __builtin_shufflevector(__s0_734, __s0_734, 3, 2, 1, 0); \
- int32x4_t __rev1_734; __rev1_734 = __builtin_shufflevector(__s1_734, __s1_734, 3, 2, 1, 0); \
- __ret_734 = (int16x8_t)(__noswap_vcombine_s16((int16x4_t)(__rev0_734), (int16x4_t)(__noswap_vshrn_n_s32(__rev1_734, __p2_734)))); \
- __ret_734 = __builtin_shufflevector(__ret_734, __ret_734, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_734; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vshrn_high_n_s64(__p0_735, __p1_735, __p2_735) __extension__ ({ \
- int32x4_t __ret_735; \
- int32x2_t __s0_735 = __p0_735; \
- int64x2_t __s1_735 = __p1_735; \
- __ret_735 = (int32x4_t)(vcombine_s32((int32x2_t)(__s0_735), (int32x2_t)(vshrn_n_s64(__s1_735, __p2_735)))); \
- __ret_735; \
-})
-#else
-#define vshrn_high_n_s64(__p0_736, __p1_736, __p2_736) __extension__ ({ \
- int32x4_t __ret_736; \
- int32x2_t __s0_736 = __p0_736; \
- int64x2_t __s1_736 = __p1_736; \
- int32x2_t __rev0_736; __rev0_736 = __builtin_shufflevector(__s0_736, __s0_736, 1, 0); \
- int64x2_t __rev1_736; __rev1_736 = __builtin_shufflevector(__s1_736, __s1_736, 1, 0); \
- __ret_736 = (int32x4_t)(__noswap_vcombine_s32((int32x2_t)(__rev0_736), (int32x2_t)(__noswap_vshrn_n_s64(__rev1_736, __p2_736)))); \
- __ret_736 = __builtin_shufflevector(__ret_736, __ret_736, 3, 2, 1, 0); \
- __ret_736; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vshrn_high_n_s16(__p0_737, __p1_737, __p2_737) __extension__ ({ \
- int8x16_t __ret_737; \
- int8x8_t __s0_737 = __p0_737; \
- int16x8_t __s1_737 = __p1_737; \
- __ret_737 = (int8x16_t)(vcombine_s8((int8x8_t)(__s0_737), (int8x8_t)(vshrn_n_s16(__s1_737, __p2_737)))); \
- __ret_737; \
-})
-#else
-#define vshrn_high_n_s16(__p0_738, __p1_738, __p2_738) __extension__ ({ \
- int8x16_t __ret_738; \
- int8x8_t __s0_738 = __p0_738; \
- int16x8_t __s1_738 = __p1_738; \
- int8x8_t __rev0_738; __rev0_738 = __builtin_shufflevector(__s0_738, __s0_738, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1_738; __rev1_738 = __builtin_shufflevector(__s1_738, __s1_738, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_738 = (int8x16_t)(__noswap_vcombine_s8((int8x8_t)(__rev0_738), (int8x8_t)(__noswap_vshrn_n_s16(__rev1_738, __p2_738)))); \
- __ret_738 = __builtin_shufflevector(__ret_738, __ret_738, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_738; \
-})
-#endif
-
-#define vslid_n_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64_t __ret; \
- uint64_t __s0 = __p0; \
- uint64_t __s1 = __p1; \
- __ret = (uint64_t) __builtin_neon_vslid_n_u64(__s0, __s1, __p2); \
- __ret; \
-})
-#define vslid_n_s64(__p0, __p1, __p2) __extension__ ({ \
- int64_t __ret; \
- int64_t __s0 = __p0; \
- int64_t __s1 = __p1; \
- __ret = (int64_t) __builtin_neon_vslid_n_s64(__s0, __s1, __p2); \
- __ret; \
-})
-#define vsli_n_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x1_t __ret; \
- poly64x1_t __s0 = __p0; \
- poly64x1_t __s1 = __p1; \
- __ret = (poly64x1_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 6); \
- __ret; \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vsliq_n_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2_t __ret; \
- poly64x2_t __s0 = __p0; \
- poly64x2_t __s1 = __p1; \
- __ret = (poly64x2_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 38); \
- __ret; \
-})
-#else
-#define vsliq_n_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2_t __ret; \
- poly64x2_t __s0 = __p0; \
- poly64x2_t __s1 = __p1; \
- poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (poly64x2_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 38); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#endif
-
-__ai uint8_t vsqaddb_u8(uint8_t __p0, int8_t __p1) {
- uint8_t __ret;
- __ret = (uint8_t) __builtin_neon_vsqaddb_u8(__p0, __p1);
- return __ret;
-}
-__ai uint32_t vsqadds_u32(uint32_t __p0, int32_t __p1) {
- uint32_t __ret;
- __ret = (uint32_t) __builtin_neon_vsqadds_u32(__p0, __p1);
- return __ret;
-}
-__ai uint64_t vsqaddd_u64(uint64_t __p0, int64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vsqaddd_u64(__p0, __p1);
- return __ret;
-}
-__ai uint16_t vsqaddh_u16(uint16_t __p0, int16_t __p1) {
- uint16_t __ret;
- __ret = (uint16_t) __builtin_neon_vsqaddh_u16(__p0, __p1);
- return __ret;
-}
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vsqaddq_u8(uint8x16_t __p0, int8x16_t __p1) {
- uint8x16_t __ret;
- __ret = (uint8x16_t) __builtin_neon_vsqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
- return __ret;
-}
-#else
-__ai uint8x16_t vsqaddq_u8(uint8x16_t __p0, int8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x16_t) __builtin_neon_vsqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vsqaddq_u32(uint32x4_t __p0, int32x4_t __p1) {
- uint32x4_t __ret;
- __ret = (uint32x4_t) __builtin_neon_vsqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
- return __ret;
-}
-#else
-__ai uint32x4_t vsqaddq_u32(uint32x4_t __p0, int32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint32x4_t) __builtin_neon_vsqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vsqaddq_u64(uint64x2_t __p0, int64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vsqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
- return __ret;
-}
-#else
-__ai uint64x2_t vsqaddq_u64(uint64x2_t __p0, int64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vsqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vsqaddq_u16(uint16x8_t __p0, int16x8_t __p1) {
- uint16x8_t __ret;
- __ret = (uint16x8_t) __builtin_neon_vsqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
- return __ret;
-}
-#else
-__ai uint16x8_t vsqaddq_u16(uint16x8_t __p0, int16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint16x8_t) __builtin_neon_vsqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vsqadd_u8(uint8x8_t __p0, int8x8_t __p1) {
- uint8x8_t __ret;
- __ret = (uint8x8_t) __builtin_neon_vsqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
- return __ret;
-}
-#else
-__ai uint8x8_t vsqadd_u8(uint8x8_t __p0, int8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (uint8x8_t) __builtin_neon_vsqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vsqadd_u32(uint32x2_t __p0, int32x2_t __p1) {
- uint32x2_t __ret;
- __ret = (uint32x2_t) __builtin_neon_vsqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
- return __ret;
-}
-#else
-__ai uint32x2_t vsqadd_u32(uint32x2_t __p0, int32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint32x2_t) __builtin_neon_vsqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-__ai uint64x1_t vsqadd_u64(uint64x1_t __p0, int64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vsqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
- return __ret;
-}
-#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vsqadd_u16(uint16x4_t __p0, int16x4_t __p1) {
- uint16x4_t __ret;
- __ret = (uint16x4_t) __builtin_neon_vsqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
- return __ret;
-}
-#else
-__ai uint16x4_t vsqadd_u16(uint16x4_t __p0, int16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (uint16x4_t) __builtin_neon_vsqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vsqrtq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vsqrtq_v((int8x16_t)__p0, 42);
- return __ret;
-}
-#else
-__ai float64x2_t vsqrtq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vsqrtq_v((int8x16_t)__rev0, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vsqrtq_f32(float32x4_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vsqrtq_v((int8x16_t)__p0, 41);
- return __ret;
-}
-#else
-__ai float32x4_t vsqrtq_f32(float32x4_t __p0) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vsqrtq_v((int8x16_t)__rev0, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-__ai float64x1_t vsqrt_f64(float64x1_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vsqrt_v((int8x8_t)__p0, 10);
- return __ret;
-}
-#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vsqrt_f32(float32x2_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vsqrt_v((int8x8_t)__p0, 9);
- return __ret;
-}
-#else
-__ai float32x2_t vsqrt_f32(float32x2_t __p0) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vsqrt_v((int8x8_t)__rev0, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-#define vsrad_n_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64_t __ret; \
- uint64_t __s0 = __p0; \
- uint64_t __s1 = __p1; \
- __ret = (uint64_t) __builtin_neon_vsrad_n_u64(__s0, __s1, __p2); \
- __ret; \
-})
-#define vsrad_n_s64(__p0, __p1, __p2) __extension__ ({ \
- int64_t __ret; \
- int64_t __s0 = __p0; \
- int64_t __s1 = __p1; \
- __ret = (int64_t) __builtin_neon_vsrad_n_s64(__s0, __s1, __p2); \
- __ret; \
-})
-#define vsrid_n_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64_t __ret; \
- uint64_t __s0 = __p0; \
- uint64_t __s1 = __p1; \
- __ret = (uint64_t) __builtin_neon_vsrid_n_u64(__s0, __s1, __p2); \
- __ret; \
-})
-#define vsrid_n_s64(__p0, __p1, __p2) __extension__ ({ \
- int64_t __ret; \
- int64_t __s0 = __p0; \
- int64_t __s1 = __p1; \
- __ret = (int64_t) __builtin_neon_vsrid_n_s64(__s0, __s1, __p2); \
- __ret; \
-})
-#define vsri_n_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x1_t __ret; \
- poly64x1_t __s0 = __p0; \
- poly64x1_t __s1 = __p1; \
- __ret = (poly64x1_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 6); \
- __ret; \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vsriq_n_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2_t __ret; \
- poly64x2_t __s0 = __p0; \
- poly64x2_t __s1 = __p1; \
- __ret = (poly64x2_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 38); \
- __ret; \
-})
-#else
-#define vsriq_n_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2_t __ret; \
- poly64x2_t __s0 = __p0; \
- poly64x2_t __s1 = __p1; \
- poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
- poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __ret = (poly64x2_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 38); \
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
- __ret; \
-})
-#endif
-
-#define vst1_p64(__p0, __p1) __extension__ ({ \
- poly64x1_t __s1 = __p1; \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 6); \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vst1q_p64(__p0, __p1) __extension__ ({ \
- poly64x2_t __s1 = __p1; \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 38); \
-})
-#else
-#define vst1q_p64(__p0, __p1) __extension__ ({ \
- poly64x2_t __s1 = __p1; \
- poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 38); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst1q_f64(__p0, __p1) __extension__ ({ \
- float64x2_t __s1 = __p1; \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 42); \
-})
-#else
-#define vst1q_f64(__p0, __p1) __extension__ ({ \
- float64x2_t __s1 = __p1; \
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 42); \
-})
-#endif
-
-#define vst1_f64(__p0, __p1) __extension__ ({ \
- float64x1_t __s1 = __p1; \
- __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 10); \
-})
-#define vst1_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x1_t __s1 = __p1; \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 6); \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vst1q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2_t __s1 = __p1; \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 38); \
-})
-#else
-#define vst1q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2_t __s1 = __p1; \
- poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 38); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst1q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2_t __s1 = __p1; \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 42); \
-})
-#else
-#define vst1q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2_t __s1 = __p1; \
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
- __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 42); \
-})
-#endif
-
-#define vst1_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x1_t __s1 = __p1; \
- __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 10); \
-})
-#define vst1_p64_x2(__p0, __p1) __extension__ ({ \
- poly64x1x2_t __s1 = __p1; \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 6); \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vst1q_p64_x2(__p0, __p1) __extension__ ({ \
- poly64x2x2_t __s1 = __p1; \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 38); \
-})
-#else
-#define vst1q_p64_x2(__p0, __p1) __extension__ ({ \
- poly64x2x2_t __s1 = __p1; \
- poly64x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 38); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst1q_f64_x2(__p0, __p1) __extension__ ({ \
- float64x2x2_t __s1 = __p1; \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 42); \
-})
-#else
-#define vst1q_f64_x2(__p0, __p1) __extension__ ({ \
- float64x2x2_t __s1 = __p1; \
- float64x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 42); \
-})
-#endif
-
-#define vst1_f64_x2(__p0, __p1) __extension__ ({ \
- float64x1x2_t __s1 = __p1; \
- __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 10); \
-})
-#define vst1_p64_x3(__p0, __p1) __extension__ ({ \
- poly64x1x3_t __s1 = __p1; \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 6); \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vst1q_p64_x3(__p0, __p1) __extension__ ({ \
- poly64x2x3_t __s1 = __p1; \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 38); \
-})
-#else
-#define vst1q_p64_x3(__p0, __p1) __extension__ ({ \
- poly64x2x3_t __s1 = __p1; \
- poly64x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 38); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst1q_f64_x3(__p0, __p1) __extension__ ({ \
- float64x2x3_t __s1 = __p1; \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 42); \
-})
-#else
-#define vst1q_f64_x3(__p0, __p1) __extension__ ({ \
- float64x2x3_t __s1 = __p1; \
- float64x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 42); \
-})
-#endif
-
-#define vst1_f64_x3(__p0, __p1) __extension__ ({ \
- float64x1x3_t __s1 = __p1; \
- __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 10); \
-})
-#define vst1_p64_x4(__p0, __p1) __extension__ ({ \
- poly64x1x4_t __s1 = __p1; \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 6); \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vst1q_p64_x4(__p0, __p1) __extension__ ({ \
- poly64x2x4_t __s1 = __p1; \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 38); \
-})
-#else
-#define vst1q_p64_x4(__p0, __p1) __extension__ ({ \
- poly64x2x4_t __s1 = __p1; \
- poly64x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 38); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst1q_f64_x4(__p0, __p1) __extension__ ({ \
- float64x2x4_t __s1 = __p1; \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 42); \
-})
-#else
-#define vst1q_f64_x4(__p0, __p1) __extension__ ({ \
- float64x2x4_t __s1 = __p1; \
- float64x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 42); \
-})
-#endif
-
-#define vst1_f64_x4(__p0, __p1) __extension__ ({ \
- float64x1x4_t __s1 = __p1; \
- __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 10); \
-})
-#define vst2_p64(__p0, __p1) __extension__ ({ \
- poly64x1x2_t __s1 = __p1; \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 6); \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vst2q_p64(__p0, __p1) __extension__ ({ \
- poly64x2x2_t __s1 = __p1; \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 38); \
-})
-#else
-#define vst2q_p64(__p0, __p1) __extension__ ({ \
- poly64x2x2_t __s1 = __p1; \
- poly64x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 38); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst2q_u64(__p0, __p1) __extension__ ({ \
- uint64x2x2_t __s1 = __p1; \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 51); \
-})
-#else
-#define vst2q_u64(__p0, __p1) __extension__ ({ \
- uint64x2x2_t __s1 = __p1; \
- uint64x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 51); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst2q_f64(__p0, __p1) __extension__ ({ \
- float64x2x2_t __s1 = __p1; \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 42); \
-})
-#else
-#define vst2q_f64(__p0, __p1) __extension__ ({ \
- float64x2x2_t __s1 = __p1; \
- float64x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 42); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst2q_s64(__p0, __p1) __extension__ ({ \
- int64x2x2_t __s1 = __p1; \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 35); \
-})
-#else
-#define vst2q_s64(__p0, __p1) __extension__ ({ \
- int64x2x2_t __s1 = __p1; \
- int64x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 35); \
-})
-#endif
-
-#define vst2_f64(__p0, __p1) __extension__ ({ \
- float64x1x2_t __s1 = __p1; \
- __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 10); \
-})
-#define vst2_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x1x2_t __s1 = __p1; \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 6); \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vst2q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16x2_t __s1 = __p1; \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 36); \
-})
-#else
-#define vst2q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16x2_t __s1 = __p1; \
- poly8x16x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 36); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst2q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2x2_t __s1 = __p1; \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 38); \
-})
-#else
-#define vst2q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2x2_t __s1 = __p1; \
- poly64x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 38); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst2q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16x2_t __s1 = __p1; \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 48); \
-})
-#else
-#define vst2q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16x2_t __s1 = __p1; \
- uint8x16x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 48); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst2q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2x2_t __s1 = __p1; \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 51); \
-})
-#else
-#define vst2q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2x2_t __s1 = __p1; \
- uint64x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 51); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst2q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16x2_t __s1 = __p1; \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 32); \
-})
-#else
-#define vst2q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16x2_t __s1 = __p1; \
- int8x16x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 32); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst2q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2x2_t __s1 = __p1; \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 42); \
-})
-#else
-#define vst2q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2x2_t __s1 = __p1; \
- float64x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 42); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst2q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2x2_t __s1 = __p1; \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 35); \
-})
-#else
-#define vst2q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2x2_t __s1 = __p1; \
- int64x2x2_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 35); \
-})
-#endif
-
-#define vst2_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x1x2_t __s1 = __p1; \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 19); \
-})
-#define vst2_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x1x2_t __s1 = __p1; \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 10); \
-})
-#define vst2_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x1x2_t __s1 = __p1; \
- __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 3); \
-})
-#define vst3_p64(__p0, __p1) __extension__ ({ \
- poly64x1x3_t __s1 = __p1; \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 6); \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vst3q_p64(__p0, __p1) __extension__ ({ \
- poly64x2x3_t __s1 = __p1; \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 38); \
-})
-#else
-#define vst3q_p64(__p0, __p1) __extension__ ({ \
- poly64x2x3_t __s1 = __p1; \
- poly64x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 38); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst3q_u64(__p0, __p1) __extension__ ({ \
- uint64x2x3_t __s1 = __p1; \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 51); \
-})
-#else
-#define vst3q_u64(__p0, __p1) __extension__ ({ \
- uint64x2x3_t __s1 = __p1; \
- uint64x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 51); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst3q_f64(__p0, __p1) __extension__ ({ \
- float64x2x3_t __s1 = __p1; \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 42); \
-})
-#else
-#define vst3q_f64(__p0, __p1) __extension__ ({ \
- float64x2x3_t __s1 = __p1; \
- float64x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 42); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst3q_s64(__p0, __p1) __extension__ ({ \
- int64x2x3_t __s1 = __p1; \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 35); \
-})
-#else
-#define vst3q_s64(__p0, __p1) __extension__ ({ \
- int64x2x3_t __s1 = __p1; \
- int64x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 35); \
-})
-#endif
-
-#define vst3_f64(__p0, __p1) __extension__ ({ \
- float64x1x3_t __s1 = __p1; \
- __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 10); \
-})
-#define vst3_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x1x3_t __s1 = __p1; \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 6); \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vst3q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16x3_t __s1 = __p1; \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 36); \
-})
-#else
-#define vst3q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16x3_t __s1 = __p1; \
- poly8x16x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 36); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst3q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2x3_t __s1 = __p1; \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 38); \
-})
-#else
-#define vst3q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2x3_t __s1 = __p1; \
- poly64x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 38); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst3q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16x3_t __s1 = __p1; \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 48); \
-})
-#else
-#define vst3q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16x3_t __s1 = __p1; \
- uint8x16x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 48); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst3q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2x3_t __s1 = __p1; \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 51); \
-})
-#else
-#define vst3q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2x3_t __s1 = __p1; \
- uint64x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 51); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst3q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16x3_t __s1 = __p1; \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 32); \
-})
-#else
-#define vst3q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16x3_t __s1 = __p1; \
- int8x16x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 32); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst3q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2x3_t __s1 = __p1; \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 42); \
-})
-#else
-#define vst3q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2x3_t __s1 = __p1; \
- float64x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 42); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst3q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2x3_t __s1 = __p1; \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 35); \
-})
-#else
-#define vst3q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2x3_t __s1 = __p1; \
- int64x2x3_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 35); \
-})
-#endif
-
-#define vst3_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x1x3_t __s1 = __p1; \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 19); \
-})
-#define vst3_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x1x3_t __s1 = __p1; \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 10); \
-})
-#define vst3_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x1x3_t __s1 = __p1; \
- __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 3); \
-})
-#define vst4_p64(__p0, __p1) __extension__ ({ \
- poly64x1x4_t __s1 = __p1; \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 6); \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vst4q_p64(__p0, __p1) __extension__ ({ \
- poly64x2x4_t __s1 = __p1; \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 38); \
-})
-#else
-#define vst4q_p64(__p0, __p1) __extension__ ({ \
- poly64x2x4_t __s1 = __p1; \
- poly64x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 38); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst4q_u64(__p0, __p1) __extension__ ({ \
- uint64x2x4_t __s1 = __p1; \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 51); \
-})
-#else
-#define vst4q_u64(__p0, __p1) __extension__ ({ \
- uint64x2x4_t __s1 = __p1; \
- uint64x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 51); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst4q_f64(__p0, __p1) __extension__ ({ \
- float64x2x4_t __s1 = __p1; \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 42); \
-})
-#else
-#define vst4q_f64(__p0, __p1) __extension__ ({ \
- float64x2x4_t __s1 = __p1; \
- float64x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 42); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst4q_s64(__p0, __p1) __extension__ ({ \
- int64x2x4_t __s1 = __p1; \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 35); \
-})
-#else
-#define vst4q_s64(__p0, __p1) __extension__ ({ \
- int64x2x4_t __s1 = __p1; \
- int64x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 35); \
-})
-#endif
-
-#define vst4_f64(__p0, __p1) __extension__ ({ \
- float64x1x4_t __s1 = __p1; \
- __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 10); \
-})
-#define vst4_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x1x4_t __s1 = __p1; \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 6); \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vst4q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16x4_t __s1 = __p1; \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 36); \
-})
-#else
-#define vst4q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
- poly8x16x4_t __s1 = __p1; \
- poly8x16x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 36); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst4q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2x4_t __s1 = __p1; \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 38); \
-})
-#else
-#define vst4q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
- poly64x2x4_t __s1 = __p1; \
- poly64x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 38); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst4q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16x4_t __s1 = __p1; \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 48); \
-})
-#else
-#define vst4q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
- uint8x16x4_t __s1 = __p1; \
- uint8x16x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 48); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst4q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2x4_t __s1 = __p1; \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 51); \
-})
-#else
-#define vst4q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x2x4_t __s1 = __p1; \
- uint64x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 51); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst4q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16x4_t __s1 = __p1; \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 32); \
-})
-#else
-#define vst4q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
- int8x16x4_t __s1 = __p1; \
- int8x16x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 32); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst4q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2x4_t __s1 = __p1; \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 42); \
-})
-#else
-#define vst4q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x2x4_t __s1 = __p1; \
- float64x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 42); \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vst4q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2x4_t __s1 = __p1; \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 35); \
-})
-#else
-#define vst4q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x2x4_t __s1 = __p1; \
- int64x2x4_t __rev1; \
- __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
- __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
- __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
- __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
- __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 35); \
-})
-#endif
-
-#define vst4_lane_u64(__p0, __p1, __p2) __extension__ ({ \
- uint64x1x4_t __s1 = __p1; \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 19); \
-})
-#define vst4_lane_f64(__p0, __p1, __p2) __extension__ ({ \
- float64x1x4_t __s1 = __p1; \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 10); \
-})
-#define vst4_lane_s64(__p0, __p1, __p2) __extension__ ({ \
- int64x1x4_t __s1 = __p1; \
- __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 3); \
-})
-#define vstrq_p128(__p0, __p1) __extension__ ({ \
- poly128_t __s1 = __p1; \
- __builtin_neon_vstrq_p128(__p0, __s1); \
-})
-__ai uint64_t vsubd_u64(uint64_t __p0, uint64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vsubd_u64(__p0, __p1);
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_p64(poly64x1_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
return __ret;
}
-__ai int64_t vsubd_s64(int64_t __p0, int64_t __p1) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vsubd_s64(__p0, __p1);
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_p16(poly16x4_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
return __ret;
}
-#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vsubq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = __p0 - __p1;
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_u8(uint8x8_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
return __ret;
}
-#else
-__ai float64x2_t vsubq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __rev0 - __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_u32(uint32x2_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
return __ret;
}
-#endif
-
-__ai float64x1_t vsub_f64(float64x1_t __p0, float64x1_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_u64(uint64x1_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_u16(uint16x4_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_f64(float64x1_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_f32(float32x2_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_f16(float16x4_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_s32(int32x2_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_s64(int64x1_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_s16(int16x4_t __p0) {
+ int8x8_t __ret;
+ __ret = (int8x8_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_p8(poly8x8_t __p0) {
float64x1_t __ret;
- __ret = __p0 - __p1;
+ __ret = (float64x1_t)(__p0);
return __ret;
}
-#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vsubhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
- uint16x8_t __ret;
- __ret = vcombine_u16(__p0, vsubhn_u32(__p1, __p2));
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_p64(poly64x1_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t)(__p0);
return __ret;
}
-#else
-__ai uint16x8_t vsubhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
- uint16x8_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- uint32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __noswap_vcombine_u16(__rev0, __noswap_vsubhn_u32(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_p16(poly16x4_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vsubhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
- uint32x4_t __ret;
- __ret = vcombine_u32(__p0, vsubhn_u64(__p1, __p2));
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_u8(uint8x8_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t)(__p0);
return __ret;
}
-#else
-__ai uint32x4_t vsubhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
- uint32x4_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- uint64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = __noswap_vcombine_u32(__rev0, __noswap_vsubhn_u64(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_u32(uint32x2_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vsubhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
- uint8x16_t __ret;
- __ret = vcombine_u8(__p0, vsubhn_u16(__p1, __p2));
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_u64(uint64x1_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t)(__p0);
return __ret;
}
-#else
-__ai uint8x16_t vsubhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
- uint8x16_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vcombine_u8(__rev0, __noswap_vsubhn_u16(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_u16(uint16x4_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vsubhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int16x8_t __ret;
- __ret = vcombine_s16(__p0, vsubhn_s32(__p1, __p2));
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_s8(int8x8_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t)(__p0);
return __ret;
}
-#else
-__ai int16x8_t vsubhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
- int16x8_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = __noswap_vcombine_s16(__rev0, __noswap_vsubhn_s32(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_f32(float32x2_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vsubhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
- int32x4_t __ret;
- __ret = vcombine_s32(__p0, vsubhn_s64(__p1, __p2));
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_f16(float16x4_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t)(__p0);
return __ret;
}
-#else
-__ai int32x4_t vsubhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
- int32x4_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- int64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
- __ret = __noswap_vcombine_s32(__rev0, __noswap_vsubhn_s64(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_s32(int32x2_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vsubhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int8x16_t __ret;
- __ret = vcombine_s8(__p0, vsubhn_s16(__p1, __p2));
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_s64(int64x1_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t)(__p0);
return __ret;
}
-#else
-__ai int8x16_t vsubhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
- int8x16_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vcombine_s8(__rev0, __noswap_vsubhn_s16(__rev1, __rev2));
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_s16(int16x4_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vsubl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint16x8_t __ret;
- __ret = vmovl_high_u8(__p0) - vmovl_high_u8(__p1);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_p8(poly8x8_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-#else
-__ai uint16x8_t vsubl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint16x8_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vmovl_high_u8(__rev0) - __noswap_vmovl_high_u8(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_p64(poly64x1_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vsubl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint64x2_t __ret;
- __ret = vmovl_high_u32(__p0) - vmovl_high_u32(__p1);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_p16(poly16x4_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-#else
-__ai uint64x2_t vsubl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint64x2_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vmovl_high_u32(__rev0) - __noswap_vmovl_high_u32(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_u8(uint8x8_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vsubl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint32x4_t __ret;
- __ret = vmovl_high_u16(__p0) - vmovl_high_u16(__p1);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_u32(uint32x2_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-#else
-__ai uint32x4_t vsubl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint32x4_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vmovl_high_u16(__rev0) - __noswap_vmovl_high_u16(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_u64(uint64x1_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vsubl_high_s8(int8x16_t __p0, int8x16_t __p1) {
- int16x8_t __ret;
- __ret = vmovl_high_s8(__p0) - vmovl_high_s8(__p1);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_u16(uint16x4_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-#else
-__ai int16x8_t vsubl_high_s8(int8x16_t __p0, int8x16_t __p1) {
- int16x8_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vmovl_high_s8(__rev0) - __noswap_vmovl_high_s8(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_s8(int8x8_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vsubl_high_s32(int32x4_t __p0, int32x4_t __p1) {
- int64x2_t __ret;
- __ret = vmovl_high_s32(__p0) - vmovl_high_s32(__p1);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_f64(float64x1_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-#else
-__ai int64x2_t vsubl_high_s32(int32x4_t __p0, int32x4_t __p1) {
- int64x2_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __noswap_vmovl_high_s32(__rev0) - __noswap_vmovl_high_s32(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_f16(float16x4_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vsubl_high_s16(int16x8_t __p0, int16x8_t __p1) {
- int32x4_t __ret;
- __ret = vmovl_high_s16(__p0) - vmovl_high_s16(__p1);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_s32(int32x2_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-#else
-__ai int32x4_t vsubl_high_s16(int16x8_t __p0, int16x8_t __p1) {
- int32x4_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vmovl_high_s16(__rev0) - __noswap_vmovl_high_s16(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_s64(int64x1_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vsubw_high_u8(uint16x8_t __p0, uint8x16_t __p1) {
- uint16x8_t __ret;
- __ret = __p0 - vmovl_high_u8(__p1);
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_s16(int16x4_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t)(__p0);
return __ret;
}
-#else
-__ai uint16x8_t vsubw_high_u8(uint16x8_t __p0, uint8x16_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __noswap_vmovl_high_u8(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_p8(poly8x8_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vsubw_high_u32(uint64x2_t __p0, uint32x4_t __p1) {
- uint64x2_t __ret;
- __ret = __p0 - vmovl_high_u32(__p1);
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_p64(poly64x1_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
return __ret;
}
-#else
-__ai uint64x2_t vsubw_high_u32(uint64x2_t __p0, uint32x4_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 - __noswap_vmovl_high_u32(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_p16(poly16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vsubw_high_u16(uint32x4_t __p0, uint16x8_t __p1) {
- uint32x4_t __ret;
- __ret = __p0 - vmovl_high_u16(__p1);
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_u8(uint8x8_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
return __ret;
}
-#else
-__ai uint32x4_t vsubw_high_u16(uint32x4_t __p0, uint16x8_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __noswap_vmovl_high_u16(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_u32(uint32x2_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_u64(uint64x1_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_u16(uint16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_s8(int8x8_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_f64(float64x1_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_f32(float32x2_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_s32(int32x2_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_s64(int64x1_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_s16(int16x4_t __p0) {
+ float16x4_t __ret;
+ __ret = (float16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_p8(poly8x8_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_p64(poly64x1_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_p16(poly16x4_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_u8(uint8x8_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_u32(uint32x2_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_u64(uint64x1_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_u16(uint16x4_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_s8(int8x8_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_f64(float64x1_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_f32(float32x2_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_f16(float16x4_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_s64(int64x1_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_s16(int16x4_t __p0) {
+ int32x2_t __ret;
+ __ret = (int32x2_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_p8(poly8x8_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_p64(poly64x1_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_p16(poly16x4_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_u8(uint8x8_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
return __ret;
}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_u32(uint32x2_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_u64(uint64x1_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_u16(uint16x4_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_s8(int8x8_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_f64(float64x1_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_f32(float32x2_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_f16(float16x4_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_s32(int32x2_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_s16(int16x4_t __p0) {
+ int64x1_t __ret;
+ __ret = (int64x1_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_p8(poly8x8_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_p64(poly64x1_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_p16(poly16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_u8(uint8x8_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_u32(uint32x2_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_u64(uint64x1_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_u16(uint16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_s8(int8x8_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_f64(float64x1_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_f32(float32x2_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_f16(float16x4_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_s32(int32x2_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_s64(int64x1_t __p0) {
+ int16x4_t __ret;
+ __ret = (int16x4_t)(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vrshld_u64(uint64_t __p0, int64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vrshld_u64(__p0, __p1);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vrshld_s64(int64_t __p0, int64_t __p1) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vrshld_s64(__p0, __p1);
+ return __ret;
+}
+#define vrshrd_n_u64(__p0, __p1) __extension__ ({ \
+ uint64_t __ret; \
+ uint64_t __s0 = __p0; \
+ __ret = (uint64_t) __builtin_neon_vrshrd_n_u64(__s0, __p1); \
+ __ret; \
+})
+#define vrshrd_n_s64(__p0, __p1) __extension__ ({ \
+ int64_t __ret; \
+ int64_t __s0 = __p0; \
+ __ret = (int64_t) __builtin_neon_vrshrd_n_s64(__s0, __p1); \
+ __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vrshrn_high_n_u32(__p0_724, __p1_724, __p2_724) __extension__ ({ \
+ uint16x8_t __ret_724; \
+ uint16x4_t __s0_724 = __p0_724; \
+ uint32x4_t __s1_724 = __p1_724; \
+ __ret_724 = (uint16x8_t)(vcombine_u16((uint16x4_t)(__s0_724), (uint16x4_t)(vrshrn_n_u32(__s1_724, __p2_724)))); \
+ __ret_724; \
+})
+#else
+#define vrshrn_high_n_u32(__p0_725, __p1_725, __p2_725) __extension__ ({ \
+ uint16x8_t __ret_725; \
+ uint16x4_t __s0_725 = __p0_725; \
+ uint32x4_t __s1_725 = __p1_725; \
+ uint16x4_t __rev0_725; __rev0_725 = __builtin_shufflevector(__s0_725, __s0_725, 3, 2, 1, 0); \
+ uint32x4_t __rev1_725; __rev1_725 = __builtin_shufflevector(__s1_725, __s1_725, 3, 2, 1, 0); \
+ __ret_725 = (uint16x8_t)(__noswap_vcombine_u16((uint16x4_t)(__rev0_725), (uint16x4_t)(__noswap_vrshrn_n_u32(__rev1_725, __p2_725)))); \
+ __ret_725 = __builtin_shufflevector(__ret_725, __ret_725, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_725; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vsubw_high_s8(int16x8_t __p0, int8x16_t __p1) {
- int16x8_t __ret;
- __ret = __p0 - vmovl_high_s8(__p1);
- return __ret;
-}
+#define vrshrn_high_n_u64(__p0_726, __p1_726, __p2_726) __extension__ ({ \
+ uint32x4_t __ret_726; \
+ uint32x2_t __s0_726 = __p0_726; \
+ uint64x2_t __s1_726 = __p1_726; \
+ __ret_726 = (uint32x4_t)(vcombine_u32((uint32x2_t)(__s0_726), (uint32x2_t)(vrshrn_n_u64(__s1_726, __p2_726)))); \
+ __ret_726; \
+})
+#else
+#define vrshrn_high_n_u64(__p0_727, __p1_727, __p2_727) __extension__ ({ \
+ uint32x4_t __ret_727; \
+ uint32x2_t __s0_727 = __p0_727; \
+ uint64x2_t __s1_727 = __p1_727; \
+ uint32x2_t __rev0_727; __rev0_727 = __builtin_shufflevector(__s0_727, __s0_727, 1, 0); \
+ uint64x2_t __rev1_727; __rev1_727 = __builtin_shufflevector(__s1_727, __s1_727, 1, 0); \
+ __ret_727 = (uint32x4_t)(__noswap_vcombine_u32((uint32x2_t)(__rev0_727), (uint32x2_t)(__noswap_vrshrn_n_u64(__rev1_727, __p2_727)))); \
+ __ret_727 = __builtin_shufflevector(__ret_727, __ret_727, 3, 2, 1, 0); \
+ __ret_727; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrn_high_n_u16(__p0_728, __p1_728, __p2_728) __extension__ ({ \
+ uint8x16_t __ret_728; \
+ uint8x8_t __s0_728 = __p0_728; \
+ uint16x8_t __s1_728 = __p1_728; \
+ __ret_728 = (uint8x16_t)(vcombine_u8((uint8x8_t)(__s0_728), (uint8x8_t)(vrshrn_n_u16(__s1_728, __p2_728)))); \
+ __ret_728; \
+})
#else
-__ai int16x8_t vsubw_high_s8(int16x8_t __p0, int8x16_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __noswap_vmovl_high_s8(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vrshrn_high_n_u16(__p0_729, __p1_729, __p2_729) __extension__ ({ \
+ uint8x16_t __ret_729; \
+ uint8x8_t __s0_729 = __p0_729; \
+ uint16x8_t __s1_729 = __p1_729; \
+ uint8x8_t __rev0_729; __rev0_729 = __builtin_shufflevector(__s0_729, __s0_729, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev1_729; __rev1_729 = __builtin_shufflevector(__s1_729, __s1_729, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_729 = (uint8x16_t)(__noswap_vcombine_u8((uint8x8_t)(__rev0_729), (uint8x8_t)(__noswap_vrshrn_n_u16(__rev1_729, __p2_729)))); \
+ __ret_729 = __builtin_shufflevector(__ret_729, __ret_729, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_729; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vsubw_high_s32(int64x2_t __p0, int32x4_t __p1) {
- int64x2_t __ret;
- __ret = __p0 - vmovl_high_s32(__p1);
- return __ret;
-}
+#define vrshrn_high_n_s32(__p0_730, __p1_730, __p2_730) __extension__ ({ \
+ int16x8_t __ret_730; \
+ int16x4_t __s0_730 = __p0_730; \
+ int32x4_t __s1_730 = __p1_730; \
+ __ret_730 = (int16x8_t)(vcombine_s16((int16x4_t)(__s0_730), (int16x4_t)(vrshrn_n_s32(__s1_730, __p2_730)))); \
+ __ret_730; \
+})
#else
-__ai int64x2_t vsubw_high_s32(int64x2_t __p0, int32x4_t __p1) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 - __noswap_vmovl_high_s32(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vrshrn_high_n_s32(__p0_731, __p1_731, __p2_731) __extension__ ({ \
+ int16x8_t __ret_731; \
+ int16x4_t __s0_731 = __p0_731; \
+ int32x4_t __s1_731 = __p1_731; \
+ int16x4_t __rev0_731; __rev0_731 = __builtin_shufflevector(__s0_731, __s0_731, 3, 2, 1, 0); \
+ int32x4_t __rev1_731; __rev1_731 = __builtin_shufflevector(__s1_731, __s1_731, 3, 2, 1, 0); \
+ __ret_731 = (int16x8_t)(__noswap_vcombine_s16((int16x4_t)(__rev0_731), (int16x4_t)(__noswap_vrshrn_n_s32(__rev1_731, __p2_731)))); \
+ __ret_731 = __builtin_shufflevector(__ret_731, __ret_731, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_731; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vsubw_high_s16(int32x4_t __p0, int16x8_t __p1) {
- int32x4_t __ret;
- __ret = __p0 - vmovl_high_s16(__p1);
- return __ret;
-}
+#define vrshrn_high_n_s64(__p0_732, __p1_732, __p2_732) __extension__ ({ \
+ int32x4_t __ret_732; \
+ int32x2_t __s0_732 = __p0_732; \
+ int64x2_t __s1_732 = __p1_732; \
+ __ret_732 = (int32x4_t)(vcombine_s32((int32x2_t)(__s0_732), (int32x2_t)(vrshrn_n_s64(__s1_732, __p2_732)))); \
+ __ret_732; \
+})
#else
-__ai int32x4_t vsubw_high_s16(int32x4_t __p0, int16x8_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 - __noswap_vmovl_high_s16(__rev1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vrshrn_high_n_s64(__p0_733, __p1_733, __p2_733) __extension__ ({ \
+ int32x4_t __ret_733; \
+ int32x2_t __s0_733 = __p0_733; \
+ int64x2_t __s1_733 = __p1_733; \
+ int32x2_t __rev0_733; __rev0_733 = __builtin_shufflevector(__s0_733, __s0_733, 1, 0); \
+ int64x2_t __rev1_733; __rev1_733 = __builtin_shufflevector(__s1_733, __s1_733, 1, 0); \
+ __ret_733 = (int32x4_t)(__noswap_vcombine_s32((int32x2_t)(__rev0_733), (int32x2_t)(__noswap_vrshrn_n_s64(__rev1_733, __p2_733)))); \
+ __ret_733 = __builtin_shufflevector(__ret_733, __ret_733, 3, 2, 1, 0); \
+ __ret_733; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vtrn1_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
- return __ret;
-}
+#define vrshrn_high_n_s16(__p0_734, __p1_734, __p2_734) __extension__ ({ \
+ int8x16_t __ret_734; \
+ int8x8_t __s0_734 = __p0_734; \
+ int16x8_t __s1_734 = __p1_734; \
+ __ret_734 = (int8x16_t)(vcombine_s8((int8x8_t)(__s0_734), (int8x8_t)(vrshrn_n_s16(__s1_734, __p2_734)))); \
+ __ret_734; \
+})
#else
-__ai poly8x8_t vtrn1_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vrshrn_high_n_s16(__p0_735, __p1_735, __p2_735) __extension__ ({ \
+ int8x16_t __ret_735; \
+ int8x8_t __s0_735 = __p0_735; \
+ int16x8_t __s1_735 = __p1_735; \
+ int8x8_t __rev0_735; __rev0_735 = __builtin_shufflevector(__s0_735, __s0_735, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1_735; __rev1_735 = __builtin_shufflevector(__s1_735, __s1_735, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_735 = (int8x16_t)(__noswap_vcombine_s8((int8x8_t)(__rev0_735), (int8x8_t)(__noswap_vrshrn_n_s16(__rev1_735, __p2_735)))); \
+ __ret_735 = __builtin_shufflevector(__ret_735, __ret_735, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_735; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x4_t vtrn1_p16(poly16x4_t __p0, poly16x4_t __p1) {
- poly16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
+__ai __attribute__((target("neon"))) float64x2_t vrsqrteq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vrsqrteq_v((int8x16_t)__p0, 42);
return __ret;
}
#else
-__ai poly16x4_t vtrn1_p16(poly16x4_t __p0, poly16x4_t __p1) {
- poly16x4_t __ret;
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float64x2_t vrsqrteq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vrsqrteq_v((int8x16_t)__rev0, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vtrn1q_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30);
+__ai __attribute__((target("neon"))) float64x1_t vrsqrte_f64(float64x1_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vrsqrte_v((int8x8_t)__p0, 10);
return __ret;
}
-#else
-__ai poly8x16_t vtrn1q_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float64_t vrsqrted_f64(float64_t __p0) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vrsqrted_f64(__p0);
+ return __ret;
+}
+__ai __attribute__((target("neon"))) float32_t vrsqrtes_f32(float32_t __p0) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vrsqrtes_f32(__p0);
return __ret;
}
-#endif
-
#ifdef __LITTLE_ENDIAN__
-__ai poly64x2_t vtrn1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
- poly64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+__ai __attribute__((target("neon"))) float64x2_t vrsqrtsq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vrsqrtsq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
return __ret;
}
#else
-__ai poly64x2_t vtrn1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
- poly64x2_t __ret;
- poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+__ai __attribute__((target("neon"))) float64x2_t vrsqrtsq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vrsqrtsq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai poly16x8_t vtrn1q_p16(poly16x8_t __p0, poly16x8_t __p1) {
- poly16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
+__ai __attribute__((target("neon"))) float64x1_t vrsqrts_f64(float64x1_t __p0, float64x1_t __p1) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vrsqrts_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
return __ret;
}
-#else
-__ai poly16x8_t vtrn1q_p16(poly16x8_t __p0, poly16x8_t __p1) {
- poly16x8_t __ret;
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float64_t vrsqrtsd_f64(float64_t __p0, float64_t __p1) {
+ float64_t __ret;
+ __ret = (float64_t) __builtin_neon_vrsqrtsd_f64(__p0, __p1);
return __ret;
}
-#endif
-
+__ai __attribute__((target("neon"))) float32_t vrsqrtss_f32(float32_t __p0, float32_t __p1) {
+ float32_t __ret;
+ __ret = (float32_t) __builtin_neon_vrsqrtss_f32(__p0, __p1);
+ return __ret;
+}
+#define vrsrad_n_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64_t __ret; \
+ uint64_t __s0 = __p0; \
+ uint64_t __s1 = __p1; \
+ __ret = (uint64_t) __builtin_neon_vrsrad_n_u64(__s0, __s1, __p2); \
+ __ret; \
+})
+#define vrsrad_n_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64_t __ret; \
+ int64_t __s0 = __p0; \
+ int64_t __s1 = __p1; \
+ __ret = (int64_t) __builtin_neon_vrsrad_n_s64(__s0, __s1, __p2); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vtrn1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30);
+__ai __attribute__((target("neon"))) uint16x8_t vrsubhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+ uint16x8_t __ret;
+ __ret = vcombine_u16(__p0, vrsubhn_u32(__p1, __p2));
return __ret;
}
#else
-__ai uint8x16_t vtrn1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint16x8_t vrsubhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+ uint16x8_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ uint32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_u16(__rev0, __noswap_vrsubhn_u32(__rev1, __rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vtrn1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vrsubhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
uint32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
+ __ret = vcombine_u32(__p0, vrsubhn_u64(__p1, __p2));
return __ret;
}
#else
-__ai uint32x4_t vtrn1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vrsubhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ uint64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = __noswap_vcombine_u32(__rev0, __noswap_vrsubhn_u64(__rev1, __rev2));
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vtrn1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+__ai __attribute__((target("neon"))) uint8x16_t vrsubhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+ uint8x16_t __ret;
+ __ret = vcombine_u8(__p0, vrsubhn_u16(__p1, __p2));
return __ret;
}
#else
-__ai uint64x2_t vtrn1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vrsubhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+ uint8x16_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_u8(__rev0, __noswap_vrsubhn_u16(__rev1, __rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vtrn1q_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
+__ai __attribute__((target("neon"))) int16x8_t vrsubhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+ int16x8_t __ret;
+ __ret = vcombine_s16(__p0, vrsubhn_s32(__p1, __p2));
return __ret;
}
#else
-__ai uint16x8_t vtrn1q_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
+__ai __attribute__((target("neon"))) int16x8_t vrsubhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+ int16x8_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_s16(__rev0, __noswap_vrsubhn_s32(__rev1, __rev2));
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vtrn1q_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30);
+__ai __attribute__((target("neon"))) int32x4_t vrsubhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+ int32x4_t __ret;
+ __ret = vcombine_s32(__p0, vrsubhn_s64(__p1, __p2));
return __ret;
}
#else
-__ai int8x16_t vtrn1q_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x4_t vrsubhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+ int32x4_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ int64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = __noswap_vcombine_s32(__rev0, __noswap_vrsubhn_s64(__rev1, __rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vtrn1q_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+__ai __attribute__((target("neon"))) int8x16_t vrsubhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+ int8x16_t __ret;
+ __ret = vcombine_s8(__p0, vrsubhn_s16(__p1, __p2));
return __ret;
}
#else
-__ai float64x2_t vtrn1q_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int8x16_t vrsubhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+ int8x16_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_s8(__rev0, __noswap_vrsubhn_s16(__rev1, __rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
+#define vset_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x1_t __ret; \
+ poly64_t __s0 = __p0; \
+ poly64x1_t __s1 = __p1; \
+ __ret = (poly64x1_t) __builtin_neon_vset_lane_i64(__s0, (poly64x1_t)__s1, __p2); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vtrn1q_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
- return __ret;
-}
+#define vsetq_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2_t __ret; \
+ poly64_t __s0 = __p0; \
+ poly64x2_t __s1 = __p1; \
+ __ret = (poly64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (poly64x2_t)__s1, __p2); \
+ __ret; \
+})
#else
-__ai float32x4_t vtrn1q_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vsetq_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2_t __ret; \
+ poly64_t __s0 = __p0; \
+ poly64x2_t __s1 = __p1; \
+ poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (poly64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (poly64x2_t)__rev1, __p2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_vsetq_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2_t __ret; \
+ poly64_t __s0 = __p0; \
+ poly64x2_t __s1 = __p1; \
+ __ret = (poly64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (poly64x2_t)__s1, __p2); \
+ __ret; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vtrn1q_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
+#define vsetq_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2_t __ret; \
+ float64_t __s0 = __p0; \
+ float64x2_t __s1 = __p1; \
+ __ret = (float64x2_t) __builtin_neon_vsetq_lane_f64(__s0, (float64x2_t)__s1, __p2); \
+ __ret; \
+})
+#else
+#define vsetq_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2_t __ret; \
+ float64_t __s0 = __p0; \
+ float64x2_t __s1 = __p1; \
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (float64x2_t) __builtin_neon_vsetq_lane_f64(__s0, (float64x2_t)__rev1, __p2); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
+#define __noswap_vsetq_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2_t __ret; \
+ float64_t __s0 = __p0; \
+ float64x2_t __s1 = __p1; \
+ __ret = (float64x2_t) __builtin_neon_vsetq_lane_f64(__s0, (float64x2_t)__s1, __p2); \
+ __ret; \
+})
+#endif
+
+#define vset_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x1_t __ret; \
+ float64_t __s0 = __p0; \
+ float64x1_t __s1 = __p1; \
+ __ret = (float64x1_t) __builtin_neon_vset_lane_f64(__s0, (float64x1_t)__s1, __p2); \
+ __ret; \
+})
+__ai __attribute__((target("neon"))) uint64_t vshld_u64(uint64_t __p0, int64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vshld_u64(__p0, __p1);
return __ret;
}
-#else
-__ai int32x4_t vtrn1q_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int64_t vshld_s64(int64_t __p0, int64_t __p1) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vshld_s64(__p0, __p1);
return __ret;
}
+#define vshld_n_u64(__p0, __p1) __extension__ ({ \
+ uint64_t __ret; \
+ uint64_t __s0 = __p0; \
+ __ret = (uint64_t) __builtin_neon_vshld_n_u64(__s0, __p1); \
+ __ret; \
+})
+#define vshld_n_s64(__p0, __p1) __extension__ ({ \
+ int64_t __ret; \
+ int64_t __s0 = __p0; \
+ __ret = (int64_t) __builtin_neon_vshld_n_s64(__s0, __p1); \
+ __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vshll_high_n_u8(__p0_736, __p1_736) __extension__ ({ \
+ uint16x8_t __ret_736; \
+ uint8x16_t __s0_736 = __p0_736; \
+ __ret_736 = (uint16x8_t)(vshll_n_u8(vget_high_u8(__s0_736), __p1_736)); \
+ __ret_736; \
+})
+#else
+#define vshll_high_n_u8(__p0_737, __p1_737) __extension__ ({ \
+ uint16x8_t __ret_737; \
+ uint8x16_t __s0_737 = __p0_737; \
+ uint8x16_t __rev0_737; __rev0_737 = __builtin_shufflevector(__s0_737, __s0_737, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_737 = (uint16x8_t)(__noswap_vshll_n_u8(__noswap_vget_high_u8(__rev0_737), __p1_737)); \
+ __ret_737 = __builtin_shufflevector(__ret_737, __ret_737, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_737; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vtrn1q_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
- return __ret;
-}
+#define vshll_high_n_u32(__p0_738, __p1_738) __extension__ ({ \
+ uint64x2_t __ret_738; \
+ uint32x4_t __s0_738 = __p0_738; \
+ __ret_738 = (uint64x2_t)(vshll_n_u32(vget_high_u32(__s0_738), __p1_738)); \
+ __ret_738; \
+})
#else
-__ai int64x2_t vtrn1q_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vshll_high_n_u32(__p0_739, __p1_739) __extension__ ({ \
+ uint64x2_t __ret_739; \
+ uint32x4_t __s0_739 = __p0_739; \
+ uint32x4_t __rev0_739; __rev0_739 = __builtin_shufflevector(__s0_739, __s0_739, 3, 2, 1, 0); \
+ __ret_739 = (uint64x2_t)(__noswap_vshll_n_u32(__noswap_vget_high_u32(__rev0_739), __p1_739)); \
+ __ret_739 = __builtin_shufflevector(__ret_739, __ret_739, 1, 0); \
+ __ret_739; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vtrn1q_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
- return __ret;
-}
+#define vshll_high_n_u16(__p0_740, __p1_740) __extension__ ({ \
+ uint32x4_t __ret_740; \
+ uint16x8_t __s0_740 = __p0_740; \
+ __ret_740 = (uint32x4_t)(vshll_n_u16(vget_high_u16(__s0_740), __p1_740)); \
+ __ret_740; \
+})
#else
-__ai int16x8_t vtrn1q_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vshll_high_n_u16(__p0_741, __p1_741) __extension__ ({ \
+ uint32x4_t __ret_741; \
+ uint16x8_t __s0_741 = __p0_741; \
+ uint16x8_t __rev0_741; __rev0_741 = __builtin_shufflevector(__s0_741, __s0_741, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_741 = (uint32x4_t)(__noswap_vshll_n_u16(__noswap_vget_high_u16(__rev0_741), __p1_741)); \
+ __ret_741 = __builtin_shufflevector(__ret_741, __ret_741, 3, 2, 1, 0); \
+ __ret_741; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vtrn1_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
- return __ret;
-}
+#define vshll_high_n_s8(__p0_742, __p1_742) __extension__ ({ \
+ int16x8_t __ret_742; \
+ int8x16_t __s0_742 = __p0_742; \
+ __ret_742 = (int16x8_t)(vshll_n_s8(vget_high_s8(__s0_742), __p1_742)); \
+ __ret_742; \
+})
#else
-__ai uint8x8_t vtrn1_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vshll_high_n_s8(__p0_743, __p1_743) __extension__ ({ \
+ int16x8_t __ret_743; \
+ int8x16_t __s0_743 = __p0_743; \
+ int8x16_t __rev0_743; __rev0_743 = __builtin_shufflevector(__s0_743, __s0_743, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_743 = (int16x8_t)(__noswap_vshll_n_s8(__noswap_vget_high_s8(__rev0_743), __p1_743)); \
+ __ret_743 = __builtin_shufflevector(__ret_743, __ret_743, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_743; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vtrn1_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
- return __ret;
-}
+#define vshll_high_n_s32(__p0_744, __p1_744) __extension__ ({ \
+ int64x2_t __ret_744; \
+ int32x4_t __s0_744 = __p0_744; \
+ __ret_744 = (int64x2_t)(vshll_n_s32(vget_high_s32(__s0_744), __p1_744)); \
+ __ret_744; \
+})
#else
-__ai uint32x2_t vtrn1_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vshll_high_n_s32(__p0_745, __p1_745) __extension__ ({ \
+ int64x2_t __ret_745; \
+ int32x4_t __s0_745 = __p0_745; \
+ int32x4_t __rev0_745; __rev0_745 = __builtin_shufflevector(__s0_745, __s0_745, 3, 2, 1, 0); \
+ __ret_745 = (int64x2_t)(__noswap_vshll_n_s32(__noswap_vget_high_s32(__rev0_745), __p1_745)); \
+ __ret_745 = __builtin_shufflevector(__ret_745, __ret_745, 1, 0); \
+ __ret_745; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vtrn1_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
- return __ret;
-}
+#define vshll_high_n_s16(__p0_746, __p1_746) __extension__ ({ \
+ int32x4_t __ret_746; \
+ int16x8_t __s0_746 = __p0_746; \
+ __ret_746 = (int32x4_t)(vshll_n_s16(vget_high_s16(__s0_746), __p1_746)); \
+ __ret_746; \
+})
#else
-__ai uint16x4_t vtrn1_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vshll_high_n_s16(__p0_747, __p1_747) __extension__ ({ \
+ int32x4_t __ret_747; \
+ int16x8_t __s0_747 = __p0_747; \
+ int16x8_t __rev0_747; __rev0_747 = __builtin_shufflevector(__s0_747, __s0_747, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_747 = (int32x4_t)(__noswap_vshll_n_s16(__noswap_vget_high_s16(__rev0_747), __p1_747)); \
+ __ret_747 = __builtin_shufflevector(__ret_747, __ret_747, 3, 2, 1, 0); \
+ __ret_747; \
+})
#endif
+#define vshrd_n_u64(__p0, __p1) __extension__ ({ \
+ uint64_t __ret; \
+ uint64_t __s0 = __p0; \
+ __ret = (uint64_t) __builtin_neon_vshrd_n_u64(__s0, __p1); \
+ __ret; \
+})
+#define vshrd_n_s64(__p0, __p1) __extension__ ({ \
+ int64_t __ret; \
+ int64_t __s0 = __p0; \
+ __ret = (int64_t) __builtin_neon_vshrd_n_s64(__s0, __p1); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vtrn1_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
- return __ret;
-}
+#define vshrn_high_n_u32(__p0_748, __p1_748, __p2_748) __extension__ ({ \
+ uint16x8_t __ret_748; \
+ uint16x4_t __s0_748 = __p0_748; \
+ uint32x4_t __s1_748 = __p1_748; \
+ __ret_748 = (uint16x8_t)(vcombine_u16((uint16x4_t)(__s0_748), (uint16x4_t)(vshrn_n_u32(__s1_748, __p2_748)))); \
+ __ret_748; \
+})
#else
-__ai int8x8_t vtrn1_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vshrn_high_n_u32(__p0_749, __p1_749, __p2_749) __extension__ ({ \
+ uint16x8_t __ret_749; \
+ uint16x4_t __s0_749 = __p0_749; \
+ uint32x4_t __s1_749 = __p1_749; \
+ uint16x4_t __rev0_749; __rev0_749 = __builtin_shufflevector(__s0_749, __s0_749, 3, 2, 1, 0); \
+ uint32x4_t __rev1_749; __rev1_749 = __builtin_shufflevector(__s1_749, __s1_749, 3, 2, 1, 0); \
+ __ret_749 = (uint16x8_t)(__noswap_vcombine_u16((uint16x4_t)(__rev0_749), (uint16x4_t)(__noswap_vshrn_n_u32(__rev1_749, __p2_749)))); \
+ __ret_749 = __builtin_shufflevector(__ret_749, __ret_749, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_749; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vtrn1_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
- return __ret;
-}
+#define vshrn_high_n_u64(__p0_750, __p1_750, __p2_750) __extension__ ({ \
+ uint32x4_t __ret_750; \
+ uint32x2_t __s0_750 = __p0_750; \
+ uint64x2_t __s1_750 = __p1_750; \
+ __ret_750 = (uint32x4_t)(vcombine_u32((uint32x2_t)(__s0_750), (uint32x2_t)(vshrn_n_u64(__s1_750, __p2_750)))); \
+ __ret_750; \
+})
#else
-__ai float32x2_t vtrn1_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vshrn_high_n_u64(__p0_751, __p1_751, __p2_751) __extension__ ({ \
+ uint32x4_t __ret_751; \
+ uint32x2_t __s0_751 = __p0_751; \
+ uint64x2_t __s1_751 = __p1_751; \
+ uint32x2_t __rev0_751; __rev0_751 = __builtin_shufflevector(__s0_751, __s0_751, 1, 0); \
+ uint64x2_t __rev1_751; __rev1_751 = __builtin_shufflevector(__s1_751, __s1_751, 1, 0); \
+ __ret_751 = (uint32x4_t)(__noswap_vcombine_u32((uint32x2_t)(__rev0_751), (uint32x2_t)(__noswap_vshrn_n_u64(__rev1_751, __p2_751)))); \
+ __ret_751 = __builtin_shufflevector(__ret_751, __ret_751, 3, 2, 1, 0); \
+ __ret_751; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vtrn1_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
- return __ret;
-}
+#define vshrn_high_n_u16(__p0_752, __p1_752, __p2_752) __extension__ ({ \
+ uint8x16_t __ret_752; \
+ uint8x8_t __s0_752 = __p0_752; \
+ uint16x8_t __s1_752 = __p1_752; \
+ __ret_752 = (uint8x16_t)(vcombine_u8((uint8x8_t)(__s0_752), (uint8x8_t)(vshrn_n_u16(__s1_752, __p2_752)))); \
+ __ret_752; \
+})
#else
-__ai int32x2_t vtrn1_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vshrn_high_n_u16(__p0_753, __p1_753, __p2_753) __extension__ ({ \
+ uint8x16_t __ret_753; \
+ uint8x8_t __s0_753 = __p0_753; \
+ uint16x8_t __s1_753 = __p1_753; \
+ uint8x8_t __rev0_753; __rev0_753 = __builtin_shufflevector(__s0_753, __s0_753, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint16x8_t __rev1_753; __rev1_753 = __builtin_shufflevector(__s1_753, __s1_753, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_753 = (uint8x16_t)(__noswap_vcombine_u8((uint8x8_t)(__rev0_753), (uint8x8_t)(__noswap_vshrn_n_u16(__rev1_753, __p2_753)))); \
+ __ret_753 = __builtin_shufflevector(__ret_753, __ret_753, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_753; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vtrn1_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
- return __ret;
-}
+#define vshrn_high_n_s32(__p0_754, __p1_754, __p2_754) __extension__ ({ \
+ int16x8_t __ret_754; \
+ int16x4_t __s0_754 = __p0_754; \
+ int32x4_t __s1_754 = __p1_754; \
+ __ret_754 = (int16x8_t)(vcombine_s16((int16x4_t)(__s0_754), (int16x4_t)(vshrn_n_s32(__s1_754, __p2_754)))); \
+ __ret_754; \
+})
#else
-__ai int16x4_t vtrn1_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vshrn_high_n_s32(__p0_755, __p1_755, __p2_755) __extension__ ({ \
+ int16x8_t __ret_755; \
+ int16x4_t __s0_755 = __p0_755; \
+ int32x4_t __s1_755 = __p1_755; \
+ int16x4_t __rev0_755; __rev0_755 = __builtin_shufflevector(__s0_755, __s0_755, 3, 2, 1, 0); \
+ int32x4_t __rev1_755; __rev1_755 = __builtin_shufflevector(__s1_755, __s1_755, 3, 2, 1, 0); \
+ __ret_755 = (int16x8_t)(__noswap_vcombine_s16((int16x4_t)(__rev0_755), (int16x4_t)(__noswap_vshrn_n_s32(__rev1_755, __p2_755)))); \
+ __ret_755 = __builtin_shufflevector(__ret_755, __ret_755, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_755; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vtrn2_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
- return __ret;
-}
+#define vshrn_high_n_s64(__p0_756, __p1_756, __p2_756) __extension__ ({ \
+ int32x4_t __ret_756; \
+ int32x2_t __s0_756 = __p0_756; \
+ int64x2_t __s1_756 = __p1_756; \
+ __ret_756 = (int32x4_t)(vcombine_s32((int32x2_t)(__s0_756), (int32x2_t)(vshrn_n_s64(__s1_756, __p2_756)))); \
+ __ret_756; \
+})
#else
-__ai poly8x8_t vtrn2_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vshrn_high_n_s64(__p0_757, __p1_757, __p2_757) __extension__ ({ \
+ int32x4_t __ret_757; \
+ int32x2_t __s0_757 = __p0_757; \
+ int64x2_t __s1_757 = __p1_757; \
+ int32x2_t __rev0_757; __rev0_757 = __builtin_shufflevector(__s0_757, __s0_757, 1, 0); \
+ int64x2_t __rev1_757; __rev1_757 = __builtin_shufflevector(__s1_757, __s1_757, 1, 0); \
+ __ret_757 = (int32x4_t)(__noswap_vcombine_s32((int32x2_t)(__rev0_757), (int32x2_t)(__noswap_vshrn_n_s64(__rev1_757, __p2_757)))); \
+ __ret_757 = __builtin_shufflevector(__ret_757, __ret_757, 3, 2, 1, 0); \
+ __ret_757; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x4_t vtrn2_p16(poly16x4_t __p0, poly16x4_t __p1) {
- poly16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
- return __ret;
-}
+#define vshrn_high_n_s16(__p0_758, __p1_758, __p2_758) __extension__ ({ \
+ int8x16_t __ret_758; \
+ int8x8_t __s0_758 = __p0_758; \
+ int16x8_t __s1_758 = __p1_758; \
+ __ret_758 = (int8x16_t)(vcombine_s8((int8x8_t)(__s0_758), (int8x8_t)(vshrn_n_s16(__s1_758, __p2_758)))); \
+ __ret_758; \
+})
#else
-__ai poly16x4_t vtrn2_p16(poly16x4_t __p0, poly16x4_t __p1) {
- poly16x4_t __ret;
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vshrn_high_n_s16(__p0_759, __p1_759, __p2_759) __extension__ ({ \
+ int8x16_t __ret_759; \
+ int8x8_t __s0_759 = __p0_759; \
+ int16x8_t __s1_759 = __p1_759; \
+ int8x8_t __rev0_759; __rev0_759 = __builtin_shufflevector(__s0_759, __s0_759, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1_759; __rev1_759 = __builtin_shufflevector(__s1_759, __s1_759, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_759 = (int8x16_t)(__noswap_vcombine_s8((int8x8_t)(__rev0_759), (int8x8_t)(__noswap_vshrn_n_s16(__rev1_759, __p2_759)))); \
+ __ret_759 = __builtin_shufflevector(__ret_759, __ret_759, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_759; \
+})
#endif
+#define vslid_n_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64_t __ret; \
+ uint64_t __s0 = __p0; \
+ uint64_t __s1 = __p1; \
+ __ret = (uint64_t) __builtin_neon_vslid_n_u64(__s0, __s1, __p2); \
+ __ret; \
+})
+#define vslid_n_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64_t __ret; \
+ int64_t __s0 = __p0; \
+ int64_t __s1 = __p1; \
+ __ret = (int64_t) __builtin_neon_vslid_n_s64(__s0, __s1, __p2); \
+ __ret; \
+})
+#define vsli_n_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x1_t __ret; \
+ poly64x1_t __s0 = __p0; \
+ poly64x1_t __s1 = __p1; \
+ __ret = (poly64x1_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 6); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vtrn2q_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31);
- return __ret;
-}
+#define vsliq_n_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2_t __ret; \
+ poly64x2_t __s0 = __p0; \
+ poly64x2_t __s1 = __p1; \
+ __ret = (poly64x2_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 38); \
+ __ret; \
+})
#else
-__ai poly8x16_t vtrn2q_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vsliq_n_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2_t __ret; \
+ poly64x2_t __s0 = __p0; \
+ poly64x2_t __s1 = __p1; \
+ poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (poly64x2_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 38); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai poly64x2_t vtrn2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
- poly64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+__ai __attribute__((target("neon"))) uint8_t vsqaddb_u8(uint8_t __p0, int8_t __p1) {
+ uint8_t __ret;
+ __ret = (uint8_t) __builtin_neon_vsqaddb_u8(__p0, __p1);
return __ret;
}
-#else
-__ai poly64x2_t vtrn2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
- poly64x2_t __ret;
- poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) uint32_t vsqadds_u32(uint32_t __p0, int32_t __p1) {
+ uint32_t __ret;
+ __ret = (uint32_t) __builtin_neon_vsqadds_u32(__p0, __p1);
return __ret;
}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai poly16x8_t vtrn2q_p16(poly16x8_t __p0, poly16x8_t __p1) {
- poly16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
+__ai __attribute__((target("neon"))) uint64_t vsqaddd_u64(uint64_t __p0, int64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vsqaddd_u64(__p0, __p1);
return __ret;
}
-#else
-__ai poly16x8_t vtrn2q_p16(poly16x8_t __p0, poly16x8_t __p1) {
- poly16x8_t __ret;
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint16_t vsqaddh_u16(uint16_t __p0, int16_t __p1) {
+ uint16_t __ret;
+ __ret = (uint16_t) __builtin_neon_vsqaddh_u16(__p0, __p1);
return __ret;
}
-#endif
-
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vtrn2q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint8x16_t vsqaddq_u8(uint8x16_t __p0, int8x16_t __p1) {
uint8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31);
+ __ret = (uint8x16_t) __builtin_neon_vsqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
return __ret;
}
#else
-__ai uint8x16_t vtrn2q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint8x16_t vsqaddq_u8(uint8x16_t __p0, int8x16_t __p1) {
uint8x16_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x16_t) __builtin_neon_vsqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vtrn2q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vsqaddq_u32(uint32x4_t __p0, int32x4_t __p1) {
uint32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
+ __ret = (uint32x4_t) __builtin_neon_vsqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
return __ret;
}
#else
-__ai uint32x4_t vtrn2q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vsqaddq_u32(uint32x4_t __p0, int32x4_t __p1) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint32x4_t) __builtin_neon_vsqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vtrn2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vsqaddq_u64(uint64x2_t __p0, int64x2_t __p1) {
uint64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+ __ret = (uint64x2_t) __builtin_neon_vsqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
return __ret;
}
#else
-__ai uint64x2_t vtrn2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vsqaddq_u64(uint64x2_t __p0, int64x2_t __p1) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vsqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vtrn2q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vsqaddq_u16(uint16x8_t __p0, int16x8_t __p1) {
uint16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
+ __ret = (uint16x8_t) __builtin_neon_vsqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
return __ret;
}
#else
-__ai uint16x8_t vtrn2q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vsqaddq_u16(uint16x8_t __p0, int16x8_t __p1) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint16x8_t) __builtin_neon_vsqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vtrn2q_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31);
+__ai __attribute__((target("neon"))) uint8x8_t vsqadd_u8(uint8x8_t __p0, int8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = (uint8x8_t) __builtin_neon_vsqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
return __ret;
}
#else
-__ai int8x16_t vtrn2q_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x8_t vsqadd_u8(uint8x8_t __p0, int8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (uint8x8_t) __builtin_neon_vsqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vtrn2q_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+__ai __attribute__((target("neon"))) uint32x2_t vsqadd_u32(uint32x2_t __p0, int32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = (uint32x2_t) __builtin_neon_vsqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
return __ret;
}
#else
-__ai float64x2_t vtrn2q_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+__ai __attribute__((target("neon"))) uint32x2_t vsqadd_u32(uint32x2_t __p0, int32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint32x2_t) __builtin_neon_vsqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
+__ai __attribute__((target("neon"))) uint64x1_t vsqadd_u64(uint64x1_t __p0, int64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vsqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vtrn2q_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
+__ai __attribute__((target("neon"))) uint16x4_t vsqadd_u16(uint16x4_t __p0, int16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = (uint16x4_t) __builtin_neon_vsqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
return __ret;
}
#else
-__ai float32x4_t vtrn2q_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
+__ai __attribute__((target("neon"))) uint16x4_t vsqadd_u16(uint16x4_t __p0, int16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (uint16x4_t) __builtin_neon_vsqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vtrn2q_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
+__ai __attribute__((target("neon"))) float64x2_t vsqrtq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ __ret = (float64x2_t) __builtin_neon_vsqrtq_v((int8x16_t)__p0, 42);
return __ret;
}
#else
-__ai int32x4_t vtrn2q_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float64x2_t vsqrtq_f64(float64x2_t __p0) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float64x2_t) __builtin_neon_vsqrtq_v((int8x16_t)__rev0, 42);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vtrn2q_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+__ai __attribute__((target("neon"))) float32x4_t vsqrtq_f32(float32x4_t __p0) {
+ float32x4_t __ret;
+ __ret = (float32x4_t) __builtin_neon_vsqrtq_v((int8x16_t)__p0, 41);
return __ret;
}
#else
-__ai int64x2_t vtrn2q_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) float32x4_t vsqrtq_f32(float32x4_t __p0) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ __ret = (float32x4_t) __builtin_neon_vsqrtq_v((int8x16_t)__rev0, 41);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
+__ai __attribute__((target("neon"))) float64x1_t vsqrt_f64(float64x1_t __p0) {
+ float64x1_t __ret;
+ __ret = (float64x1_t) __builtin_neon_vsqrt_v((int8x8_t)__p0, 10);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vtrn2q_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
+__ai __attribute__((target("neon"))) float32x2_t vsqrt_f32(float32x2_t __p0) {
+ float32x2_t __ret;
+ __ret = (float32x2_t) __builtin_neon_vsqrt_v((int8x8_t)__p0, 9);
return __ret;
}
#else
-__ai int16x8_t vtrn2q_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x2_t vsqrt_f32(float32x2_t __p0) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ __ret = (float32x2_t) __builtin_neon_vsqrt_v((int8x8_t)__rev0, 9);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
+#define vsrad_n_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64_t __ret; \
+ uint64_t __s0 = __p0; \
+ uint64_t __s1 = __p1; \
+ __ret = (uint64_t) __builtin_neon_vsrad_n_u64(__s0, __s1, __p2); \
+ __ret; \
+})
+#define vsrad_n_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64_t __ret; \
+ int64_t __s0 = __p0; \
+ int64_t __s1 = __p1; \
+ __ret = (int64_t) __builtin_neon_vsrad_n_s64(__s0, __s1, __p2); \
+ __ret; \
+})
+#define vsrid_n_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64_t __ret; \
+ uint64_t __s0 = __p0; \
+ uint64_t __s1 = __p1; \
+ __ret = (uint64_t) __builtin_neon_vsrid_n_u64(__s0, __s1, __p2); \
+ __ret; \
+})
+#define vsrid_n_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64_t __ret; \
+ int64_t __s0 = __p0; \
+ int64_t __s1 = __p1; \
+ __ret = (int64_t) __builtin_neon_vsrid_n_s64(__s0, __s1, __p2); \
+ __ret; \
+})
+#define vsri_n_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x1_t __ret; \
+ poly64x1_t __s0 = __p0; \
+ poly64x1_t __s1 = __p1; \
+ __ret = (poly64x1_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 6); \
+ __ret; \
+})
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vtrn2_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
- return __ret;
-}
+#define vsriq_n_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2_t __ret; \
+ poly64x2_t __s0 = __p0; \
+ poly64x2_t __s1 = __p1; \
+ __ret = (poly64x2_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 38); \
+ __ret; \
+})
#else
-__ai uint8x8_t vtrn2_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vsriq_n_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2_t __ret; \
+ poly64x2_t __s0 = __p0; \
+ poly64x2_t __s1 = __p1; \
+ poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+ poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __ret = (poly64x2_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 38); \
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+ __ret; \
+})
#endif
+#define vst1_p64(__p0, __p1) __extension__ ({ \
+ poly64x1_t __s1 = __p1; \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 6); \
+})
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vtrn2_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
- return __ret;
-}
+#define vst1q_p64(__p0, __p1) __extension__ ({ \
+ poly64x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 38); \
+})
#else
-__ai uint32x2_t vtrn2_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst1q_p64(__p0, __p1) __extension__ ({ \
+ poly64x2_t __s1 = __p1; \
+ poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 38); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vtrn2_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
- return __ret;
-}
+#define vst1q_f64(__p0, __p1) __extension__ ({ \
+ float64x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 42); \
+})
#else
-__ai uint16x4_t vtrn2_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst1q_f64(__p0, __p1) __extension__ ({ \
+ float64x2_t __s1 = __p1; \
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 42); \
+})
#endif
+#define vst1_f64(__p0, __p1) __extension__ ({ \
+ float64x1_t __s1 = __p1; \
+ __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 10); \
+})
+#define vst1_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x1_t __s1 = __p1; \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 6); \
+})
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vtrn2_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
- return __ret;
-}
+#define vst1q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 38); \
+})
#else
-__ai int8x8_t vtrn2_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst1q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2_t __s1 = __p1; \
+ poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 38); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vtrn2_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
- return __ret;
-}
+#define vst1q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 42); \
+})
#else
-__ai float32x2_t vtrn2_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst1q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2_t __s1 = __p1; \
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+ __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 42); \
+})
#endif
+#define vst1_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x1_t __s1 = __p1; \
+ __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 10); \
+})
+#define vst1_p64_x2(__p0, __p1) __extension__ ({ \
+ poly64x1x2_t __s1 = __p1; \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 6); \
+})
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vtrn2_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
- return __ret;
-}
+#define vst1q_p64_x2(__p0, __p1) __extension__ ({ \
+ poly64x2x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 38); \
+})
#else
-__ai int32x2_t vtrn2_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst1q_p64_x2(__p0, __p1) __extension__ ({ \
+ poly64x2x2_t __s1 = __p1; \
+ poly64x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 38); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vtrn2_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
- return __ret;
-}
+#define vst1q_f64_x2(__p0, __p1) __extension__ ({ \
+ float64x2x2_t __s1 = __p1; \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 42); \
+})
#else
-__ai int16x4_t vtrn2_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst1q_f64_x2(__p0, __p1) __extension__ ({ \
+ float64x2x2_t __s1 = __p1; \
+ float64x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 42); \
+})
+#endif
+
+#define vst1_f64_x2(__p0, __p1) __extension__ ({ \
+ float64x1x2_t __s1 = __p1; \
+ __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 10); \
+})
+#define vst1_p64_x3(__p0, __p1) __extension__ ({ \
+ poly64x1x3_t __s1 = __p1; \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 6); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_p64_x3(__p0, __p1) __extension__ ({ \
+ poly64x2x3_t __s1 = __p1; \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 38); \
+})
+#else
+#define vst1q_p64_x3(__p0, __p1) __extension__ ({ \
+ poly64x2x3_t __s1 = __p1; \
+ poly64x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 38); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_f64_x3(__p0, __p1) __extension__ ({ \
+ float64x2x3_t __s1 = __p1; \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 42); \
+})
+#else
+#define vst1q_f64_x3(__p0, __p1) __extension__ ({ \
+ float64x2x3_t __s1 = __p1; \
+ float64x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 42); \
+})
+#endif
+
+#define vst1_f64_x3(__p0, __p1) __extension__ ({ \
+ float64x1x3_t __s1 = __p1; \
+ __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 10); \
+})
+#define vst1_p64_x4(__p0, __p1) __extension__ ({ \
+ poly64x1x4_t __s1 = __p1; \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 6); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_p64_x4(__p0, __p1) __extension__ ({ \
+ poly64x2x4_t __s1 = __p1; \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 38); \
+})
+#else
+#define vst1q_p64_x4(__p0, __p1) __extension__ ({ \
+ poly64x2x4_t __s1 = __p1; \
+ poly64x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 38); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_f64_x4(__p0, __p1) __extension__ ({ \
+ float64x2x4_t __s1 = __p1; \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 42); \
+})
+#else
+#define vst1q_f64_x4(__p0, __p1) __extension__ ({ \
+ float64x2x4_t __s1 = __p1; \
+ float64x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 42); \
+})
+#endif
+
+#define vst1_f64_x4(__p0, __p1) __extension__ ({ \
+ float64x1x4_t __s1 = __p1; \
+ __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 10); \
+})
+#define vst2_p64(__p0, __p1) __extension__ ({ \
+ poly64x1x2_t __s1 = __p1; \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 6); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_p64(__p0, __p1) __extension__ ({ \
+ poly64x2x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 38); \
+})
+#else
+#define vst2q_p64(__p0, __p1) __extension__ ({ \
+ poly64x2x2_t __s1 = __p1; \
+ poly64x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 38); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_u64(__p0, __p1) __extension__ ({ \
+ uint64x2x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 51); \
+})
+#else
+#define vst2q_u64(__p0, __p1) __extension__ ({ \
+ uint64x2x2_t __s1 = __p1; \
+ uint64x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 51); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_f64(__p0, __p1) __extension__ ({ \
+ float64x2x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 42); \
+})
+#else
+#define vst2q_f64(__p0, __p1) __extension__ ({ \
+ float64x2x2_t __s1 = __p1; \
+ float64x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 42); \
+})
#endif
-__ai uint64x1_t vtst_p64(poly64x1_t __p0, poly64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vtstq_p64(poly64x2_t __p0, poly64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
- return __ret;
-}
+#define vst2q_s64(__p0, __p1) __extension__ ({ \
+ int64x2x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 35); \
+})
#else
-__ai uint64x2_t vtstq_p64(poly64x2_t __p0, poly64x2_t __p1) {
- uint64x2_t __ret;
- poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst2q_s64(__p0, __p1) __extension__ ({ \
+ int64x2x2_t __s1 = __p1; \
+ int64x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 35); \
+})
#endif
+#define vst2_f64(__p0, __p1) __extension__ ({ \
+ float64x1x2_t __s1 = __p1; \
+ __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 10); \
+})
+#define vst2_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x1x2_t __s1 = __p1; \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 6); \
+})
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vtstq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
- return __ret;
-}
+#define vst2q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 36); \
+})
#else
-__ai uint64x2_t vtstq_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst2q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16x2_t __s1 = __p1; \
+ poly8x16x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 36); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vtstq_s64(int64x2_t __p0, int64x2_t __p1) {
- uint64x2_t __ret;
- __ret = (uint64x2_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
- return __ret;
-}
+#define vst2q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 38); \
+})
#else
-__ai uint64x2_t vtstq_s64(int64x2_t __p0, int64x2_t __p1) {
- uint64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (uint64x2_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst2q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2x2_t __s1 = __p1; \
+ poly64x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 38); \
+})
#endif
-__ai uint64x1_t vtst_u64(uint64x1_t __p0, uint64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
- return __ret;
-}
-__ai uint64x1_t vtst_s64(int64x1_t __p0, int64x1_t __p1) {
- uint64x1_t __ret;
- __ret = (uint64x1_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
- return __ret;
-}
-__ai uint64_t vtstd_u64(uint64_t __p0, uint64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vtstd_u64(__p0, __p1);
- return __ret;
-}
-__ai uint64_t vtstd_s64(int64_t __p0, int64_t __p1) {
- uint64_t __ret;
- __ret = (uint64_t) __builtin_neon_vtstd_s64(__p0, __p1);
- return __ret;
-}
-__ai int8_t vuqaddb_s8(int8_t __p0, uint8_t __p1) {
- int8_t __ret;
- __ret = (int8_t) __builtin_neon_vuqaddb_s8(__p0, __p1);
- return __ret;
-}
-__ai int32_t vuqadds_s32(int32_t __p0, uint32_t __p1) {
- int32_t __ret;
- __ret = (int32_t) __builtin_neon_vuqadds_s32(__p0, __p1);
- return __ret;
-}
-__ai int64_t vuqaddd_s64(int64_t __p0, uint64_t __p1) {
- int64_t __ret;
- __ret = (int64_t) __builtin_neon_vuqaddd_s64(__p0, __p1);
- return __ret;
-}
-__ai int16_t vuqaddh_s16(int16_t __p0, uint16_t __p1) {
- int16_t __ret;
- __ret = (int16_t) __builtin_neon_vuqaddh_s16(__p0, __p1);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vuqaddq_s8(int8x16_t __p0, uint8x16_t __p1) {
- int8x16_t __ret;
- __ret = (int8x16_t) __builtin_neon_vuqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
- return __ret;
-}
+#define vst2q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 48); \
+})
#else
-__ai int8x16_t vuqaddq_s8(int8x16_t __p0, uint8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x16_t) __builtin_neon_vuqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16x2_t __s1 = __p1; \
+ uint8x16x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 48); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vuqaddq_s32(int32x4_t __p0, uint32x4_t __p1) {
- int32x4_t __ret;
- __ret = (int32x4_t) __builtin_neon_vuqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
- return __ret;
-}
+#define vst2q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 51); \
+})
#else
-__ai int32x4_t vuqaddq_s32(int32x4_t __p0, uint32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int32x4_t) __builtin_neon_vuqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2x2_t __s1 = __p1; \
+ uint64x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 51); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vuqaddq_s64(int64x2_t __p0, uint64x2_t __p1) {
- int64x2_t __ret;
- __ret = (int64x2_t) __builtin_neon_vuqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
- return __ret;
-}
+#define vst2q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 32); \
+})
#else
-__ai int64x2_t vuqaddq_s64(int64x2_t __p0, uint64x2_t __p1) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int64x2_t) __builtin_neon_vuqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst2q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16x2_t __s1 = __p1; \
+ int8x16x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 32); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vuqaddq_s16(int16x8_t __p0, uint16x8_t __p1) {
- int16x8_t __ret;
- __ret = (int16x8_t) __builtin_neon_vuqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
- return __ret;
-}
+#define vst2q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 42); \
+})
#else
-__ai int16x8_t vuqaddq_s16(int16x8_t __p0, uint16x8_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int16x8_t) __builtin_neon_vuqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2x2_t __s1 = __p1; \
+ float64x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 42); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vuqadd_s8(int8x8_t __p0, uint8x8_t __p1) {
- int8x8_t __ret;
- __ret = (int8x8_t) __builtin_neon_vuqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
- return __ret;
-}
+#define vst2q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2x2_t __s1 = __p1; \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 35); \
+})
#else
-__ai int8x8_t vuqadd_s8(int8x8_t __p0, uint8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (int8x8_t) __builtin_neon_vuqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst2q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2x2_t __s1 = __p1; \
+ int64x2x2_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 35); \
+})
#endif
+#define vst2_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x1x2_t __s1 = __p1; \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 19); \
+})
+#define vst2_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x1x2_t __s1 = __p1; \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 10); \
+})
+#define vst2_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x1x2_t __s1 = __p1; \
+ __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 3); \
+})
+#define vst3_p64(__p0, __p1) __extension__ ({ \
+ poly64x1x3_t __s1 = __p1; \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 6); \
+})
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vuqadd_s32(int32x2_t __p0, uint32x2_t __p1) {
- int32x2_t __ret;
- __ret = (int32x2_t) __builtin_neon_vuqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
- return __ret;
-}
+#define vst3q_p64(__p0, __p1) __extension__ ({ \
+ poly64x2x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 38); \
+})
#else
-__ai int32x2_t vuqadd_s32(int32x2_t __p0, uint32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (int32x2_t) __builtin_neon_vuqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst3q_p64(__p0, __p1) __extension__ ({ \
+ poly64x2x3_t __s1 = __p1; \
+ poly64x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 38); \
+})
#endif
-__ai int64x1_t vuqadd_s64(int64x1_t __p0, uint64x1_t __p1) {
- int64x1_t __ret;
- __ret = (int64x1_t) __builtin_neon_vuqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vuqadd_s16(int16x4_t __p0, uint16x4_t __p1) {
- int16x4_t __ret;
- __ret = (int16x4_t) __builtin_neon_vuqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
- return __ret;
-}
+#define vst3q_u64(__p0, __p1) __extension__ ({ \
+ uint64x2x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 51); \
+})
#else
-__ai int16x4_t vuqadd_s16(int16x4_t __p0, uint16x4_t __p1) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (int16x4_t) __builtin_neon_vuqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_u64(__p0, __p1) __extension__ ({ \
+ uint64x2x3_t __s1 = __p1; \
+ uint64x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 51); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vuzp1_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
- return __ret;
-}
+#define vst3q_f64(__p0, __p1) __extension__ ({ \
+ float64x2x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 42); \
+})
#else
-__ai poly8x8_t vuzp1_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_f64(__p0, __p1) __extension__ ({ \
+ float64x2x3_t __s1 = __p1; \
+ float64x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 42); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x4_t vuzp1_p16(poly16x4_t __p0, poly16x4_t __p1) {
- poly16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
- return __ret;
-}
+#define vst3q_s64(__p0, __p1) __extension__ ({ \
+ int64x2x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 35); \
+})
#else
-__ai poly16x4_t vuzp1_p16(poly16x4_t __p0, poly16x4_t __p1) {
- poly16x4_t __ret;
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_s64(__p0, __p1) __extension__ ({ \
+ int64x2x3_t __s1 = __p1; \
+ int64x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 35); \
+})
#endif
+#define vst3_f64(__p0, __p1) __extension__ ({ \
+ float64x1x3_t __s1 = __p1; \
+ __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 10); \
+})
+#define vst3_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x1x3_t __s1 = __p1; \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 6); \
+})
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vuzp1q_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
- return __ret;
-}
+#define vst3q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 36); \
+})
#else
-__ai poly8x16_t vuzp1q_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16x3_t __s1 = __p1; \
+ poly8x16x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 36); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly64x2_t vuzp1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
- poly64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
- return __ret;
-}
+#define vst3q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 38); \
+})
#else
-__ai poly64x2_t vuzp1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
- poly64x2_t __ret;
- poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst3q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2x3_t __s1 = __p1; \
+ poly64x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 38); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x8_t vuzp1q_p16(poly16x8_t __p0, poly16x8_t __p1) {
- poly16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
- return __ret;
-}
+#define vst3q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 48); \
+})
#else
-__ai poly16x8_t vuzp1q_p16(poly16x8_t __p0, poly16x8_t __p1) {
- poly16x8_t __ret;
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16x3_t __s1 = __p1; \
+ uint8x16x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 48); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vuzp1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
- return __ret;
-}
+#define vst3q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 51); \
+})
#else
-__ai uint8x16_t vuzp1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2x3_t __s1 = __p1; \
+ uint64x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 51); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vuzp1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
- return __ret;
-}
+#define vst3q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 32); \
+})
#else
-__ai uint32x4_t vuzp1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst3q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16x3_t __s1 = __p1; \
+ int8x16x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 32); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vuzp1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
- return __ret;
-}
+#define vst3q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 42); \
+})
#else
-__ai uint64x2_t vuzp1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
- uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst3q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2x3_t __s1 = __p1; \
+ float64x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 42); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vuzp1q_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
- return __ret;
-}
+#define vst3q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2x3_t __s1 = __p1; \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 35); \
+})
+#else
+#define vst3q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2x3_t __s1 = __p1; \
+ int64x2x3_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 35); \
+})
+#endif
+
+#define vst3_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x1x3_t __s1 = __p1; \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 19); \
+})
+#define vst3_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x1x3_t __s1 = __p1; \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 10); \
+})
+#define vst3_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x1x3_t __s1 = __p1; \
+ __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 3); \
+})
+#define vst4_p64(__p0, __p1) __extension__ ({ \
+ poly64x1x4_t __s1 = __p1; \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 6); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_p64(__p0, __p1) __extension__ ({ \
+ poly64x2x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 38); \
+})
#else
-__ai uint16x8_t vuzp1q_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst4q_p64(__p0, __p1) __extension__ ({ \
+ poly64x2x4_t __s1 = __p1; \
+ poly64x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 38); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vuzp1q_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
- return __ret;
-}
+#define vst4q_u64(__p0, __p1) __extension__ ({ \
+ uint64x2x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 51); \
+})
#else
-__ai int8x16_t vuzp1q_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst4q_u64(__p0, __p1) __extension__ ({ \
+ uint64x2x4_t __s1 = __p1; \
+ uint64x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 51); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vuzp1q_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
- return __ret;
-}
+#define vst4q_f64(__p0, __p1) __extension__ ({ \
+ float64x2x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 42); \
+})
#else
-__ai float64x2_t vuzp1q_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst4q_f64(__p0, __p1) __extension__ ({ \
+ float64x2x4_t __s1 = __p1; \
+ float64x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 42); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vuzp1q_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
- return __ret;
-}
+#define vst4q_s64(__p0, __p1) __extension__ ({ \
+ int64x2x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 35); \
+})
#else
-__ai float32x4_t vuzp1q_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst4q_s64(__p0, __p1) __extension__ ({ \
+ int64x2x4_t __s1 = __p1; \
+ int64x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 35); \
+})
#endif
+#define vst4_f64(__p0, __p1) __extension__ ({ \
+ float64x1x4_t __s1 = __p1; \
+ __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 10); \
+})
+#define vst4_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x1x4_t __s1 = __p1; \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 6); \
+})
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vuzp1q_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
- return __ret;
-}
+#define vst4q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 36); \
+})
#else
-__ai int32x4_t vuzp1q_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst4q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+ poly8x16x4_t __s1 = __p1; \
+ poly8x16x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 36); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vuzp1q_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
- return __ret;
-}
+#define vst4q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 38); \
+})
#else
-__ai int64x2_t vuzp1q_s64(int64x2_t __p0, int64x2_t __p1) {
- int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst4q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+ poly64x2x4_t __s1 = __p1; \
+ poly64x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 38); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vuzp1q_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
- return __ret;
-}
+#define vst4q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 48); \
+})
#else
-__ai int16x8_t vuzp1q_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst4q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+ uint8x16x4_t __s1 = __p1; \
+ uint8x16x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 48); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vuzp1_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
- return __ret;
-}
+#define vst4q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 51); \
+})
#else
-__ai uint8x8_t vuzp1_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst4q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x2x4_t __s1 = __p1; \
+ uint64x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 51); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vuzp1_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
- return __ret;
-}
+#define vst4q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 32); \
+})
#else
-__ai uint32x2_t vuzp1_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vst4q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+ int8x16x4_t __s1 = __p1; \
+ int8x16x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 32); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vuzp1_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
- return __ret;
-}
+#define vst4q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 42); \
+})
#else
-__ai uint16x4_t vuzp1_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vst4q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x2x4_t __s1 = __p1; \
+ float64x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 42); \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vuzp1_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
- return __ret;
-}
+#define vst4q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2x4_t __s1 = __p1; \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 35); \
+})
#else
-__ai int8x8_t vuzp1_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
+#define vst4q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x2x4_t __s1 = __p1; \
+ int64x2x4_t __rev1; \
+ __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+ __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+ __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+ __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+ __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 35); \
+})
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vuzp1_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+#define vst4_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+ uint64x1x4_t __s1 = __p1; \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 19); \
+})
+#define vst4_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+ float64x1x4_t __s1 = __p1; \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 10); \
+})
+#define vst4_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+ int64x1x4_t __s1 = __p1; \
+ __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 3); \
+})
+#define vstrq_p128(__p0, __p1) __extension__ ({ \
+ poly128_t __s1 = __p1; \
+ __builtin_neon_vstrq_p128(__p0, __s1); \
+})
+__ai __attribute__((target("neon"))) uint64_t vsubd_u64(uint64_t __p0, uint64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vsubd_u64(__p0, __p1);
return __ret;
}
-#else
-__ai float32x2_t vuzp1_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int64_t vsubd_s64(int64_t __p0, int64_t __p1) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vsubd_s64(__p0, __p1);
return __ret;
}
-#endif
-
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vuzp1_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+__ai __attribute__((target("neon"))) float64x2_t vsubq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = __p0 - __p1;
return __ret;
}
#else
-__ai int32x2_t vuzp1_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+__ai __attribute__((target("neon"))) float64x2_t vsubq_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __rev0 - __rev1;
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vuzp1_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
- return __ret;
-}
-#else
-__ai int16x4_t vuzp1_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float64x1_t vsub_f64(float64x1_t __p0, float64x1_t __p1) {
+ float64x1_t __ret;
+ __ret = __p0 - __p1;
return __ret;
}
-#endif
-
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vuzp2_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+__ai __attribute__((target("neon"))) uint16x8_t vsubhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+ uint16x8_t __ret;
+ __ret = vcombine_u16(__p0, vsubhn_u32(__p1, __p2));
return __ret;
}
#else
-__ai poly8x8_t vuzp2_p8(poly8x8_t __p0, poly8x8_t __p1) {
- poly8x8_t __ret;
- poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
+__ai __attribute__((target("neon"))) uint16x8_t vsubhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+ uint16x8_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ uint32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_u16(__rev0, __noswap_vsubhn_u32(__rev1, __rev2));
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x4_t vuzp2_p16(poly16x4_t __p0, poly16x4_t __p1) {
- poly16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
+__ai __attribute__((target("neon"))) uint32x4_t vsubhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+ uint32x4_t __ret;
+ __ret = vcombine_u32(__p0, vsubhn_u64(__p1, __p2));
return __ret;
}
#else
-__ai poly16x4_t vuzp2_p16(poly16x4_t __p0, poly16x4_t __p1) {
- poly16x4_t __ret;
- poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
+__ai __attribute__((target("neon"))) uint32x4_t vsubhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+ uint32x4_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ uint64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = __noswap_vcombine_u32(__rev0, __noswap_vsubhn_u64(__rev1, __rev2));
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vuzp2q_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
+__ai __attribute__((target("neon"))) uint8x16_t vsubhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+ uint8x16_t __ret;
+ __ret = vcombine_u8(__p0, vsubhn_u16(__p1, __p2));
return __ret;
}
#else
-__ai poly8x16_t vuzp2q_p8(poly8x16_t __p0, poly8x16_t __p1) {
- poly8x16_t __ret;
- poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
+__ai __attribute__((target("neon"))) uint8x16_t vsubhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+ uint8x16_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_u8(__rev0, __noswap_vsubhn_u16(__rev1, __rev2));
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly64x2_t vuzp2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
- poly64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+__ai __attribute__((target("neon"))) int16x8_t vsubhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+ int16x8_t __ret;
+ __ret = vcombine_s16(__p0, vsubhn_s32(__p1, __p2));
return __ret;
}
#else
-__ai poly64x2_t vuzp2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
- poly64x2_t __ret;
- poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("neon"))) int16x8_t vsubhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+ int16x8_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ int32x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_s16(__rev0, __noswap_vsubhn_s32(__rev1, __rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x8_t vuzp2q_p16(poly16x8_t __p0, poly16x8_t __p1) {
- poly16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+__ai __attribute__((target("neon"))) int32x4_t vsubhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+ int32x4_t __ret;
+ __ret = vcombine_s32(__p0, vsubhn_s64(__p1, __p2));
return __ret;
}
#else
-__ai poly16x8_t vuzp2q_p16(poly16x8_t __p0, poly16x8_t __p1) {
- poly16x8_t __ret;
- poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x4_t vsubhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+ int32x4_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ int64x2_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+ __ret = __noswap_vcombine_s32(__rev0, __noswap_vsubhn_s64(__rev1, __rev2));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vuzp2q_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
+__ai __attribute__((target("neon"))) int8x16_t vsubhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+ int8x16_t __ret;
+ __ret = vcombine_s8(__p0, vsubhn_s16(__p1, __p2));
return __ret;
}
#else
-__ai uint8x16_t vuzp2q_u8(uint8x16_t __p0, uint8x16_t __p1) {
- uint8x16_t __ret;
- uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
+__ai __attribute__((target("neon"))) int8x16_t vsubhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+ int8x16_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vcombine_s8(__rev0, __noswap_vsubhn_s16(__rev1, __rev2));
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vuzp2q_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
+__ai __attribute__((target("neon"))) uint16x8_t vsubl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint16x8_t __ret;
+ __ret = vmovl_high_u8(__p0) - vmovl_high_u8(__p1);
return __ret;
}
#else
-__ai uint32x4_t vuzp2q_u32(uint32x4_t __p0, uint32x4_t __p1) {
- uint32x4_t __ret;
- uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint16x8_t vsubl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint16x8_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vmovl_high_u8(__rev0) - __noswap_vmovl_high_u8(__rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vuzp2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vsubl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+ __ret = vmovl_high_u32(__p0) - vmovl_high_u32(__p1);
return __ret;
}
#else
-__ai uint64x2_t vuzp2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vsubl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint64x2_t __ret;
- uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __noswap_vmovl_high_u32(__rev0) - __noswap_vmovl_high_u32(__rev1);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vuzp2q_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+__ai __attribute__((target("neon"))) uint32x4_t vsubl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint32x4_t __ret;
+ __ret = vmovl_high_u16(__p0) - vmovl_high_u16(__p1);
return __ret;
}
#else
-__ai uint16x8_t vuzp2q_u16(uint16x8_t __p0, uint16x8_t __p1) {
- uint16x8_t __ret;
+__ai __attribute__((target("neon"))) uint32x4_t vsubl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint32x4_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vmovl_high_u16(__rev0) - __noswap_vmovl_high_u16(__rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vuzp2q_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
+__ai __attribute__((target("neon"))) int16x8_t vsubl_high_s8(int8x16_t __p0, int8x16_t __p1) {
+ int16x8_t __ret;
+ __ret = vmovl_high_s8(__p0) - vmovl_high_s8(__p1);
return __ret;
}
#else
-__ai int8x16_t vuzp2q_s8(int8x16_t __p0, int8x16_t __p1) {
- int8x16_t __ret;
+__ai __attribute__((target("neon"))) int16x8_t vsubl_high_s8(int8x16_t __p0, int8x16_t __p1) {
+ int16x8_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
- __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vuzp2q_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
- return __ret;
-}
-#else
-__ai float64x2_t vuzp2q_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vuzp2q_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
- return __ret;
-}
-#else
-__ai float32x4_t vuzp2q_f32(float32x4_t __p0, float32x4_t __p1) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vuzp2q_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
- return __ret;
-}
-#else
-__ai int32x4_t vuzp2q_s32(int32x4_t __p0, int32x4_t __p1) {
- int32x4_t __ret;
- int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ __ret = __noswap_vmovl_high_s8(__rev0) - __noswap_vmovl_high_s8(__rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vuzp2q_s64(int64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vsubl_high_s32(int32x4_t __p0, int32x4_t __p1) {
int64x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+ __ret = vmovl_high_s32(__p0) - vmovl_high_s32(__p1);
return __ret;
}
#else
-__ai int64x2_t vuzp2q_s64(int64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vsubl_high_s32(int32x4_t __p0, int32x4_t __p1) {
int64x2_t __ret;
- int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __noswap_vmovl_high_s32(__rev0) - __noswap_vmovl_high_s32(__rev1);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vuzp2q_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+__ai __attribute__((target("neon"))) int32x4_t vsubl_high_s16(int16x8_t __p0, int16x8_t __p1) {
+ int32x4_t __ret;
+ __ret = vmovl_high_s16(__p0) - vmovl_high_s16(__p1);
return __ret;
}
#else
-__ai int16x8_t vuzp2q_s16(int16x8_t __p0, int16x8_t __p1) {
- int16x8_t __ret;
+__ai __attribute__((target("neon"))) int32x4_t vsubl_high_s16(int16x8_t __p0, int16x8_t __p1) {
+ int32x4_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vmovl_high_s16(__rev0) - __noswap_vmovl_high_s16(__rev1);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vuzp2_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+__ai __attribute__((target("neon"))) uint16x8_t vsubw_high_u8(uint16x8_t __p0, uint8x16_t __p1) {
+ uint16x8_t __ret;
+ __ret = __p0 - vmovl_high_u8(__p1);
return __ret;
}
#else
-__ai uint8x8_t vuzp2_u8(uint8x8_t __p0, uint8x8_t __p1) {
- uint8x8_t __ret;
- uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
+__ai __attribute__((target("neon"))) uint16x8_t vsubw_high_u8(uint16x8_t __p0, uint8x16_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 - __noswap_vmovl_high_u8(__rev1);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vuzp2_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+__ai __attribute__((target("neon"))) uint64x2_t vsubw_high_u32(uint64x2_t __p0, uint32x4_t __p1) {
+ uint64x2_t __ret;
+ __ret = __p0 - vmovl_high_u32(__p1);
return __ret;
}
#else
-__ai uint32x2_t vuzp2_u32(uint32x2_t __p0, uint32x2_t __p1) {
- uint32x2_t __ret;
- uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+__ai __attribute__((target("neon"))) uint64x2_t vsubw_high_u32(uint64x2_t __p0, uint32x4_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 - __noswap_vmovl_high_u32(__rev1);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vuzp2_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
+__ai __attribute__((target("neon"))) uint32x4_t vsubw_high_u16(uint32x4_t __p0, uint16x8_t __p1) {
+ uint32x4_t __ret;
+ __ret = __p0 - vmovl_high_u16(__p1);
return __ret;
}
#else
-__ai uint16x4_t vuzp2_u16(uint16x4_t __p0, uint16x4_t __p1) {
- uint16x4_t __ret;
- uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
+__ai __attribute__((target("neon"))) uint32x4_t vsubw_high_u16(uint32x4_t __p0, uint16x8_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 - __noswap_vmovl_high_u16(__rev1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vuzp2_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+__ai __attribute__((target("neon"))) int16x8_t vsubw_high_s8(int16x8_t __p0, int8x16_t __p1) {
+ int16x8_t __ret;
+ __ret = __p0 - vmovl_high_s8(__p1);
return __ret;
}
#else
-__ai int8x8_t vuzp2_s8(int8x8_t __p0, int8x8_t __p1) {
- int8x8_t __ret;
- int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
+__ai __attribute__((target("neon"))) int16x8_t vsubw_high_s8(int16x8_t __p0, int8x16_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 - __noswap_vmovl_high_s8(__rev1);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vuzp2_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
- return __ret;
-}
-#else
-__ai float32x2_t vuzp2_f32(float32x2_t __p0, float32x2_t __p1) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vuzp2_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+__ai __attribute__((target("neon"))) int64x2_t vsubw_high_s32(int64x2_t __p0, int32x4_t __p1) {
+ int64x2_t __ret;
+ __ret = __p0 - vmovl_high_s32(__p1);
return __ret;
}
#else
-__ai int32x2_t vuzp2_s32(int32x2_t __p0, int32x2_t __p1) {
- int32x2_t __ret;
- int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+__ai __attribute__((target("neon"))) int64x2_t vsubw_high_s32(int64x2_t __p0, int32x4_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __rev0 - __noswap_vmovl_high_s32(__rev1);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vuzp2_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
+__ai __attribute__((target("neon"))) int32x4_t vsubw_high_s16(int32x4_t __p0, int16x8_t __p1) {
+ int32x4_t __ret;
+ __ret = __p0 - vmovl_high_s16(__p1);
return __ret;
}
#else
-__ai int16x4_t vuzp2_s16(int16x4_t __p0, int16x4_t __p1) {
- int16x4_t __ret;
- int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
+__ai __attribute__((target("neon"))) int32x4_t vsubw_high_s16(int32x4_t __p0, int16x8_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __rev0 - __noswap_vmovl_high_s16(__rev1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vzip1_p8(poly8x8_t __p0, poly8x8_t __p1) {
+__ai __attribute__((target("neon"))) poly8x8_t vtrn1_p8(poly8x8_t __p0, poly8x8_t __p1) {
poly8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
return __ret;
}
#else
-__ai poly8x8_t vzip1_p8(poly8x8_t __p0, poly8x8_t __p1) {
+__ai __attribute__((target("neon"))) poly8x8_t vtrn1_p8(poly8x8_t __p0, poly8x8_t __p1) {
poly8x8_t __ret;
poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x4_t vzip1_p16(poly16x4_t __p0, poly16x4_t __p1) {
+__ai __attribute__((target("neon"))) poly16x4_t vtrn1_p16(poly16x4_t __p0, poly16x4_t __p1) {
poly16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
return __ret;
}
#else
-__ai poly16x4_t vzip1_p16(poly16x4_t __p0, poly16x4_t __p1) {
+__ai __attribute__((target("neon"))) poly16x4_t vtrn1_p16(poly16x4_t __p0, poly16x4_t __p1) {
poly16x4_t __ret;
poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vzip1q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+__ai __attribute__((target("neon"))) poly8x16_t vtrn1q_p8(poly8x16_t __p0, poly8x16_t __p1) {
poly8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30);
return __ret;
}
#else
-__ai poly8x16_t vzip1q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+__ai __attribute__((target("neon"))) poly8x16_t vtrn1q_p8(poly8x16_t __p0, poly8x16_t __p1) {
poly8x16_t __ret;
poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly64x2_t vzip1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+__ai __attribute__((target("neon"))) poly64x2_t vtrn1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
poly64x2_t __ret;
__ret = __builtin_shufflevector(__p0, __p1, 0, 2);
return __ret;
}
#else
-__ai poly64x2_t vzip1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+__ai __attribute__((target("neon"))) poly64x2_t vtrn1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
poly64x2_t __ret;
poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -61812,64 +61842,64 @@ __ai poly64x2_t vzip1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x8_t vzip1q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+__ai __attribute__((target("neon"))) poly16x8_t vtrn1q_p16(poly16x8_t __p0, poly16x8_t __p1) {
poly16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
return __ret;
}
#else
-__ai poly16x8_t vzip1q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+__ai __attribute__((target("neon"))) poly16x8_t vtrn1q_p16(poly16x8_t __p0, poly16x8_t __p1) {
poly16x8_t __ret;
poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vzip1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint8x16_t vtrn1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
uint8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30);
return __ret;
}
#else
-__ai uint8x16_t vzip1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint8x16_t vtrn1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
uint8x16_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vzip1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vtrn1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
return __ret;
}
#else
-__ai uint32x4_t vzip1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vtrn1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vzip1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vtrn1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
uint64x2_t __ret;
__ret = __builtin_shufflevector(__p0, __p1, 0, 2);
return __ret;
}
#else
-__ai uint64x2_t vzip1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vtrn1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -61880,47 +61910,47 @@ __ai uint64x2_t vzip1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vzip1q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vtrn1q_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
return __ret;
}
#else
-__ai uint16x8_t vzip1q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vtrn1q_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vzip1q_s8(int8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) int8x16_t vtrn1q_s8(int8x16_t __p0, int8x16_t __p1) {
int8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30);
return __ret;
}
#else
-__ai int8x16_t vzip1q_s8(int8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) int8x16_t vtrn1q_s8(int8x16_t __p0, int8x16_t __p1) {
int8x16_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vzip1q_f64(float64x2_t __p0, float64x2_t __p1) {
+__ai __attribute__((target("neon"))) float64x2_t vtrn1q_f64(float64x2_t __p0, float64x2_t __p1) {
float64x2_t __ret;
__ret = __builtin_shufflevector(__p0, __p1, 0, 2);
return __ret;
}
#else
-__ai float64x2_t vzip1q_f64(float64x2_t __p0, float64x2_t __p1) {
+__ai __attribute__((target("neon"))) float64x2_t vtrn1q_f64(float64x2_t __p0, float64x2_t __p1) {
float64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -61931,47 +61961,47 @@ __ai float64x2_t vzip1q_f64(float64x2_t __p0, float64x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vzip1q_f32(float32x4_t __p0, float32x4_t __p1) {
+__ai __attribute__((target("neon"))) float32x4_t vtrn1q_f32(float32x4_t __p0, float32x4_t __p1) {
float32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
return __ret;
}
#else
-__ai float32x4_t vzip1q_f32(float32x4_t __p0, float32x4_t __p1) {
+__ai __attribute__((target("neon"))) float32x4_t vtrn1q_f32(float32x4_t __p0, float32x4_t __p1) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vzip1q_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vtrn1q_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
return __ret;
}
#else
-__ai int32x4_t vzip1q_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vtrn1q_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vzip1q_s64(int64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vtrn1q_s64(int64x2_t __p0, int64x2_t __p1) {
int64x2_t __ret;
__ret = __builtin_shufflevector(__p0, __p1, 0, 2);
return __ret;
}
#else
-__ai int64x2_t vzip1q_s64(int64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vtrn1q_s64(int64x2_t __p0, int64x2_t __p1) {
int64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -61982,47 +62012,47 @@ __ai int64x2_t vzip1q_s64(int64x2_t __p0, int64x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vzip1q_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vtrn1q_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
return __ret;
}
#else
-__ai int16x8_t vzip1q_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vtrn1q_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vzip1_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vtrn1_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
return __ret;
}
#else
-__ai uint8x8_t vzip1_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vtrn1_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint8x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vzip1_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vtrn1_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint32x2_t __ret;
__ret = __builtin_shufflevector(__p0, __p1, 0, 2);
return __ret;
}
#else
-__ai uint32x2_t vzip1_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vtrn1_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -62033,47 +62063,47 @@ __ai uint32x2_t vzip1_u32(uint32x2_t __p0, uint32x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vzip1_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vtrn1_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
return __ret;
}
#else
-__ai uint16x4_t vzip1_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vtrn1_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vzip1_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vtrn1_s8(int8x8_t __p0, int8x8_t __p1) {
int8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
return __ret;
}
#else
-__ai int8x8_t vzip1_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vtrn1_s8(int8x8_t __p0, int8x8_t __p1) {
int8x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vzip1_f32(float32x2_t __p0, float32x2_t __p1) {
+__ai __attribute__((target("neon"))) float32x2_t vtrn1_f32(float32x2_t __p0, float32x2_t __p1) {
float32x2_t __ret;
__ret = __builtin_shufflevector(__p0, __p1, 0, 2);
return __ret;
}
#else
-__ai float32x2_t vzip1_f32(float32x2_t __p0, float32x2_t __p1) {
+__ai __attribute__((target("neon"))) float32x2_t vtrn1_f32(float32x2_t __p0, float32x2_t __p1) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -62084,13 +62114,13 @@ __ai float32x2_t vzip1_f32(float32x2_t __p0, float32x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vzip1_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vtrn1_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
__ret = __builtin_shufflevector(__p0, __p1, 0, 2);
return __ret;
}
#else
-__ai int32x2_t vzip1_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vtrn1_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -62101,81 +62131,115 @@ __ai int32x2_t vzip1_s32(int32x2_t __p0, int32x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vzip1_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vtrn1_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
return __ret;
}
#else
-__ai int16x4_t vzip1_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vtrn1_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x8_t vtrn1q_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x8_t vtrn1q_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x4_t vtrn1_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x4_t vtrn1_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x8_t vzip2_p8(poly8x8_t __p0, poly8x8_t __p1) {
+__ai __attribute__((target("neon"))) poly8x8_t vtrn2_p8(poly8x8_t __p0, poly8x8_t __p1) {
poly8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
return __ret;
}
#else
-__ai poly8x8_t vzip2_p8(poly8x8_t __p0, poly8x8_t __p1) {
+__ai __attribute__((target("neon"))) poly8x8_t vtrn2_p8(poly8x8_t __p0, poly8x8_t __p1) {
poly8x8_t __ret;
poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x4_t vzip2_p16(poly16x4_t __p0, poly16x4_t __p1) {
+__ai __attribute__((target("neon"))) poly16x4_t vtrn2_p16(poly16x4_t __p0, poly16x4_t __p1) {
poly16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
return __ret;
}
#else
-__ai poly16x4_t vzip2_p16(poly16x4_t __p0, poly16x4_t __p1) {
+__ai __attribute__((target("neon"))) poly16x4_t vtrn2_p16(poly16x4_t __p0, poly16x4_t __p1) {
poly16x4_t __ret;
poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly8x16_t vzip2q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+__ai __attribute__((target("neon"))) poly8x16_t vtrn2q_p8(poly8x16_t __p0, poly8x16_t __p1) {
poly8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31);
return __ret;
}
#else
-__ai poly8x16_t vzip2q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+__ai __attribute__((target("neon"))) poly8x16_t vtrn2q_p8(poly8x16_t __p0, poly8x16_t __p1) {
poly8x16_t __ret;
poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly64x2_t vzip2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+__ai __attribute__((target("neon"))) poly64x2_t vtrn2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
poly64x2_t __ret;
__ret = __builtin_shufflevector(__p0, __p1, 1, 3);
return __ret;
}
#else
-__ai poly64x2_t vzip2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+__ai __attribute__((target("neon"))) poly64x2_t vtrn2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
poly64x2_t __ret;
poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -62186,64 +62250,64 @@ __ai poly64x2_t vzip2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai poly16x8_t vzip2q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+__ai __attribute__((target("neon"))) poly16x8_t vtrn2q_p16(poly16x8_t __p0, poly16x8_t __p1) {
poly16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
return __ret;
}
#else
-__ai poly16x8_t vzip2q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+__ai __attribute__((target("neon"))) poly16x8_t vtrn2q_p16(poly16x8_t __p0, poly16x8_t __p1) {
poly16x8_t __ret;
poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vzip2q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint8x16_t vtrn2q_u8(uint8x16_t __p0, uint8x16_t __p1) {
uint8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31);
return __ret;
}
#else
-__ai uint8x16_t vzip2q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint8x16_t vtrn2q_u8(uint8x16_t __p0, uint8x16_t __p1) {
uint8x16_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vzip2q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vtrn2q_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
return __ret;
}
#else
-__ai uint32x4_t vzip2q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vtrn2q_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vzip2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vtrn2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
uint64x2_t __ret;
__ret = __builtin_shufflevector(__p0, __p1, 1, 3);
return __ret;
}
#else
-__ai uint64x2_t vzip2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vtrn2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -62254,47 +62318,47 @@ __ai uint64x2_t vzip2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vzip2q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vtrn2q_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
return __ret;
}
#else
-__ai uint16x8_t vzip2q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vtrn2q_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vzip2q_s8(int8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) int8x16_t vtrn2q_s8(int8x16_t __p0, int8x16_t __p1) {
int8x16_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31);
return __ret;
}
#else
-__ai int8x16_t vzip2q_s8(int8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) int8x16_t vtrn2q_s8(int8x16_t __p0, int8x16_t __p1) {
int8x16_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31);
__ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vzip2q_f64(float64x2_t __p0, float64x2_t __p1) {
+__ai __attribute__((target("neon"))) float64x2_t vtrn2q_f64(float64x2_t __p0, float64x2_t __p1) {
float64x2_t __ret;
__ret = __builtin_shufflevector(__p0, __p1, 1, 3);
return __ret;
}
#else
-__ai float64x2_t vzip2q_f64(float64x2_t __p0, float64x2_t __p1) {
+__ai __attribute__((target("neon"))) float64x2_t vtrn2q_f64(float64x2_t __p0, float64x2_t __p1) {
float64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -62305,47 +62369,47 @@ __ai float64x2_t vzip2q_f64(float64x2_t __p0, float64x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x4_t vzip2q_f32(float32x4_t __p0, float32x4_t __p1) {
+__ai __attribute__((target("neon"))) float32x4_t vtrn2q_f32(float32x4_t __p0, float32x4_t __p1) {
float32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
return __ret;
}
#else
-__ai float32x4_t vzip2q_f32(float32x4_t __p0, float32x4_t __p1) {
+__ai __attribute__((target("neon"))) float32x4_t vtrn2q_f32(float32x4_t __p0, float32x4_t __p1) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vzip2q_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vtrn2q_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
return __ret;
}
#else
-__ai int32x4_t vzip2q_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vtrn2q_s32(int32x4_t __p0, int32x4_t __p1) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vzip2q_s64(int64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vtrn2q_s64(int64x2_t __p0, int64x2_t __p1) {
int64x2_t __ret;
__ret = __builtin_shufflevector(__p0, __p1, 1, 3);
return __ret;
}
#else
-__ai int64x2_t vzip2q_s64(int64x2_t __p0, int64x2_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vtrn2q_s64(int64x2_t __p0, int64x2_t __p1) {
int64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -62356,47 +62420,47 @@ __ai int64x2_t vzip2q_s64(int64x2_t __p0, int64x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vzip2q_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vtrn2q_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
return __ret;
}
#else
-__ai int16x8_t vzip2q_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vtrn2q_s16(int16x8_t __p0, int16x8_t __p1) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vzip2_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vtrn2_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
return __ret;
}
#else
-__ai uint8x8_t vzip2_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint8x8_t vtrn2_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint8x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vzip2_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vtrn2_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint32x2_t __ret;
__ret = __builtin_shufflevector(__p0, __p1, 1, 3);
return __ret;
}
#else
-__ai uint32x2_t vzip2_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint32x2_t vtrn2_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -62407,47 +62471,47 @@ __ai uint32x2_t vzip2_u32(uint32x2_t __p0, uint32x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vzip2_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vtrn2_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
return __ret;
}
#else
-__ai uint16x4_t vzip2_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint16x4_t vtrn2_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vzip2_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vtrn2_s8(int8x8_t __p0, int8x8_t __p1) {
int8x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
return __ret;
}
#else
-__ai int8x8_t vzip2_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int8x8_t vtrn2_s8(int8x8_t __p0, int8x8_t __p1) {
int8x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai float32x2_t vzip2_f32(float32x2_t __p0, float32x2_t __p1) {
+__ai __attribute__((target("neon"))) float32x2_t vtrn2_f32(float32x2_t __p0, float32x2_t __p1) {
float32x2_t __ret;
__ret = __builtin_shufflevector(__p0, __p1, 1, 3);
return __ret;
}
#else
-__ai float32x2_t vzip2_f32(float32x2_t __p0, float32x2_t __p1) {
+__ai __attribute__((target("neon"))) float32x2_t vtrn2_f32(float32x2_t __p0, float32x2_t __p1) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -62458,13 +62522,13 @@ __ai float32x2_t vzip2_f32(float32x2_t __p0, float32x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vzip2_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vtrn2_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
__ret = __builtin_shufflevector(__p0, __p1, 1, 3);
return __ret;
}
#else
-__ai int32x2_t vzip2_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int32x2_t vtrn2_s32(int32x2_t __p0, int32x2_t __p1) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -62475,1978 +62539,1474 @@ __ai int32x2_t vzip2_s32(int32x2_t __p0, int32x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vzip2_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vtrn2_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
return __ret;
}
#else
-__ai int16x4_t vzip2_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int16x4_t vtrn2_s16(int16x4_t __p0, int16x4_t __p1) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai __attribute__((target("aes"))) poly128_t vmull_p64(poly64_t __p0, poly64_t __p1) {
- poly128_t __ret;
- __ret = (poly128_t) __builtin_neon_vmull_p64(__p0, __p1);
- return __ret;
-}
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("aes"))) poly128_t vmull_high_p64(poly64x2_t __p0, poly64x2_t __p1) {
- poly128_t __ret;
- __ret = vmull_p64((poly64_t)(vget_high_p64(__p0)), (poly64_t)(vget_high_p64(__p1)));
- return __ret;
-}
-#else
-__ai __attribute__((target("aes"))) poly128_t vmull_high_p64(poly64x2_t __p0, poly64x2_t __p1) {
- poly128_t __ret;
- poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = vmull_p64((poly64_t)(__noswap_vget_high_p64(__rev0)), (poly64_t)(__noswap_vget_high_p64(__rev1)));
- return __ret;
-}
-#endif
-
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) bfloat16x8_t __a64_vcvtq_low_bf16_f32(float32x4_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t) __builtin_neon___a64_vcvtq_low_bf16_f32((int8x16_t)__p0, 43);
+__ai __attribute__((target("neon"))) float16x8_t vtrn2q_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
return __ret;
}
#else
-__ai __attribute__((target("bf16"))) bfloat16x8_t __a64_vcvtq_low_bf16_f32(float32x4_t __p0) {
- bfloat16x8_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (bfloat16x8_t) __builtin_neon___a64_vcvtq_low_bf16_f32((int8x16_t)__rev0, 43);
+__ai __attribute__((target("neon"))) float16x8_t vtrn2q_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16x8_t __noswap___a64_vcvtq_low_bf16_f32(float32x4_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t) __builtin_neon___a64_vcvtq_low_bf16_f32((int8x16_t)__p0, 43);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcopyq_lane_bf16(__p0_739, __p1_739, __p2_739, __p3_739) __extension__ ({ \
- bfloat16x8_t __ret_739; \
- bfloat16x8_t __s0_739 = __p0_739; \
- bfloat16x4_t __s2_739 = __p2_739; \
- __ret_739 = vsetq_lane_bf16(vget_lane_bf16(__s2_739, __p3_739), __s0_739, __p1_739); \
- __ret_739; \
-})
-#else
-#define vcopyq_lane_bf16(__p0_740, __p1_740, __p2_740, __p3_740) __extension__ ({ \
- bfloat16x8_t __ret_740; \
- bfloat16x8_t __s0_740 = __p0_740; \
- bfloat16x4_t __s2_740 = __p2_740; \
- bfloat16x8_t __rev0_740; __rev0_740 = __builtin_shufflevector(__s0_740, __s0_740, 7, 6, 5, 4, 3, 2, 1, 0); \
- bfloat16x4_t __rev2_740; __rev2_740 = __builtin_shufflevector(__s2_740, __s2_740, 3, 2, 1, 0); \
- __ret_740 = __noswap_vsetq_lane_bf16(__noswap_vget_lane_bf16(__rev2_740, __p3_740), __rev0_740, __p1_740); \
- __ret_740 = __builtin_shufflevector(__ret_740, __ret_740, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_740; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcopy_lane_bf16(__p0_741, __p1_741, __p2_741, __p3_741) __extension__ ({ \
- bfloat16x4_t __ret_741; \
- bfloat16x4_t __s0_741 = __p0_741; \
- bfloat16x4_t __s2_741 = __p2_741; \
- __ret_741 = vset_lane_bf16(vget_lane_bf16(__s2_741, __p3_741), __s0_741, __p1_741); \
- __ret_741; \
-})
-#else
-#define vcopy_lane_bf16(__p0_742, __p1_742, __p2_742, __p3_742) __extension__ ({ \
- bfloat16x4_t __ret_742; \
- bfloat16x4_t __s0_742 = __p0_742; \
- bfloat16x4_t __s2_742 = __p2_742; \
- bfloat16x4_t __rev0_742; __rev0_742 = __builtin_shufflevector(__s0_742, __s0_742, 3, 2, 1, 0); \
- bfloat16x4_t __rev2_742; __rev2_742 = __builtin_shufflevector(__s2_742, __s2_742, 3, 2, 1, 0); \
- __ret_742 = __noswap_vset_lane_bf16(__noswap_vget_lane_bf16(__rev2_742, __p3_742), __rev0_742, __p1_742); \
- __ret_742 = __builtin_shufflevector(__ret_742, __ret_742, 3, 2, 1, 0); \
- __ret_742; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcopyq_laneq_bf16(__p0_743, __p1_743, __p2_743, __p3_743) __extension__ ({ \
- bfloat16x8_t __ret_743; \
- bfloat16x8_t __s0_743 = __p0_743; \
- bfloat16x8_t __s2_743 = __p2_743; \
- __ret_743 = vsetq_lane_bf16(vgetq_lane_bf16(__s2_743, __p3_743), __s0_743, __p1_743); \
- __ret_743; \
-})
-#else
-#define vcopyq_laneq_bf16(__p0_744, __p1_744, __p2_744, __p3_744) __extension__ ({ \
- bfloat16x8_t __ret_744; \
- bfloat16x8_t __s0_744 = __p0_744; \
- bfloat16x8_t __s2_744 = __p2_744; \
- bfloat16x8_t __rev0_744; __rev0_744 = __builtin_shufflevector(__s0_744, __s0_744, 7, 6, 5, 4, 3, 2, 1, 0); \
- bfloat16x8_t __rev2_744; __rev2_744 = __builtin_shufflevector(__s2_744, __s2_744, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_744 = __noswap_vsetq_lane_bf16(__noswap_vgetq_lane_bf16(__rev2_744, __p3_744), __rev0_744, __p1_744); \
- __ret_744 = __builtin_shufflevector(__ret_744, __ret_744, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_744; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcopy_laneq_bf16(__p0_745, __p1_745, __p2_745, __p3_745) __extension__ ({ \
- bfloat16x4_t __ret_745; \
- bfloat16x4_t __s0_745 = __p0_745; \
- bfloat16x8_t __s2_745 = __p2_745; \
- __ret_745 = vset_lane_bf16(vgetq_lane_bf16(__s2_745, __p3_745), __s0_745, __p1_745); \
- __ret_745; \
-})
-#else
-#define vcopy_laneq_bf16(__p0_746, __p1_746, __p2_746, __p3_746) __extension__ ({ \
- bfloat16x4_t __ret_746; \
- bfloat16x4_t __s0_746 = __p0_746; \
- bfloat16x8_t __s2_746 = __p2_746; \
- bfloat16x4_t __rev0_746; __rev0_746 = __builtin_shufflevector(__s0_746, __s0_746, 3, 2, 1, 0); \
- bfloat16x8_t __rev2_746; __rev2_746 = __builtin_shufflevector(__s2_746, __s2_746, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_746 = __noswap_vset_lane_bf16(__noswap_vgetq_lane_bf16(__rev2_746, __p3_746), __rev0_746, __p1_746); \
- __ret_746 = __builtin_shufflevector(__ret_746, __ret_746, 3, 2, 1, 0); \
- __ret_746; \
-})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) bfloat16x4_t vcvt_bf16_f32(float32x4_t __p0) {
- bfloat16x4_t __ret;
- __ret = vget_low_bf16(__a64_vcvtq_low_bf16_f32(__p0));
+__ai __attribute__((target("neon"))) float16x4_t vtrn2_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
return __ret;
}
#else
-__ai __attribute__((target("bf16"))) bfloat16x4_t vcvt_bf16_f32(float32x4_t __p0) {
- bfloat16x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __noswap_vget_low_bf16(__noswap___a64_vcvtq_low_bf16_f32(__rev0));
+__ai __attribute__((target("neon"))) float16x4_t vtrn2_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) bfloat16x8_t vcvtq_high_bf16_f32(bfloat16x8_t __p0, float32x4_t __p1) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t) __builtin_neon_vcvtq_high_bf16_f32((int8x16_t)__p0, (int8x16_t)__p1, 43);
- return __ret;
-}
-#else
-__ai __attribute__((target("bf16"))) bfloat16x8_t vcvtq_high_bf16_f32(bfloat16x8_t __p0, float32x4_t __p1) {
- bfloat16x8_t __ret;
- bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (bfloat16x8_t) __builtin_neon_vcvtq_high_bf16_f32((int8x16_t)__rev0, (int8x16_t)__rev1, 43);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) bfloat16x8_t vcvtq_low_bf16_f32(float32x4_t __p0) {
- bfloat16x8_t __ret;
- __ret = __a64_vcvtq_low_bf16_f32(__p0);
- return __ret;
-}
-#else
-__ai __attribute__((target("bf16"))) bfloat16x8_t vcvtq_low_bf16_f32(float32x4_t __p0) {
- bfloat16x8_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = __noswap___a64_vcvtq_low_bf16_f32(__rev0);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
- return __ret;
-}
-#endif
-
-__ai __attribute__((target("bf16"))) poly8x8_t vreinterpret_p8_bf16(bfloat16x4_t __p0) {
- poly8x8_t __ret;
- __ret = (poly8x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) poly64x1_t vreinterpret_p64_bf16(bfloat16x4_t __p0) {
- poly64x1_t __ret;
- __ret = (poly64x1_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) poly16x4_t vreinterpret_p16_bf16(bfloat16x4_t __p0) {
- poly16x4_t __ret;
- __ret = (poly16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) poly8x16_t vreinterpretq_p8_bf16(bfloat16x8_t __p0) {
- poly8x16_t __ret;
- __ret = (poly8x16_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) poly128_t vreinterpretq_p128_bf16(bfloat16x8_t __p0) {
- poly128_t __ret;
- __ret = (poly128_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) poly64x2_t vreinterpretq_p64_bf16(bfloat16x8_t __p0) {
- poly64x2_t __ret;
- __ret = (poly64x2_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) poly16x8_t vreinterpretq_p16_bf16(bfloat16x8_t __p0) {
- poly16x8_t __ret;
- __ret = (poly16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) uint8x16_t vreinterpretq_u8_bf16(bfloat16x8_t __p0) {
- uint8x16_t __ret;
- __ret = (uint8x16_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) uint32x4_t vreinterpretq_u32_bf16(bfloat16x8_t __p0) {
- uint32x4_t __ret;
- __ret = (uint32x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) uint64x2_t vreinterpretq_u64_bf16(bfloat16x8_t __p0) {
- uint64x2_t __ret;
- __ret = (uint64x2_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) uint16x8_t vreinterpretq_u16_bf16(bfloat16x8_t __p0) {
- uint16x8_t __ret;
- __ret = (uint16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) int8x16_t vreinterpretq_s8_bf16(bfloat16x8_t __p0) {
- int8x16_t __ret;
- __ret = (int8x16_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) float64x2_t vreinterpretq_f64_bf16(bfloat16x8_t __p0) {
- float64x2_t __ret;
- __ret = (float64x2_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) float32x4_t vreinterpretq_f32_bf16(bfloat16x8_t __p0) {
- float32x4_t __ret;
- __ret = (float32x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) float16x8_t vreinterpretq_f16_bf16(bfloat16x8_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) int32x4_t vreinterpretq_s32_bf16(bfloat16x8_t __p0) {
- int32x4_t __ret;
- __ret = (int32x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) int64x2_t vreinterpretq_s64_bf16(bfloat16x8_t __p0) {
- int64x2_t __ret;
- __ret = (int64x2_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) int16x8_t vreinterpretq_s16_bf16(bfloat16x8_t __p0) {
- int16x8_t __ret;
- __ret = (int16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) uint8x8_t vreinterpret_u8_bf16(bfloat16x4_t __p0) {
- uint8x8_t __ret;
- __ret = (uint8x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) uint32x2_t vreinterpret_u32_bf16(bfloat16x4_t __p0) {
- uint32x2_t __ret;
- __ret = (uint32x2_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) uint64x1_t vreinterpret_u64_bf16(bfloat16x4_t __p0) {
+__ai __attribute__((target("neon"))) uint64x1_t vtst_p64(poly64x1_t __p0, poly64x1_t __p1) {
uint64x1_t __ret;
- __ret = (uint64x1_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) uint16x4_t vreinterpret_u16_bf16(bfloat16x4_t __p0) {
- uint16x4_t __ret;
- __ret = (uint16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) int8x8_t vreinterpret_s8_bf16(bfloat16x4_t __p0) {
- int8x8_t __ret;
- __ret = (int8x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) float64x1_t vreinterpret_f64_bf16(bfloat16x4_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) float32x2_t vreinterpret_f32_bf16(bfloat16x4_t __p0) {
- float32x2_t __ret;
- __ret = (float32x2_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) float16x4_t vreinterpret_f16_bf16(bfloat16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) int32x2_t vreinterpret_s32_bf16(bfloat16x4_t __p0) {
- int32x2_t __ret;
- __ret = (int32x2_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) int64x1_t vreinterpret_s64_bf16(bfloat16x4_t __p0) {
- int64x1_t __ret;
- __ret = (int64x1_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) int16x4_t vreinterpret_s16_bf16(bfloat16x4_t __p0) {
- int16x4_t __ret;
- __ret = (int16x4_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_p8(poly8x16_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_p128(poly128_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_p64(poly64x2_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_p16(poly16x8_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_u8(uint8x16_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_u32(uint32x4_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_u64(uint64x2_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_u16(uint16x8_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_s8(int8x16_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_f64(float64x2_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_f32(float32x4_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_f16(float16x8_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
- return __ret;
-}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_s32(int32x4_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
+ __ret = (uint64x1_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_s64(int64x2_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vtstq_p64(poly64x2_t __p0, poly64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16x8_t vreinterpretq_bf16_s16(int16x8_t __p0) {
- bfloat16x8_t __ret;
- __ret = (bfloat16x8_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vtstq_p64(poly64x2_t __p0, poly64x2_t __p1) {
+ uint64x2_t __ret;
+ poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_p8(poly8x8_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vtstq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_p64(poly64x1_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vtstq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_p16(poly16x4_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vtstq_s64(int64x2_t __p0, int64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = (uint64x2_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_u8(uint8x8_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vtstq_s64(int64x2_t __p0, int64x2_t __p1) {
+ uint64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (uint64x2_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_u32(uint32x2_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vtst_u64(uint64x1_t __p0, uint64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_u64(uint64x1_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
+__ai __attribute__((target("neon"))) uint64x1_t vtst_s64(int64x1_t __p0, int64x1_t __p1) {
+ uint64x1_t __ret;
+ __ret = (uint64x1_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_u16(uint16x4_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
+__ai __attribute__((target("neon"))) uint64_t vtstd_u64(uint64_t __p0, uint64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vtstd_u64(__p0, __p1);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_s8(int8x8_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
+__ai __attribute__((target("neon"))) uint64_t vtstd_s64(int64_t __p0, int64_t __p1) {
+ uint64_t __ret;
+ __ret = (uint64_t) __builtin_neon_vtstd_s64(__p0, __p1);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_f64(float64x1_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
+__ai __attribute__((target("neon"))) int8_t vuqaddb_s8(int8_t __p0, uint8_t __p1) {
+ int8_t __ret;
+ __ret = (int8_t) __builtin_neon_vuqaddb_s8(__p0, __p1);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_f32(float32x2_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
+__ai __attribute__((target("neon"))) int32_t vuqadds_s32(int32_t __p0, uint32_t __p1) {
+ int32_t __ret;
+ __ret = (int32_t) __builtin_neon_vuqadds_s32(__p0, __p1);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_f16(float16x4_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
+__ai __attribute__((target("neon"))) int64_t vuqaddd_s64(int64_t __p0, uint64_t __p1) {
+ int64_t __ret;
+ __ret = (int64_t) __builtin_neon_vuqaddd_s64(__p0, __p1);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_s32(int32x2_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
+__ai __attribute__((target("neon"))) int16_t vuqaddh_s16(int16_t __p0, uint16_t __p1) {
+ int16_t __ret;
+ __ret = (int16_t) __builtin_neon_vuqaddh_s16(__p0, __p1);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_s64(int64x1_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vuqaddq_s8(int8x16_t __p0, uint8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = (int8x16_t) __builtin_neon_vuqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
return __ret;
}
-__ai __attribute__((target("bf16"))) bfloat16x4_t vreinterpret_bf16_s16(int16x4_t __p0) {
- bfloat16x4_t __ret;
- __ret = (bfloat16x4_t)(__p0);
+#else
+__ai __attribute__((target("neon"))) int8x16_t vuqaddq_s8(int8x16_t __p0, uint8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x16_t) __builtin_neon_vuqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-#ifdef __LITTLE_ENDIAN__
-#define vdotq_laneq_u32(__p0_747, __p1_747, __p2_747, __p3_747) __extension__ ({ \
- uint32x4_t __ret_747; \
- uint32x4_t __s0_747 = __p0_747; \
- uint8x16_t __s1_747 = __p1_747; \
- uint8x16_t __s2_747 = __p2_747; \
-uint8x16_t __reint_747 = __s2_747; \
-uint32x4_t __reint1_747 = splatq_laneq_u32(*(uint32x4_t *) &__reint_747, __p3_747); \
- __ret_747 = vdotq_u32(__s0_747, __s1_747, *(uint8x16_t *) &__reint1_747); \
- __ret_747; \
-})
-#else
-#define vdotq_laneq_u32(__p0_748, __p1_748, __p2_748, __p3_748) __extension__ ({ \
- uint32x4_t __ret_748; \
- uint32x4_t __s0_748 = __p0_748; \
- uint8x16_t __s1_748 = __p1_748; \
- uint8x16_t __s2_748 = __p2_748; \
- uint32x4_t __rev0_748; __rev0_748 = __builtin_shufflevector(__s0_748, __s0_748, 3, 2, 1, 0); \
- uint8x16_t __rev1_748; __rev1_748 = __builtin_shufflevector(__s1_748, __s1_748, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint8x16_t __rev2_748; __rev2_748 = __builtin_shufflevector(__s2_748, __s2_748, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
-uint8x16_t __reint_748 = __rev2_748; \
-uint32x4_t __reint1_748 = __noswap_splatq_laneq_u32(*(uint32x4_t *) &__reint_748, __p3_748); \
- __ret_748 = __noswap_vdotq_u32(__rev0_748, __rev1_748, *(uint8x16_t *) &__reint1_748); \
- __ret_748 = __builtin_shufflevector(__ret_748, __ret_748, 3, 2, 1, 0); \
- __ret_748; \
-})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdotq_laneq_s32(__p0_749, __p1_749, __p2_749, __p3_749) __extension__ ({ \
- int32x4_t __ret_749; \
- int32x4_t __s0_749 = __p0_749; \
- int8x16_t __s1_749 = __p1_749; \
- int8x16_t __s2_749 = __p2_749; \
-int8x16_t __reint_749 = __s2_749; \
-int32x4_t __reint1_749 = splatq_laneq_s32(*(int32x4_t *) &__reint_749, __p3_749); \
- __ret_749 = vdotq_s32(__s0_749, __s1_749, *(int8x16_t *) &__reint1_749); \
- __ret_749; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vuqaddq_s32(int32x4_t __p0, uint32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = (int32x4_t) __builtin_neon_vuqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+ return __ret;
+}
#else
-#define vdotq_laneq_s32(__p0_750, __p1_750, __p2_750, __p3_750) __extension__ ({ \
- int32x4_t __ret_750; \
- int32x4_t __s0_750 = __p0_750; \
- int8x16_t __s1_750 = __p1_750; \
- int8x16_t __s2_750 = __p2_750; \
- int32x4_t __rev0_750; __rev0_750 = __builtin_shufflevector(__s0_750, __s0_750, 3, 2, 1, 0); \
- int8x16_t __rev1_750; __rev1_750 = __builtin_shufflevector(__s1_750, __s1_750, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- int8x16_t __rev2_750; __rev2_750 = __builtin_shufflevector(__s2_750, __s2_750, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
-int8x16_t __reint_750 = __rev2_750; \
-int32x4_t __reint1_750 = __noswap_splatq_laneq_s32(*(int32x4_t *) &__reint_750, __p3_750); \
- __ret_750 = __noswap_vdotq_s32(__rev0_750, __rev1_750, *(int8x16_t *) &__reint1_750); \
- __ret_750 = __builtin_shufflevector(__ret_750, __ret_750, 3, 2, 1, 0); \
- __ret_750; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vuqaddq_s32(int32x4_t __p0, uint32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int32x4_t) __builtin_neon_vuqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdot_laneq_u32(__p0_751, __p1_751, __p2_751, __p3_751) __extension__ ({ \
- uint32x2_t __ret_751; \
- uint32x2_t __s0_751 = __p0_751; \
- uint8x8_t __s1_751 = __p1_751; \
- uint8x16_t __s2_751 = __p2_751; \
-uint8x16_t __reint_751 = __s2_751; \
-uint32x2_t __reint1_751 = splat_laneq_u32(*(uint32x4_t *) &__reint_751, __p3_751); \
- __ret_751 = vdot_u32(__s0_751, __s1_751, *(uint8x8_t *) &__reint1_751); \
- __ret_751; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vuqaddq_s64(int64x2_t __p0, uint64x2_t __p1) {
+ int64x2_t __ret;
+ __ret = (int64x2_t) __builtin_neon_vuqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+ return __ret;
+}
#else
-#define vdot_laneq_u32(__p0_752, __p1_752, __p2_752, __p3_752) __extension__ ({ \
- uint32x2_t __ret_752; \
- uint32x2_t __s0_752 = __p0_752; \
- uint8x8_t __s1_752 = __p1_752; \
- uint8x16_t __s2_752 = __p2_752; \
- uint32x2_t __rev0_752; __rev0_752 = __builtin_shufflevector(__s0_752, __s0_752, 1, 0); \
- uint8x8_t __rev1_752; __rev1_752 = __builtin_shufflevector(__s1_752, __s1_752, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint8x16_t __rev2_752; __rev2_752 = __builtin_shufflevector(__s2_752, __s2_752, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
-uint8x16_t __reint_752 = __rev2_752; \
-uint32x2_t __reint1_752 = __noswap_splat_laneq_u32(*(uint32x4_t *) &__reint_752, __p3_752); \
- __ret_752 = __noswap_vdot_u32(__rev0_752, __rev1_752, *(uint8x8_t *) &__reint1_752); \
- __ret_752 = __builtin_shufflevector(__ret_752, __ret_752, 1, 0); \
- __ret_752; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vuqaddq_s64(int64x2_t __p0, uint64x2_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int64x2_t) __builtin_neon_vuqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vdot_laneq_s32(__p0_753, __p1_753, __p2_753, __p3_753) __extension__ ({ \
- int32x2_t __ret_753; \
- int32x2_t __s0_753 = __p0_753; \
- int8x8_t __s1_753 = __p1_753; \
- int8x16_t __s2_753 = __p2_753; \
-int8x16_t __reint_753 = __s2_753; \
-int32x2_t __reint1_753 = splat_laneq_s32(*(int32x4_t *) &__reint_753, __p3_753); \
- __ret_753 = vdot_s32(__s0_753, __s1_753, *(int8x8_t *) &__reint1_753); \
- __ret_753; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vuqaddq_s16(int16x8_t __p0, uint16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = (int16x8_t) __builtin_neon_vuqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+ return __ret;
+}
#else
-#define vdot_laneq_s32(__p0_754, __p1_754, __p2_754, __p3_754) __extension__ ({ \
- int32x2_t __ret_754; \
- int32x2_t __s0_754 = __p0_754; \
- int8x8_t __s1_754 = __p1_754; \
- int8x16_t __s2_754 = __p2_754; \
- int32x2_t __rev0_754; __rev0_754 = __builtin_shufflevector(__s0_754, __s0_754, 1, 0); \
- int8x8_t __rev1_754; __rev1_754 = __builtin_shufflevector(__s1_754, __s1_754, 7, 6, 5, 4, 3, 2, 1, 0); \
- int8x16_t __rev2_754; __rev2_754 = __builtin_shufflevector(__s2_754, __s2_754, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
-int8x16_t __reint_754 = __rev2_754; \
-int32x2_t __reint1_754 = __noswap_splat_laneq_s32(*(int32x4_t *) &__reint_754, __p3_754); \
- __ret_754 = __noswap_vdot_s32(__rev0_754, __rev1_754, *(int8x8_t *) &__reint1_754); \
- __ret_754 = __builtin_shufflevector(__ret_754, __ret_754, 1, 0); \
- __ret_754; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vuqaddq_s16(int16x8_t __p0, uint16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int16x8_t) __builtin_neon_vuqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fp16fml"))) float32x4_t vfmlalq_high_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vfmlalq_high_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("neon"))) int8x8_t vuqadd_s8(int8x8_t __p0, uint8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = (int8x8_t) __builtin_neon_vuqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
return __ret;
}
#else
-__ai __attribute__((target("fp16fml"))) float32x4_t vfmlalq_high_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vfmlalq_high_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
-__ai __attribute__((target("fp16fml"))) float32x4_t __noswap_vfmlalq_high_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vfmlalq_high_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("neon"))) int8x8_t vuqadd_s8(int8x8_t __p0, uint8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = (int8x8_t) __builtin_neon_vuqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fp16fml"))) float32x2_t vfmlal_high_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vfmlal_high_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+__ai __attribute__((target("neon"))) int32x2_t vuqadd_s32(int32x2_t __p0, uint32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = (int32x2_t) __builtin_neon_vuqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
return __ret;
}
#else
-__ai __attribute__((target("fp16fml"))) float32x2_t vfmlal_high_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vfmlal_high_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+__ai __attribute__((target("neon"))) int32x2_t vuqadd_s32(int32x2_t __p0, uint32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = (int32x2_t) __builtin_neon_vuqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai __attribute__((target("fp16fml"))) float32x2_t __noswap_vfmlal_high_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vfmlal_high_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
- return __ret;
-}
#endif
+__ai __attribute__((target("neon"))) int64x1_t vuqadd_s64(int64x1_t __p0, uint64x1_t __p1) {
+ int64x1_t __ret;
+ __ret = (int64x1_t) __builtin_neon_vuqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
+ return __ret;
+}
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fp16fml"))) float32x4_t vfmlalq_low_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vfmlalq_low_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("neon"))) int16x4_t vuqadd_s16(int16x4_t __p0, uint16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = (int16x4_t) __builtin_neon_vuqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
return __ret;
}
#else
-__ai __attribute__((target("fp16fml"))) float32x4_t vfmlalq_low_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vfmlalq_low_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+__ai __attribute__((target("neon"))) int16x4_t vuqadd_s16(int16x4_t __p0, uint16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = (int16x4_t) __builtin_neon_vuqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai __attribute__((target("fp16fml"))) float32x4_t __noswap_vfmlalq_low_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vfmlalq_low_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fp16fml"))) float32x2_t vfmlal_low_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vfmlal_low_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+__ai __attribute__((target("neon"))) poly8x8_t vuzp1_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
return __ret;
}
#else
-__ai __attribute__((target("fp16fml"))) float32x2_t vfmlal_low_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vfmlal_low_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
-__ai __attribute__((target("fp16fml"))) float32x2_t __noswap_vfmlal_low_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vfmlal_low_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+__ai __attribute__((target("neon"))) poly8x8_t vuzp1_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fp16fml"))) float32x4_t vfmlslq_high_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vfmlslq_high_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("neon"))) poly16x4_t vuzp1_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ poly16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
return __ret;
}
#else
-__ai __attribute__((target("fp16fml"))) float32x4_t vfmlslq_high_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vfmlslq_high_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+__ai __attribute__((target("neon"))) poly16x4_t vuzp1_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ poly16x4_t __ret;
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai __attribute__((target("fp16fml"))) float32x4_t __noswap_vfmlslq_high_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vfmlslq_high_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vuzp1q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vuzp1q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly8x16_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fp16fml"))) float32x2_t vfmlsl_high_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vfmlsl_high_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+__ai __attribute__((target("neon"))) poly64x2_t vuzp1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+ poly64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
return __ret;
}
#else
-__ai __attribute__((target("fp16fml"))) float32x2_t vfmlsl_high_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vfmlsl_high_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+__ai __attribute__((target("neon"))) poly64x2_t vuzp1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+ poly64x2_t __ret;
+ poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai __attribute__((target("fp16fml"))) float32x2_t __noswap_vfmlsl_high_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vfmlsl_high_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8_t vuzp1q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+ poly16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8_t vuzp1q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+ poly16x8_t __ret;
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fp16fml"))) float32x4_t vfmlslq_low_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vfmlslq_low_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+__ai __attribute__((target("neon"))) uint8x16_t vuzp1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
return __ret;
}
#else
-__ai __attribute__((target("fp16fml"))) float32x4_t vfmlslq_low_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float32x4_t __ret;
- float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float32x4_t) __builtin_neon_vfmlslq_low_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vuzp1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai __attribute__((target("fp16fml"))) float32x4_t __noswap_vfmlslq_low_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
- float32x4_t __ret;
- __ret = (float32x4_t) __builtin_neon_vfmlslq_low_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vuzp1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vuzp1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fp16fml"))) float32x2_t vfmlsl_low_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vfmlsl_low_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+__ai __attribute__((target("neon"))) uint64x2_t vuzp1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
return __ret;
}
#else
-__ai __attribute__((target("fp16fml"))) float32x2_t vfmlsl_low_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float32x2_t __ret;
- float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- float16x4_t __rev2; __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
- __ret = (float32x2_t) __builtin_neon_vfmlsl_low_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+__ai __attribute__((target("neon"))) uint64x2_t vuzp1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai __attribute__((target("fp16fml"))) float32x2_t __noswap_vfmlsl_low_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
- float32x2_t __ret;
- __ret = (float32x2_t) __builtin_neon_vfmlsl_low_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
- return __ret;
-}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vdivq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = __p0 / __p1;
+__ai __attribute__((target("neon"))) uint16x8_t vuzp1q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vdivq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __rev0 / __rev1;
+__ai __attribute__((target("neon"))) uint16x8_t vuzp1q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vdiv_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = __p0 / __p1;
+__ai __attribute__((target("neon"))) int8x16_t vuzp1q_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vdiv_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __rev0 / __rev1;
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int8x16_t vuzp1q_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vduph_lane_f16(__p0, __p1) __extension__ ({ \
- float16_t __ret; \
- float16x4_t __s0 = __p0; \
- __ret = (float16_t) __builtin_neon_vduph_lane_f16((float16x4_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vuzp1q_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+ return __ret;
+}
#else
-#define vduph_lane_f16(__p0, __p1) __extension__ ({ \
- float16_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (float16_t) __builtin_neon_vduph_lane_f16((float16x4_t)__rev0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vuzp1q_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vduph_laneq_f16(__p0, __p1) __extension__ ({ \
- float16_t __ret; \
- float16x8_t __s0 = __p0; \
- __ret = (float16_t) __builtin_neon_vduph_laneq_f16((float16x8_t)__s0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vuzp1q_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
+ return __ret;
+}
#else
-#define vduph_laneq_f16(__p0, __p1) __extension__ ({ \
- float16_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (float16_t) __builtin_neon_vduph_laneq_f16((float16x8_t)__rev0, __p1); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vuzp1q_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vfmah_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
- float16_t __ret; \
- float16_t __s0 = __p0; \
- float16_t __s1 = __p1; \
- float16x4_t __s2 = __p2; \
- __ret = (float16_t) __builtin_neon_vfmah_lane_f16(__s0, __s1, (float16x4_t)__s2, __p3); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vuzp1q_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
+ return __ret;
+}
#else
-#define vfmah_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
- float16_t __ret; \
- float16_t __s0 = __p0; \
- float16_t __s1 = __p1; \
- float16x4_t __s2 = __p2; \
- float16x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
- __ret = (float16_t) __builtin_neon_vfmah_lane_f16(__s0, __s1, (float16x4_t)__rev2, __p3); \
- __ret; \
-})
-#define __noswap_vfmah_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
- float16_t __ret; \
- float16_t __s0 = __p0; \
- float16_t __s1 = __p1; \
- float16x4_t __s2 = __p2; \
- __ret = (float16_t) __builtin_neon_vfmah_lane_f16(__s0, __s1, (float16x4_t)__s2, __p3); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vuzp1q_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vfmaq_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __s1 = __p1; \
- float16x4_t __s2 = __p2; \
- __ret = (float16x8_t) __builtin_neon_vfmaq_lane_f16((int8x16_t)__s0, (int8x16_t)__s1, (int8x8_t)__s2, __p3, 40); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vuzp1q_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+ return __ret;
+}
#else
-#define vfmaq_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __s1 = __p1; \
- float16x4_t __s2 = __p2; \
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
- __ret = (float16x8_t) __builtin_neon_vfmaq_lane_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x8_t)__rev2, __p3, 40); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vfmaq_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __s1 = __p1; \
- float16x4_t __s2 = __p2; \
- __ret = (float16x8_t) __builtin_neon_vfmaq_lane_f16((int8x16_t)__s0, (int8x16_t)__s1, (int8x8_t)__s2, __p3, 40); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vuzp1q_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vfma_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __s1 = __p1; \
- float16x4_t __s2 = __p2; \
- __ret = (float16x4_t) __builtin_neon_vfma_lane_f16((int8x8_t)__s0, (int8x8_t)__s1, (int8x8_t)__s2, __p3, 8); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vuzp1q_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
+ return __ret;
+}
#else
-#define vfma_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __s1 = __p1; \
- float16x4_t __s2 = __p2; \
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- float16x4_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
- __ret = (float16x4_t) __builtin_neon_vfma_lane_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, __p3, 8); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vfma_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __s1 = __p1; \
- float16x4_t __s2 = __p2; \
- __ret = (float16x4_t) __builtin_neon_vfma_lane_f16((int8x8_t)__s0, (int8x8_t)__s1, (int8x8_t)__s2, __p3, 8); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vuzp1q_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vuzp1_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vuzp1_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vfmah_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
- float16_t __ret; \
- float16_t __s0 = __p0; \
- float16_t __s1 = __p1; \
- float16x8_t __s2 = __p2; \
- __ret = (float16_t) __builtin_neon_vfmah_laneq_f16(__s0, __s1, (float16x8_t)__s2, __p3); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vuzp1_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+ return __ret;
+}
#else
-#define vfmah_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
- float16_t __ret; \
- float16_t __s0 = __p0; \
- float16_t __s1 = __p1; \
- float16x8_t __s2 = __p2; \
- float16x8_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (float16_t) __builtin_neon_vfmah_laneq_f16(__s0, __s1, (float16x8_t)__rev2, __p3); \
- __ret; \
-})
-#define __noswap_vfmah_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
- float16_t __ret; \
- float16_t __s0 = __p0; \
- float16_t __s1 = __p1; \
- float16x8_t __s2 = __p2; \
- __ret = (float16_t) __builtin_neon_vfmah_laneq_f16(__s0, __s1, (float16x8_t)__s2, __p3); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x2_t vuzp1_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vfmaq_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __s1 = __p1; \
- float16x8_t __s2 = __p2; \
- __ret = (float16x8_t) __builtin_neon_vfmaq_laneq_f16((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 40); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vuzp1_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
+ return __ret;
+}
#else
-#define vfmaq_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __s1 = __p1; \
- float16x8_t __s2 = __p2; \
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (float16x8_t) __builtin_neon_vfmaq_laneq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, __p3, 40); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vfmaq_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __s1 = __p1; \
- float16x8_t __s2 = __p2; \
- __ret = (float16x8_t) __builtin_neon_vfmaq_laneq_f16((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 40); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x4_t vuzp1_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vfma_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __s1 = __p1; \
- float16x8_t __s2 = __p2; \
- __ret = (float16x4_t) __builtin_neon_vfma_laneq_f16((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__s2, __p3, 8); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vuzp1_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
+ return __ret;
+}
#else
-#define vfma_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __s1 = __p1; \
- float16x8_t __s2 = __p2; \
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- float16x8_t __rev2; __rev2 = __builtin_shufflevector(__s2, __s2, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (float16x4_t) __builtin_neon_vfma_laneq_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x16_t)__rev2, __p3, 8); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
-#define __noswap_vfma_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __s1 = __p1; \
- float16x8_t __s2 = __p2; \
- __ret = (float16x4_t) __builtin_neon_vfma_laneq_f16((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__s2, __p3, 8); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x8_t vuzp1_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vfmaq_n_f16(__p0, __p1, __p2) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __s1 = __p1; \
- float16_t __s2 = __p2; \
- __ret = vfmaq_f16(__s0, __s1, (float16x8_t) {__s2, __s2, __s2, __s2, __s2, __s2, __s2, __s2}); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vuzp1_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+ return __ret;
+}
#else
-#define vfmaq_n_f16(__p0, __p1, __p2) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __s1 = __p1; \
- float16_t __s2 = __p2; \
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = __noswap_vfmaq_f16(__rev0, __rev1, (float16x8_t) {__s2, __s2, __s2, __s2, __s2, __s2, __s2, __s2}); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vuzp1_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vfma_n_f16(__p0, __p1, __p2) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __s1 = __p1; \
- float16_t __s2 = __p2; \
- __ret = vfma_f16(__s0, __s1, (float16x4_t) {__s2, __s2, __s2, __s2}); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vuzp1_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+ return __ret;
+}
#else
-#define vfma_n_f16(__p0, __p1, __p2) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __s1 = __p1; \
- float16_t __s2 = __p2; \
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = __noswap_vfma_f16(__rev0, __rev1, (float16x4_t) {__s2, __s2, __s2, __s2}); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vuzp1_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vfmsh_lane_f16(__p0_755, __p1_755, __p2_755, __p3_755) __extension__ ({ \
- float16_t __ret_755; \
- float16_t __s0_755 = __p0_755; \
- float16_t __s1_755 = __p1_755; \
- float16x4_t __s2_755 = __p2_755; \
- __ret_755 = vfmah_lane_f16(__s0_755, -__s1_755, __s2_755, __p3_755); \
- __ret_755; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vuzp1_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
+ return __ret;
+}
#else
-#define vfmsh_lane_f16(__p0_756, __p1_756, __p2_756, __p3_756) __extension__ ({ \
- float16_t __ret_756; \
- float16_t __s0_756 = __p0_756; \
- float16_t __s1_756 = __p1_756; \
- float16x4_t __s2_756 = __p2_756; \
- float16x4_t __rev2_756; __rev2_756 = __builtin_shufflevector(__s2_756, __s2_756, 3, 2, 1, 0); \
- __ret_756 = __noswap_vfmah_lane_f16(__s0_756, -__s1_756, __rev2_756, __p3_756); \
- __ret_756; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vuzp1_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vfmsq_lane_f16(__p0_757, __p1_757, __p2_757, __p3_757) __extension__ ({ \
- float16x8_t __ret_757; \
- float16x8_t __s0_757 = __p0_757; \
- float16x8_t __s1_757 = __p1_757; \
- float16x4_t __s2_757 = __p2_757; \
- __ret_757 = vfmaq_lane_f16(__s0_757, -__s1_757, __s2_757, __p3_757); \
- __ret_757; \
-})
+__ai __attribute__((target("neon"))) float16x8_t vuzp1q_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
+ return __ret;
+}
#else
-#define vfmsq_lane_f16(__p0_758, __p1_758, __p2_758, __p3_758) __extension__ ({ \
- float16x8_t __ret_758; \
- float16x8_t __s0_758 = __p0_758; \
- float16x8_t __s1_758 = __p1_758; \
- float16x4_t __s2_758 = __p2_758; \
- float16x8_t __rev0_758; __rev0_758 = __builtin_shufflevector(__s0_758, __s0_758, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev1_758; __rev1_758 = __builtin_shufflevector(__s1_758, __s1_758, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x4_t __rev2_758; __rev2_758 = __builtin_shufflevector(__s2_758, __s2_758, 3, 2, 1, 0); \
- __ret_758 = __noswap_vfmaq_lane_f16(__rev0_758, -__rev1_758, __rev2_758, __p3_758); \
- __ret_758 = __builtin_shufflevector(__ret_758, __ret_758, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_758; \
-})
+__ai __attribute__((target("neon"))) float16x8_t vuzp1q_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vfms_lane_f16(__p0_759, __p1_759, __p2_759, __p3_759) __extension__ ({ \
- float16x4_t __ret_759; \
- float16x4_t __s0_759 = __p0_759; \
- float16x4_t __s1_759 = __p1_759; \
- float16x4_t __s2_759 = __p2_759; \
- __ret_759 = vfma_lane_f16(__s0_759, -__s1_759, __s2_759, __p3_759); \
- __ret_759; \
-})
+__ai __attribute__((target("neon"))) float16x4_t vuzp1_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
+ return __ret;
+}
#else
-#define vfms_lane_f16(__p0_760, __p1_760, __p2_760, __p3_760) __extension__ ({ \
- float16x4_t __ret_760; \
- float16x4_t __s0_760 = __p0_760; \
- float16x4_t __s1_760 = __p1_760; \
- float16x4_t __s2_760 = __p2_760; \
- float16x4_t __rev0_760; __rev0_760 = __builtin_shufflevector(__s0_760, __s0_760, 3, 2, 1, 0); \
- float16x4_t __rev1_760; __rev1_760 = __builtin_shufflevector(__s1_760, __s1_760, 3, 2, 1, 0); \
- float16x4_t __rev2_760; __rev2_760 = __builtin_shufflevector(__s2_760, __s2_760, 3, 2, 1, 0); \
- __ret_760 = __noswap_vfma_lane_f16(__rev0_760, -__rev1_760, __rev2_760, __p3_760); \
- __ret_760 = __builtin_shufflevector(__ret_760, __ret_760, 3, 2, 1, 0); \
- __ret_760; \
-})
+__ai __attribute__((target("neon"))) float16x4_t vuzp1_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vfmsh_laneq_f16(__p0_761, __p1_761, __p2_761, __p3_761) __extension__ ({ \
- float16_t __ret_761; \
- float16_t __s0_761 = __p0_761; \
- float16_t __s1_761 = __p1_761; \
- float16x8_t __s2_761 = __p2_761; \
- __ret_761 = vfmah_laneq_f16(__s0_761, -__s1_761, __s2_761, __p3_761); \
- __ret_761; \
-})
+__ai __attribute__((target("neon"))) poly8x8_t vuzp2_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+ return __ret;
+}
#else
-#define vfmsh_laneq_f16(__p0_762, __p1_762, __p2_762, __p3_762) __extension__ ({ \
- float16_t __ret_762; \
- float16_t __s0_762 = __p0_762; \
- float16_t __s1_762 = __p1_762; \
- float16x8_t __s2_762 = __p2_762; \
- float16x8_t __rev2_762; __rev2_762 = __builtin_shufflevector(__s2_762, __s2_762, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_762 = __noswap_vfmah_laneq_f16(__s0_762, -__s1_762, __rev2_762, __p3_762); \
- __ret_762; \
-})
+__ai __attribute__((target("neon"))) poly8x8_t vuzp2_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vfmsq_laneq_f16(__p0_763, __p1_763, __p2_763, __p3_763) __extension__ ({ \
- float16x8_t __ret_763; \
- float16x8_t __s0_763 = __p0_763; \
- float16x8_t __s1_763 = __p1_763; \
- float16x8_t __s2_763 = __p2_763; \
- __ret_763 = vfmaq_laneq_f16(__s0_763, -__s1_763, __s2_763, __p3_763); \
- __ret_763; \
-})
+__ai __attribute__((target("neon"))) poly16x4_t vuzp2_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ poly16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
+ return __ret;
+}
#else
-#define vfmsq_laneq_f16(__p0_764, __p1_764, __p2_764, __p3_764) __extension__ ({ \
- float16x8_t __ret_764; \
- float16x8_t __s0_764 = __p0_764; \
- float16x8_t __s1_764 = __p1_764; \
- float16x8_t __s2_764 = __p2_764; \
- float16x8_t __rev0_764; __rev0_764 = __builtin_shufflevector(__s0_764, __s0_764, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev1_764; __rev1_764 = __builtin_shufflevector(__s1_764, __s1_764, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev2_764; __rev2_764 = __builtin_shufflevector(__s2_764, __s2_764, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_764 = __noswap_vfmaq_laneq_f16(__rev0_764, -__rev1_764, __rev2_764, __p3_764); \
- __ret_764 = __builtin_shufflevector(__ret_764, __ret_764, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_764; \
-})
+__ai __attribute__((target("neon"))) poly16x4_t vuzp2_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ poly16x4_t __ret;
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vfms_laneq_f16(__p0_765, __p1_765, __p2_765, __p3_765) __extension__ ({ \
- float16x4_t __ret_765; \
- float16x4_t __s0_765 = __p0_765; \
- float16x4_t __s1_765 = __p1_765; \
- float16x8_t __s2_765 = __p2_765; \
- __ret_765 = vfma_laneq_f16(__s0_765, -__s1_765, __s2_765, __p3_765); \
- __ret_765; \
-})
+__ai __attribute__((target("neon"))) poly8x16_t vuzp2q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
+ return __ret;
+}
#else
-#define vfms_laneq_f16(__p0_766, __p1_766, __p2_766, __p3_766) __extension__ ({ \
- float16x4_t __ret_766; \
- float16x4_t __s0_766 = __p0_766; \
- float16x4_t __s1_766 = __p1_766; \
- float16x8_t __s2_766 = __p2_766; \
- float16x4_t __rev0_766; __rev0_766 = __builtin_shufflevector(__s0_766, __s0_766, 3, 2, 1, 0); \
- float16x4_t __rev1_766; __rev1_766 = __builtin_shufflevector(__s1_766, __s1_766, 3, 2, 1, 0); \
- float16x8_t __rev2_766; __rev2_766 = __builtin_shufflevector(__s2_766, __s2_766, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_766 = __noswap_vfma_laneq_f16(__rev0_766, -__rev1_766, __rev2_766, __p3_766); \
- __ret_766 = __builtin_shufflevector(__ret_766, __ret_766, 3, 2, 1, 0); \
- __ret_766; \
-})
+__ai __attribute__((target("neon"))) poly8x16_t vuzp2q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly8x16_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vfmsq_n_f16(__p0, __p1, __p2) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __s1 = __p1; \
- float16_t __s2 = __p2; \
- __ret = vfmaq_f16(__s0, -__s1, (float16x8_t) {__s2, __s2, __s2, __s2, __s2, __s2, __s2, __s2}); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly64x2_t vuzp2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+ poly64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+ return __ret;
+}
#else
-#define vfmsq_n_f16(__p0, __p1, __p2) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __s1 = __p1; \
- float16_t __s2 = __p2; \
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = __noswap_vfmaq_f16(__rev0, -__rev1, (float16x8_t) {__s2, __s2, __s2, __s2, __s2, __s2, __s2, __s2}); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly64x2_t vuzp2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+ poly64x2_t __ret;
+ poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vfms_n_f16(__p0, __p1, __p2) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __s1 = __p1; \
- float16_t __s2 = __p2; \
- __ret = vfma_f16(__s0, -__s1, (float16x4_t) {__s2, __s2, __s2, __s2}); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x8_t vuzp2q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+ poly16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+ return __ret;
+}
#else
-#define vfms_n_f16(__p0, __p1, __p2) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __s1 = __p1; \
- float16_t __s2 = __p2; \
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = __noswap_vfma_f16(__rev0, -__rev1, (float16x4_t) {__s2, __s2, __s2, __s2}); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x8_t vuzp2q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+ poly16x8_t __ret;
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmaxnmvq_f16(__p0) __extension__ ({ \
- float16_t __ret; \
- float16x8_t __s0 = __p0; \
- __ret = (float16_t) __builtin_neon_vmaxnmvq_f16((int8x16_t)__s0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vuzp2q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
+ return __ret;
+}
#else
-#define vmaxnmvq_f16(__p0) __extension__ ({ \
- float16_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (float16_t) __builtin_neon_vmaxnmvq_f16((int8x16_t)__rev0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vuzp2q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmaxnmv_f16(__p0) __extension__ ({ \
- float16_t __ret; \
- float16x4_t __s0 = __p0; \
- __ret = (float16_t) __builtin_neon_vmaxnmv_f16((int8x8_t)__s0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vuzp2q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
+ return __ret;
+}
#else
-#define vmaxnmv_f16(__p0) __extension__ ({ \
- float16_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (float16_t) __builtin_neon_vmaxnmv_f16((int8x8_t)__rev0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint32x4_t vuzp2q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmaxvq_f16(__p0) __extension__ ({ \
- float16_t __ret; \
- float16x8_t __s0 = __p0; \
- __ret = (float16_t) __builtin_neon_vmaxvq_f16((int8x16_t)__s0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vuzp2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+ return __ret;
+}
#else
-#define vmaxvq_f16(__p0) __extension__ ({ \
- float16_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (float16_t) __builtin_neon_vmaxvq_f16((int8x16_t)__rev0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint64x2_t vuzp2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmaxv_f16(__p0) __extension__ ({ \
- float16_t __ret; \
- float16x4_t __s0 = __p0; \
- __ret = (float16_t) __builtin_neon_vmaxv_f16((int8x8_t)__s0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vuzp2q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+ return __ret;
+}
#else
-#define vmaxv_f16(__p0) __extension__ ({ \
- float16_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (float16_t) __builtin_neon_vmaxv_f16((int8x8_t)__rev0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) uint16x8_t vuzp2q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vminnmvq_f16(__p0) __extension__ ({ \
- float16_t __ret; \
- float16x8_t __s0 = __p0; \
- __ret = (float16_t) __builtin_neon_vminnmvq_f16((int8x16_t)__s0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vuzp2q_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
+ return __ret;
+}
#else
-#define vminnmvq_f16(__p0) __extension__ ({ \
- float16_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (float16_t) __builtin_neon_vminnmvq_f16((int8x16_t)__rev0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int8x16_t vuzp2q_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vminnmv_f16(__p0) __extension__ ({ \
- float16_t __ret; \
- float16x4_t __s0 = __p0; \
- __ret = (float16_t) __builtin_neon_vminnmv_f16((int8x8_t)__s0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vuzp2q_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+ return __ret;
+}
#else
-#define vminnmv_f16(__p0) __extension__ ({ \
- float16_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (float16_t) __builtin_neon_vminnmv_f16((int8x8_t)__rev0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float64x2_t vuzp2q_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vminvq_f16(__p0) __extension__ ({ \
- float16_t __ret; \
- float16x8_t __s0 = __p0; \
- __ret = (float16_t) __builtin_neon_vminvq_f16((int8x16_t)__s0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vuzp2q_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
+ return __ret;
+}
#else
-#define vminvq_f16(__p0) __extension__ ({ \
- float16_t __ret; \
- float16x8_t __s0 = __p0; \
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (float16_t) __builtin_neon_vminvq_f16((int8x16_t)__rev0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x4_t vuzp2q_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vminv_f16(__p0) __extension__ ({ \
- float16_t __ret; \
- float16x4_t __s0 = __p0; \
- __ret = (float16_t) __builtin_neon_vminv_f16((int8x8_t)__s0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vuzp2q_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
+ return __ret;
+}
#else
-#define vminv_f16(__p0) __extension__ ({ \
- float16_t __ret; \
- float16x4_t __s0 = __p0; \
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = (float16_t) __builtin_neon_vminv_f16((int8x8_t)__rev0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) int32x4_t vuzp2q_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulq_laneq_f16(__p0_767, __p1_767, __p2_767) __extension__ ({ \
- float16x8_t __ret_767; \
- float16x8_t __s0_767 = __p0_767; \
- float16x8_t __s1_767 = __p1_767; \
- __ret_767 = __s0_767 * splatq_laneq_f16(__s1_767, __p2_767); \
- __ret_767; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vuzp2q_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+ return __ret;
+}
#else
-#define vmulq_laneq_f16(__p0_768, __p1_768, __p2_768) __extension__ ({ \
- float16x8_t __ret_768; \
- float16x8_t __s0_768 = __p0_768; \
- float16x8_t __s1_768 = __p1_768; \
- float16x8_t __rev0_768; __rev0_768 = __builtin_shufflevector(__s0_768, __s0_768, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev1_768; __rev1_768 = __builtin_shufflevector(__s1_768, __s1_768, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_768 = __rev0_768 * __noswap_splatq_laneq_f16(__rev1_768, __p2_768); \
- __ret_768 = __builtin_shufflevector(__ret_768, __ret_768, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_768; \
-})
+__ai __attribute__((target("neon"))) int64x2_t vuzp2q_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmul_laneq_f16(__p0_769, __p1_769, __p2_769) __extension__ ({ \
- float16x4_t __ret_769; \
- float16x4_t __s0_769 = __p0_769; \
- float16x8_t __s1_769 = __p1_769; \
- __ret_769 = __s0_769 * splat_laneq_f16(__s1_769, __p2_769); \
- __ret_769; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vuzp2q_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+ return __ret;
+}
#else
-#define vmul_laneq_f16(__p0_770, __p1_770, __p2_770) __extension__ ({ \
- float16x4_t __ret_770; \
- float16x4_t __s0_770 = __p0_770; \
- float16x8_t __s1_770 = __p1_770; \
- float16x4_t __rev0_770; __rev0_770 = __builtin_shufflevector(__s0_770, __s0_770, 3, 2, 1, 0); \
- float16x8_t __rev1_770; __rev1_770 = __builtin_shufflevector(__s1_770, __s1_770, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_770 = __rev0_770 * __noswap_splat_laneq_f16(__rev1_770, __p2_770); \
- __ret_770 = __builtin_shufflevector(__ret_770, __ret_770, 3, 2, 1, 0); \
- __ret_770; \
-})
+__ai __attribute__((target("neon"))) int16x8_t vuzp2q_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vmulxq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vmulxq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+__ai __attribute__((target("neon"))) uint8x8_t vuzp2_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vmulxq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vmulxq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+__ai __attribute__((target("neon"))) uint8x8_t vuzp2_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai __attribute__((target("fullfp16"))) float16x8_t __noswap_vmulxq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vmulxq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vuzp2_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vuzp2_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vmulx_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vmulx_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+__ai __attribute__((target("neon"))) uint16x4_t vuzp2_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vmulx_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vmulx_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+__ai __attribute__((target("neon"))) uint16x4_t vuzp2_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai __attribute__((target("fullfp16"))) float16x4_t __noswap_vmulx_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vmulx_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vuzp2_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vuzp2_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulxh_lane_f16(__p0, __p1, __p2) __extension__ ({ \
- float16_t __ret; \
- float16_t __s0 = __p0; \
- float16x4_t __s1 = __p1; \
- __ret = (float16_t) __builtin_neon_vmulxh_lane_f16(__s0, (float16x4_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vuzp2_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+ return __ret;
+}
#else
-#define vmulxh_lane_f16(__p0, __p1, __p2) __extension__ ({ \
- float16_t __ret; \
- float16_t __s0 = __p0; \
- float16x4_t __s1 = __p1; \
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
- __ret = (float16_t) __builtin_neon_vmulxh_lane_f16(__s0, (float16x4_t)__rev1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float32x2_t vuzp2_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulxq_lane_f16(__p0_771, __p1_771, __p2_771) __extension__ ({ \
- float16x8_t __ret_771; \
- float16x8_t __s0_771 = __p0_771; \
- float16x4_t __s1_771 = __p1_771; \
- __ret_771 = vmulxq_f16(__s0_771, splatq_lane_f16(__s1_771, __p2_771)); \
- __ret_771; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vuzp2_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+ return __ret;
+}
#else
-#define vmulxq_lane_f16(__p0_772, __p1_772, __p2_772) __extension__ ({ \
- float16x8_t __ret_772; \
- float16x8_t __s0_772 = __p0_772; \
- float16x4_t __s1_772 = __p1_772; \
- float16x8_t __rev0_772; __rev0_772 = __builtin_shufflevector(__s0_772, __s0_772, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x4_t __rev1_772; __rev1_772 = __builtin_shufflevector(__s1_772, __s1_772, 3, 2, 1, 0); \
- __ret_772 = __noswap_vmulxq_f16(__rev0_772, __noswap_splatq_lane_f16(__rev1_772, __p2_772)); \
- __ret_772 = __builtin_shufflevector(__ret_772, __ret_772, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_772; \
-})
+__ai __attribute__((target("neon"))) int32x2_t vuzp2_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulx_lane_f16(__p0_773, __p1_773, __p2_773) __extension__ ({ \
- float16x4_t __ret_773; \
- float16x4_t __s0_773 = __p0_773; \
- float16x4_t __s1_773 = __p1_773; \
- __ret_773 = vmulx_f16(__s0_773, splat_lane_f16(__s1_773, __p2_773)); \
- __ret_773; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vuzp2_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
+ return __ret;
+}
#else
-#define vmulx_lane_f16(__p0_774, __p1_774, __p2_774) __extension__ ({ \
- float16x4_t __ret_774; \
- float16x4_t __s0_774 = __p0_774; \
- float16x4_t __s1_774 = __p1_774; \
- float16x4_t __rev0_774; __rev0_774 = __builtin_shufflevector(__s0_774, __s0_774, 3, 2, 1, 0); \
- float16x4_t __rev1_774; __rev1_774 = __builtin_shufflevector(__s1_774, __s1_774, 3, 2, 1, 0); \
- __ret_774 = __noswap_vmulx_f16(__rev0_774, __noswap_splat_lane_f16(__rev1_774, __p2_774)); \
- __ret_774 = __builtin_shufflevector(__ret_774, __ret_774, 3, 2, 1, 0); \
- __ret_774; \
-})
+__ai __attribute__((target("neon"))) int16x4_t vuzp2_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulxh_laneq_f16(__p0, __p1, __p2) __extension__ ({ \
- float16_t __ret; \
- float16_t __s0 = __p0; \
- float16x8_t __s1 = __p1; \
- __ret = (float16_t) __builtin_neon_vmulxh_laneq_f16(__s0, (float16x8_t)__s1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float16x8_t vuzp2q_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+ return __ret;
+}
#else
-#define vmulxh_laneq_f16(__p0, __p1, __p2) __extension__ ({ \
- float16_t __ret; \
- float16_t __s0 = __p0; \
- float16x8_t __s1 = __p1; \
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = (float16_t) __builtin_neon_vmulxh_laneq_f16(__s0, (float16x8_t)__rev1, __p2); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) float16x8_t vuzp2q_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulxq_laneq_f16(__p0_775, __p1_775, __p2_775) __extension__ ({ \
- float16x8_t __ret_775; \
- float16x8_t __s0_775 = __p0_775; \
- float16x8_t __s1_775 = __p1_775; \
- __ret_775 = vmulxq_f16(__s0_775, splatq_laneq_f16(__s1_775, __p2_775)); \
- __ret_775; \
-})
+__ai __attribute__((target("neon"))) float16x4_t vuzp2_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
+ return __ret;
+}
#else
-#define vmulxq_laneq_f16(__p0_776, __p1_776, __p2_776) __extension__ ({ \
- float16x8_t __ret_776; \
- float16x8_t __s0_776 = __p0_776; \
- float16x8_t __s1_776 = __p1_776; \
- float16x8_t __rev0_776; __rev0_776 = __builtin_shufflevector(__s0_776, __s0_776, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev1_776; __rev1_776 = __builtin_shufflevector(__s1_776, __s1_776, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_776 = __noswap_vmulxq_f16(__rev0_776, __noswap_splatq_laneq_f16(__rev1_776, __p2_776)); \
- __ret_776 = __builtin_shufflevector(__ret_776, __ret_776, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_776; \
-})
+__ai __attribute__((target("neon"))) float16x4_t vuzp2_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulx_laneq_f16(__p0_777, __p1_777, __p2_777) __extension__ ({ \
- float16x4_t __ret_777; \
- float16x4_t __s0_777 = __p0_777; \
- float16x8_t __s1_777 = __p1_777; \
- __ret_777 = vmulx_f16(__s0_777, splat_laneq_f16(__s1_777, __p2_777)); \
- __ret_777; \
-})
+__ai __attribute__((target("neon"))) poly8x8_t vzip1_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
+ return __ret;
+}
#else
-#define vmulx_laneq_f16(__p0_778, __p1_778, __p2_778) __extension__ ({ \
- float16x4_t __ret_778; \
- float16x4_t __s0_778 = __p0_778; \
- float16x8_t __s1_778 = __p1_778; \
- float16x4_t __rev0_778; __rev0_778 = __builtin_shufflevector(__s0_778, __s0_778, 3, 2, 1, 0); \
- float16x8_t __rev1_778; __rev1_778 = __builtin_shufflevector(__s1_778, __s1_778, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_778 = __noswap_vmulx_f16(__rev0_778, __noswap_splat_laneq_f16(__rev1_778, __p2_778)); \
- __ret_778 = __builtin_shufflevector(__ret_778, __ret_778, 3, 2, 1, 0); \
- __ret_778; \
-})
+__ai __attribute__((target("neon"))) poly8x8_t vzip1_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulxq_n_f16(__p0, __p1) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16_t __s1 = __p1; \
- __ret = vmulxq_f16(__s0, (float16x8_t) {__s1, __s1, __s1, __s1, __s1, __s1, __s1, __s1}); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x4_t vzip1_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ poly16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
+ return __ret;
+}
#else
-#define vmulxq_n_f16(__p0, __p1) __extension__ ({ \
- float16x8_t __ret; \
- float16x8_t __s0 = __p0; \
- float16_t __s1 = __p1; \
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret = __noswap_vmulxq_f16(__rev0, (float16x8_t) {__s1, __s1, __s1, __s1, __s1, __s1, __s1, __s1}); \
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly16x4_t vzip1_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ poly16x4_t __ret;
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmulx_n_f16(__p0, __p1) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16_t __s1 = __p1; \
- __ret = vmulx_f16(__s0, (float16x4_t) {__s1, __s1, __s1, __s1}); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x16_t vzip1q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
+ return __ret;
+}
#else
-#define vmulx_n_f16(__p0, __p1) __extension__ ({ \
- float16x4_t __ret; \
- float16x4_t __s0 = __p0; \
- float16_t __s1 = __p1; \
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
- __ret = __noswap_vmulx_f16(__rev0, (float16x4_t) {__s1, __s1, __s1, __s1}); \
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
- __ret; \
-})
+__ai __attribute__((target("neon"))) poly8x16_t vzip1q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly8x16_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vpaddq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vpaddq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+__ai __attribute__((target("neon"))) poly64x2_t vzip1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+ poly64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vpaddq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vpaddq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly64x2_t vzip1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+ poly64x2_t __ret;
+ poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vpmaxq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vpmaxq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+__ai __attribute__((target("neon"))) poly16x8_t vzip1q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+ poly16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vpmaxq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vpmaxq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+__ai __attribute__((target("neon"))) poly16x8_t vzip1q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+ poly16x8_t __ret;
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vpmaxnmq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vpmaxnmq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+__ai __attribute__((target("neon"))) uint8x16_t vzip1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vpmaxnmq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vpmaxnmq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x16_t vzip1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vpmaxnm_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vpmaxnm_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+__ai __attribute__((target("neon"))) uint32x4_t vzip1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vpmaxnm_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vpmaxnm_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+__ai __attribute__((target("neon"))) uint32x4_t vzip1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vpminq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vpminq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+__ai __attribute__((target("neon"))) uint64x2_t vzip1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vpminq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vpminq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint64x2_t vzip1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vpminnmq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vpminnmq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+__ai __attribute__((target("neon"))) uint16x8_t vzip1q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vpminnmq_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vpminnmq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+__ai __attribute__((target("neon"))) uint16x8_t vzip1q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vpminnm_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vpminnm_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+__ai __attribute__((target("neon"))) int8x16_t vzip1q_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vpminnm_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vpminnm_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int8x16_t vzip1q_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vrndiq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vrndiq_f16((int8x16_t)__p0, 40);
+__ai __attribute__((target("neon"))) float64x2_t vzip1q_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vrndiq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vrndiq_f16((int8x16_t)__rev0, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float64x2_t vzip1q_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vrndi_f16(float16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vrndi_f16((int8x8_t)__p0, 8);
+__ai __attribute__((target("neon"))) float32x4_t vzip1q_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vrndi_f16(float16x4_t __p0) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vrndi_f16((int8x8_t)__rev0, 8);
+__ai __attribute__((target("neon"))) float32x4_t vzip1q_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vsqrtq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- __ret = (float16x8_t) __builtin_neon_vsqrtq_f16((int8x16_t)__p0, 40);
+__ai __attribute__((target("neon"))) int32x4_t vzip1q_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vsqrtq_f16(float16x8_t __p0) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = (float16x8_t) __builtin_neon_vsqrtq_f16((int8x16_t)__rev0, 40);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x4_t vzip1q_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vsqrt_f16(float16x4_t __p0) {
- float16x4_t __ret;
- __ret = (float16x4_t) __builtin_neon_vsqrt_f16((int8x8_t)__p0, 8);
+__ai __attribute__((target("neon"))) int64x2_t vzip1q_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vsqrt_f16(float16x4_t __p0) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- __ret = (float16x4_t) __builtin_neon_vsqrt_f16((int8x8_t)__rev0, 8);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int64x2_t vzip1q_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vtrn1q_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
+__ai __attribute__((target("neon"))) int16x8_t vzip1q_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vtrn1q_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
+__ai __attribute__((target("neon"))) int16x8_t vzip1q_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vtrn1_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
+__ai __attribute__((target("neon"))) uint8x8_t vzip1_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vtrn1_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint8x8_t vzip1_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vtrn2q_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
+__ai __attribute__((target("neon"))) uint32x2_t vzip1_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vtrn2q_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) uint32x2_t vzip1_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vtrn2_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
+__ai __attribute__((target("neon"))) uint16x4_t vzip1_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vtrn2_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
+__ai __attribute__((target("neon"))) uint16x4_t vzip1_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vuzp1q_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
+__ai __attribute__((target("neon"))) int8x8_t vzip1_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vuzp1q_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
+__ai __attribute__((target("neon"))) int8x8_t vzip1_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vuzp1_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
+__ai __attribute__((target("neon"))) float32x2_t vzip1_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vuzp1_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) float32x2_t vzip1_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vuzp2q_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+__ai __attribute__((target("neon"))) int32x2_t vzip1_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vuzp2q_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
- __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) int32x2_t vzip1_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vuzp2_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
+__ai __attribute__((target("neon"))) int16x4_t vzip1_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vuzp2_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
- __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
+__ai __attribute__((target("neon"))) int16x4_t vzip1_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vzip1q_f16(float16x8_t __p0, float16x8_t __p1) {
+__ai __attribute__((target("neon"))) float16x8_t vzip1q_f16(float16x8_t __p0, float16x8_t __p1) {
float16x8_t __ret;
__ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vzip1q_f16(float16x8_t __p0, float16x8_t __p1) {
+__ai __attribute__((target("neon"))) float16x8_t vzip1q_f16(float16x8_t __p0, float16x8_t __p1) {
float16x8_t __ret;
float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -64457,13 +64017,13 @@ __ai __attribute__((target("fullfp16"))) float16x8_t vzip1q_f16(float16x8_t __p0
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vzip1_f16(float16x4_t __p0, float16x4_t __p1) {
+__ai __attribute__((target("neon"))) float16x4_t vzip1_f16(float16x4_t __p0, float16x4_t __p1) {
float16x4_t __ret;
__ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vzip1_f16(float16x4_t __p0, float16x4_t __p1) {
+__ai __attribute__((target("neon"))) float16x4_t vzip1_f16(float16x4_t __p0, float16x4_t __p1) {
float16x4_t __ret;
float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -64474,16 +64034,16 @@ __ai __attribute__((target("fullfp16"))) float16x4_t vzip1_f16(float16x4_t __p0,
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x8_t vzip2q_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
+__ai __attribute__((target("neon"))) poly8x8_t vzip2_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly8x8_t __ret;
__ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x8_t vzip2q_f16(float16x8_t __p0, float16x8_t __p1) {
- float16x8_t __ret;
- float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly8x8_t vzip2_p8(poly8x8_t __p0, poly8x8_t __p1) {
+ poly8x8_t __ret;
+ poly8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
__ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
@@ -64491,16 +64051,16 @@ __ai __attribute__((target("fullfp16"))) float16x8_t vzip2q_f16(float16x8_t __p0
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("fullfp16"))) float16x4_t vzip2_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
+__ai __attribute__((target("neon"))) poly16x4_t vzip2_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ poly16x4_t __ret;
__ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
return __ret;
}
#else
-__ai __attribute__((target("fullfp16"))) float16x4_t vzip2_f16(float16x4_t __p0, float16x4_t __p1) {
- float16x4_t __ret;
- float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
- float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+__ai __attribute__((target("neon"))) poly16x4_t vzip2_p16(poly16x4_t __p0, poly16x4_t __p1) {
+ poly16x4_t __ret;
+ poly16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ poly16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
__ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
@@ -64508,107 +64068,377 @@ __ai __attribute__((target("fullfp16"))) float16x4_t vzip2_f16(float16x4_t __p0,
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsudotq_laneq_s32(__p0_779, __p1_779, __p2_779, __p3_779) __extension__ ({ \
- int32x4_t __ret_779; \
- int32x4_t __s0_779 = __p0_779; \
- int8x16_t __s1_779 = __p1_779; \
- uint8x16_t __s2_779 = __p2_779; \
-uint8x16_t __reint_779 = __s2_779; \
- __ret_779 = vusdotq_s32(__s0_779, (uint8x16_t)(splatq_laneq_s32(*(int32x4_t *) &__reint_779, __p3_779)), __s1_779); \
- __ret_779; \
-})
+__ai __attribute__((target("neon"))) poly8x16_t vzip2q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+ return __ret;
+}
#else
-#define vsudotq_laneq_s32(__p0_780, __p1_780, __p2_780, __p3_780) __extension__ ({ \
- int32x4_t __ret_780; \
- int32x4_t __s0_780 = __p0_780; \
- int8x16_t __s1_780 = __p1_780; \
- uint8x16_t __s2_780 = __p2_780; \
- int32x4_t __rev0_780; __rev0_780 = __builtin_shufflevector(__s0_780, __s0_780, 3, 2, 1, 0); \
- int8x16_t __rev1_780; __rev1_780 = __builtin_shufflevector(__s1_780, __s1_780, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint8x16_t __rev2_780; __rev2_780 = __builtin_shufflevector(__s2_780, __s2_780, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
-uint8x16_t __reint_780 = __rev2_780; \
- __ret_780 = __noswap_vusdotq_s32(__rev0_780, (uint8x16_t)(__noswap_splatq_laneq_s32(*(int32x4_t *) &__reint_780, __p3_780)), __rev1_780); \
- __ret_780 = __builtin_shufflevector(__ret_780, __ret_780, 3, 2, 1, 0); \
- __ret_780; \
-})
+__ai __attribute__((target("neon"))) poly8x16_t vzip2q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+ poly8x16_t __ret;
+ poly8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsudot_laneq_s32(__p0_781, __p1_781, __p2_781, __p3_781) __extension__ ({ \
- int32x2_t __ret_781; \
- int32x2_t __s0_781 = __p0_781; \
- int8x8_t __s1_781 = __p1_781; \
- uint8x16_t __s2_781 = __p2_781; \
-uint8x16_t __reint_781 = __s2_781; \
- __ret_781 = vusdot_s32(__s0_781, (uint8x8_t)(splat_laneq_s32(*(int32x4_t *) &__reint_781, __p3_781)), __s1_781); \
- __ret_781; \
-})
+__ai __attribute__((target("neon"))) poly64x2_t vzip2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+ poly64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+ return __ret;
+}
#else
-#define vsudot_laneq_s32(__p0_782, __p1_782, __p2_782, __p3_782) __extension__ ({ \
- int32x2_t __ret_782; \
- int32x2_t __s0_782 = __p0_782; \
- int8x8_t __s1_782 = __p1_782; \
- uint8x16_t __s2_782 = __p2_782; \
- int32x2_t __rev0_782; __rev0_782 = __builtin_shufflevector(__s0_782, __s0_782, 1, 0); \
- int8x8_t __rev1_782; __rev1_782 = __builtin_shufflevector(__s1_782, __s1_782, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint8x16_t __rev2_782; __rev2_782 = __builtin_shufflevector(__s2_782, __s2_782, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
-uint8x16_t __reint_782 = __rev2_782; \
- __ret_782 = __noswap_vusdot_s32(__rev0_782, (uint8x8_t)(__noswap_splat_laneq_s32(*(int32x4_t *) &__reint_782, __p3_782)), __rev1_782); \
- __ret_782 = __builtin_shufflevector(__ret_782, __ret_782, 1, 0); \
- __ret_782; \
-})
+__ai __attribute__((target("neon"))) poly64x2_t vzip2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+ poly64x2_t __ret;
+ poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vusdotq_laneq_s32(__p0_783, __p1_783, __p2_783, __p3_783) __extension__ ({ \
- int32x4_t __ret_783; \
- int32x4_t __s0_783 = __p0_783; \
- uint8x16_t __s1_783 = __p1_783; \
- int8x16_t __s2_783 = __p2_783; \
-int8x16_t __reint_783 = __s2_783; \
- __ret_783 = vusdotq_s32(__s0_783, __s1_783, (int8x16_t)(splatq_laneq_s32(*(int32x4_t *) &__reint_783, __p3_783))); \
- __ret_783; \
-})
+__ai __attribute__((target("neon"))) poly16x8_t vzip2q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+ poly16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+ return __ret;
+}
#else
-#define vusdotq_laneq_s32(__p0_784, __p1_784, __p2_784, __p3_784) __extension__ ({ \
- int32x4_t __ret_784; \
- int32x4_t __s0_784 = __p0_784; \
- uint8x16_t __s1_784 = __p1_784; \
- int8x16_t __s2_784 = __p2_784; \
- int32x4_t __rev0_784; __rev0_784 = __builtin_shufflevector(__s0_784, __s0_784, 3, 2, 1, 0); \
- uint8x16_t __rev1_784; __rev1_784 = __builtin_shufflevector(__s1_784, __s1_784, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- int8x16_t __rev2_784; __rev2_784 = __builtin_shufflevector(__s2_784, __s2_784, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
-int8x16_t __reint_784 = __rev2_784; \
- __ret_784 = __noswap_vusdotq_s32(__rev0_784, __rev1_784, (int8x16_t)(__noswap_splatq_laneq_s32(*(int32x4_t *) &__reint_784, __p3_784))); \
- __ret_784 = __builtin_shufflevector(__ret_784, __ret_784, 3, 2, 1, 0); \
- __ret_784; \
-})
+__ai __attribute__((target("neon"))) poly16x8_t vzip2q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+ poly16x8_t __ret;
+ poly16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ poly16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#ifdef __LITTLE_ENDIAN__
-#define vusdot_laneq_s32(__p0_785, __p1_785, __p2_785, __p3_785) __extension__ ({ \
- int32x2_t __ret_785; \
- int32x2_t __s0_785 = __p0_785; \
- uint8x8_t __s1_785 = __p1_785; \
- int8x16_t __s2_785 = __p2_785; \
-int8x16_t __reint_785 = __s2_785; \
- __ret_785 = vusdot_s32(__s0_785, __s1_785, (int8x8_t)(splat_laneq_s32(*(int32x4_t *) &__reint_785, __p3_785))); \
- __ret_785; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vzip2q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+ return __ret;
+}
#else
-#define vusdot_laneq_s32(__p0_786, __p1_786, __p2_786, __p3_786) __extension__ ({ \
- int32x2_t __ret_786; \
- int32x2_t __s0_786 = __p0_786; \
- uint8x8_t __s1_786 = __p1_786; \
- int8x16_t __s2_786 = __p2_786; \
- int32x2_t __rev0_786; __rev0_786 = __builtin_shufflevector(__s0_786, __s0_786, 1, 0); \
- uint8x8_t __rev1_786; __rev1_786 = __builtin_shufflevector(__s1_786, __s1_786, 7, 6, 5, 4, 3, 2, 1, 0); \
- int8x16_t __rev2_786; __rev2_786 = __builtin_shufflevector(__s2_786, __s2_786, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
-int8x16_t __reint_786 = __rev2_786; \
- __ret_786 = __noswap_vusdot_s32(__rev0_786, __rev1_786, (int8x8_t)(__noswap_splat_laneq_s32(*(int32x4_t *) &__reint_786, __p3_786))); \
- __ret_786 = __builtin_shufflevector(__ret_786, __ret_786, 1, 0); \
- __ret_786; \
-})
+__ai __attribute__((target("neon"))) uint8x16_t vzip2q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+ uint8x16_t __ret;
+ uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vzip2q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vzip2q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+ uint32x4_t __ret;
+ uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vzip2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vzip2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+ uint64x2_t __ret;
+ uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vzip2q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vzip2q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+ uint16x8_t __ret;
+ uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vzip2q_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vzip2q_s8(int8x16_t __p0, int8x16_t __p1) {
+ int8x16_t __ret;
+ int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+ __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vzip2q_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vzip2q_f64(float64x2_t __p0, float64x2_t __p1) {
+ float64x2_t __ret;
+ float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vzip2q_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vzip2q_f32(float32x4_t __p0, float32x4_t __p1) {
+ float32x4_t __ret;
+ float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vzip2q_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vzip2q_s32(int32x4_t __p0, int32x4_t __p1) {
+ int32x4_t __ret;
+ int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vzip2q_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vzip2q_s64(int64x2_t __p0, int64x2_t __p1) {
+ int64x2_t __ret;
+ int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vzip2q_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vzip2q_s16(int16x8_t __p0, int16x8_t __p1) {
+ int16x8_t __ret;
+ int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vzip2_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vzip2_u8(uint8x8_t __p0, uint8x8_t __p1) {
+ uint8x8_t __ret;
+ uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vzip2_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vzip2_u32(uint32x2_t __p0, uint32x2_t __p1) {
+ uint32x2_t __ret;
+ uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vzip2_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vzip2_u16(uint16x4_t __p0, uint16x4_t __p1) {
+ uint16x4_t __ret;
+ uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vzip2_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vzip2_s8(int8x8_t __p0, int8x8_t __p1) {
+ int8x8_t __ret;
+ int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vzip2_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vzip2_f32(float32x2_t __p0, float32x2_t __p1) {
+ float32x2_t __ret;
+ float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ float32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vzip2_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vzip2_s32(int32x2_t __p0, int32x2_t __p1) {
+ int32x2_t __ret;
+ int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+ __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vzip2_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vzip2_s16(int16x4_t __p0, int16x4_t __p1) {
+ int16x4_t __ret;
+ int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x8_t vzip2q_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x8_t vzip2q_f16(float16x8_t __p0, float16x8_t __p1) {
+ float16x8_t __ret;
+ float16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ float16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+ __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x4_t vzip2_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+ return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x4_t vzip2_f16(float16x4_t __p0, float16x4_t __p1) {
+ float16x4_t __ret;
+ float16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+ float16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+ __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+ return __ret;
+}
#endif
#define vldap1_lane_p64(__p0, __p1, __p2) __extension__ ({ \
@@ -64776,13 +64606,13 @@ int8x16_t __reint_786 = __rev2_786; \
__builtin_neon_vstl1_lane_s64(__p0, (int8x8_t)__s1, __p2, 3); \
})
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) uint8x16_t vbcaxq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint8x16_t vbcaxq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint8x16_t __ret;
__ret = (uint8x16_t) __builtin_neon_vbcaxq_u8((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 48);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) uint8x16_t vbcaxq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint8x16_t vbcaxq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint8x16_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -64794,13 +64624,13 @@ __ai __attribute__((target("sha3"))) uint8x16_t vbcaxq_u8(uint8x16_t __p0, uint8
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) uint32x4_t vbcaxq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint32x4_t vbcaxq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vbcaxq_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) uint32x4_t vbcaxq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint32x4_t vbcaxq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -64812,13 +64642,13 @@ __ai __attribute__((target("sha3"))) uint32x4_t vbcaxq_u32(uint32x4_t __p0, uint
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) uint64x2_t vbcaxq_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vbcaxq_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
uint64x2_t __ret;
__ret = (uint64x2_t) __builtin_neon_vbcaxq_u64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 51);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) uint64x2_t vbcaxq_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vbcaxq_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -64830,13 +64660,13 @@ __ai __attribute__((target("sha3"))) uint64x2_t vbcaxq_u64(uint64x2_t __p0, uint
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) uint16x8_t vbcaxq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint16x8_t vbcaxq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
uint16x8_t __ret;
__ret = (uint16x8_t) __builtin_neon_vbcaxq_u16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 49);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) uint16x8_t vbcaxq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint16x8_t vbcaxq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -64848,13 +64678,13 @@ __ai __attribute__((target("sha3"))) uint16x8_t vbcaxq_u16(uint16x8_t __p0, uint
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) int8x16_t vbcaxq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
+__ai __attribute__((target("sha3,neon"))) int8x16_t vbcaxq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
int8x16_t __ret;
__ret = (int8x16_t) __builtin_neon_vbcaxq_s8((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 32);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) int8x16_t vbcaxq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
+__ai __attribute__((target("sha3,neon"))) int8x16_t vbcaxq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
int8x16_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -64866,13 +64696,13 @@ __ai __attribute__((target("sha3"))) int8x16_t vbcaxq_s8(int8x16_t __p0, int8x16
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) int32x4_t vbcaxq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+__ai __attribute__((target("sha3,neon"))) int32x4_t vbcaxq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
int32x4_t __ret;
__ret = (int32x4_t) __builtin_neon_vbcaxq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) int32x4_t vbcaxq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+__ai __attribute__((target("sha3,neon"))) int32x4_t vbcaxq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -64884,13 +64714,13 @@ __ai __attribute__((target("sha3"))) int32x4_t vbcaxq_s32(int32x4_t __p0, int32x
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) int64x2_t vbcaxq_s64(int64x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+__ai __attribute__((target("sha3,neon"))) int64x2_t vbcaxq_s64(int64x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
int64x2_t __ret;
__ret = (int64x2_t) __builtin_neon_vbcaxq_s64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 35);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) int64x2_t vbcaxq_s64(int64x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+__ai __attribute__((target("sha3,neon"))) int64x2_t vbcaxq_s64(int64x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
int64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -64902,13 +64732,13 @@ __ai __attribute__((target("sha3"))) int64x2_t vbcaxq_s64(int64x2_t __p0, int64x
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) int16x8_t vbcaxq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+__ai __attribute__((target("sha3,neon"))) int16x8_t vbcaxq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
int16x8_t __ret;
__ret = (int16x8_t) __builtin_neon_vbcaxq_s16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) int16x8_t vbcaxq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+__ai __attribute__((target("sha3,neon"))) int16x8_t vbcaxq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -64920,13 +64750,13 @@ __ai __attribute__((target("sha3"))) int16x8_t vbcaxq_s16(int16x8_t __p0, int16x
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) uint8x16_t veor3q_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint8x16_t veor3q_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint8x16_t __ret;
__ret = (uint8x16_t) __builtin_neon_veor3q_u8((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 48);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) uint8x16_t veor3q_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint8x16_t veor3q_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint8x16_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -64938,13 +64768,13 @@ __ai __attribute__((target("sha3"))) uint8x16_t veor3q_u8(uint8x16_t __p0, uint8
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) uint32x4_t veor3q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint32x4_t veor3q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_veor3q_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) uint32x4_t veor3q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint32x4_t veor3q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -64956,13 +64786,13 @@ __ai __attribute__((target("sha3"))) uint32x4_t veor3q_u32(uint32x4_t __p0, uint
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) uint64x2_t veor3q_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint64x2_t veor3q_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
uint64x2_t __ret;
__ret = (uint64x2_t) __builtin_neon_veor3q_u64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 51);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) uint64x2_t veor3q_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint64x2_t veor3q_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -64974,13 +64804,13 @@ __ai __attribute__((target("sha3"))) uint64x2_t veor3q_u64(uint64x2_t __p0, uint
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) uint16x8_t veor3q_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint16x8_t veor3q_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
uint16x8_t __ret;
__ret = (uint16x8_t) __builtin_neon_veor3q_u16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 49);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) uint16x8_t veor3q_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint16x8_t veor3q_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -64992,13 +64822,13 @@ __ai __attribute__((target("sha3"))) uint16x8_t veor3q_u16(uint16x8_t __p0, uint
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) int8x16_t veor3q_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
+__ai __attribute__((target("sha3,neon"))) int8x16_t veor3q_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
int8x16_t __ret;
__ret = (int8x16_t) __builtin_neon_veor3q_s8((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 32);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) int8x16_t veor3q_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
+__ai __attribute__((target("sha3,neon"))) int8x16_t veor3q_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
int8x16_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -65010,13 +64840,13 @@ __ai __attribute__((target("sha3"))) int8x16_t veor3q_s8(int8x16_t __p0, int8x16
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) int32x4_t veor3q_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+__ai __attribute__((target("sha3,neon"))) int32x4_t veor3q_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
int32x4_t __ret;
__ret = (int32x4_t) __builtin_neon_veor3q_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) int32x4_t veor3q_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+__ai __attribute__((target("sha3,neon"))) int32x4_t veor3q_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -65028,13 +64858,13 @@ __ai __attribute__((target("sha3"))) int32x4_t veor3q_s32(int32x4_t __p0, int32x
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) int64x2_t veor3q_s64(int64x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+__ai __attribute__((target("sha3,neon"))) int64x2_t veor3q_s64(int64x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
int64x2_t __ret;
__ret = (int64x2_t) __builtin_neon_veor3q_s64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 35);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) int64x2_t veor3q_s64(int64x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+__ai __attribute__((target("sha3,neon"))) int64x2_t veor3q_s64(int64x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
int64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -65046,13 +64876,13 @@ __ai __attribute__((target("sha3"))) int64x2_t veor3q_s64(int64x2_t __p0, int64x
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) int16x8_t veor3q_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+__ai __attribute__((target("sha3,neon"))) int16x8_t veor3q_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
int16x8_t __ret;
__ret = (int16x8_t) __builtin_neon_veor3q_s16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) int16x8_t veor3q_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+__ai __attribute__((target("sha3,neon"))) int16x8_t veor3q_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -65064,13 +64894,13 @@ __ai __attribute__((target("sha3"))) int16x8_t veor3q_s16(int16x8_t __p0, int16x
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) uint64x2_t vrax1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vrax1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
uint64x2_t __ret;
__ret = (uint64x2_t) __builtin_neon_vrax1q_u64((int8x16_t)__p0, (int8x16_t)__p1, 51);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) uint64x2_t vrax1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vrax1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -65081,13 +64911,13 @@ __ai __attribute__((target("sha3"))) uint64x2_t vrax1q_u64(uint64x2_t __p0, uint
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) uint64x2_t vsha512hq_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vsha512hq_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
uint64x2_t __ret;
__ret = (uint64x2_t) __builtin_neon_vsha512hq_u64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 51);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) uint64x2_t vsha512hq_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vsha512hq_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -65099,13 +64929,13 @@ __ai __attribute__((target("sha3"))) uint64x2_t vsha512hq_u64(uint64x2_t __p0, u
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) uint64x2_t vsha512h2q_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vsha512h2q_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
uint64x2_t __ret;
__ret = (uint64x2_t) __builtin_neon_vsha512h2q_u64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 51);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) uint64x2_t vsha512h2q_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vsha512h2q_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -65117,13 +64947,13 @@ __ai __attribute__((target("sha3"))) uint64x2_t vsha512h2q_u64(uint64x2_t __p0,
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) uint64x2_t vsha512su0q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vsha512su0q_u64(uint64x2_t __p0, uint64x2_t __p1) {
uint64x2_t __ret;
__ret = (uint64x2_t) __builtin_neon_vsha512su0q_u64((int8x16_t)__p0, (int8x16_t)__p1, 51);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) uint64x2_t vsha512su0q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vsha512su0q_u64(uint64x2_t __p0, uint64x2_t __p1) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -65134,13 +64964,13 @@ __ai __attribute__((target("sha3"))) uint64x2_t vsha512su0q_u64(uint64x2_t __p0,
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sha3"))) uint64x2_t vsha512su1q_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vsha512su1q_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
uint64x2_t __ret;
__ret = (uint64x2_t) __builtin_neon_vsha512su1q_u64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 51);
return __ret;
}
#else
-__ai __attribute__((target("sha3"))) uint64x2_t vsha512su1q_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vsha512su1q_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -65173,13 +65003,13 @@ __ai __attribute__((target("sha3"))) uint64x2_t vsha512su1q_u64(uint64x2_t __p0,
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sm4"))) uint32x4_t vsm3partw1q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm3partw1q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vsm3partw1q_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
return __ret;
}
#else
-__ai __attribute__((target("sm4"))) uint32x4_t vsm3partw1q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm3partw1q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -65191,13 +65021,13 @@ __ai __attribute__((target("sm4"))) uint32x4_t vsm3partw1q_u32(uint32x4_t __p0,
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sm4"))) uint32x4_t vsm3partw2q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm3partw2q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vsm3partw2q_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
return __ret;
}
#else
-__ai __attribute__((target("sm4"))) uint32x4_t vsm3partw2q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm3partw2q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -65209,13 +65039,13 @@ __ai __attribute__((target("sm4"))) uint32x4_t vsm3partw2q_u32(uint32x4_t __p0,
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sm4"))) uint32x4_t vsm3ss1q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm3ss1q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vsm3ss1q_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
return __ret;
}
#else
-__ai __attribute__((target("sm4"))) uint32x4_t vsm3ss1q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm3ss1q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -65323,13 +65153,13 @@ __ai __attribute__((target("sm4"))) uint32x4_t vsm3ss1q_u32(uint32x4_t __p0, uin
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sm4"))) uint32x4_t vsm4eq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm4eq_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vsm4eq_u32((int8x16_t)__p0, (int8x16_t)__p1, 50);
return __ret;
}
#else
-__ai __attribute__((target("sm4"))) uint32x4_t vsm4eq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm4eq_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -65340,13 +65170,13 @@ __ai __attribute__((target("sm4"))) uint32x4_t vsm4eq_u32(uint32x4_t __p0, uint3
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("sm4"))) uint32x4_t vsm4ekeyq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm4ekeyq_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
__ret = (uint32x4_t) __builtin_neon_vsm4ekeyq_u32((int8x16_t)__p0, (int8x16_t)__p1, 50);
return __ret;
}
#else
-__ai __attribute__((target("sm4"))) uint32x4_t vsm4ekeyq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm4ekeyq_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -65356,394 +65186,394 @@ __ai __attribute__((target("sm4"))) uint32x4_t vsm4ekeyq_u32(uint32x4_t __p0, ui
}
#endif
-__ai __attribute__((target("v8.1a"))) int32_t vqrdmlahs_s32(int32_t __p0, int32_t __p1, int32_t __p2) {
+__ai __attribute__((target("v8.1a,neon"))) int32_t vqrdmlahs_s32(int32_t __p0, int32_t __p1, int32_t __p2) {
int32_t __ret;
__ret = (int32_t) __builtin_neon_vqrdmlahs_s32(__p0, __p1, __p2);
return __ret;
}
-__ai __attribute__((target("v8.1a"))) int16_t vqrdmlahh_s16(int16_t __p0, int16_t __p1, int16_t __p2) {
+__ai __attribute__((target("v8.1a,neon"))) int16_t vqrdmlahh_s16(int16_t __p0, int16_t __p1, int16_t __p2) {
int16_t __ret;
__ret = (int16_t) __builtin_neon_vqrdmlahh_s16(__p0, __p1, __p2);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-#define vqrdmlahs_lane_s32(__p0_787, __p1_787, __p2_787, __p3_787) __extension__ ({ \
- int32_t __ret_787; \
- int32_t __s0_787 = __p0_787; \
- int32_t __s1_787 = __p1_787; \
- int32x2_t __s2_787 = __p2_787; \
- __ret_787 = vqrdmlahs_s32(__s0_787, __s1_787, vget_lane_s32(__s2_787, __p3_787)); \
- __ret_787; \
+#define vqrdmlahs_lane_s32(__p0_760, __p1_760, __p2_760, __p3_760) __extension__ ({ \
+ int32_t __ret_760; \
+ int32_t __s0_760 = __p0_760; \
+ int32_t __s1_760 = __p1_760; \
+ int32x2_t __s2_760 = __p2_760; \
+ __ret_760 = vqrdmlahs_s32(__s0_760, __s1_760, vget_lane_s32(__s2_760, __p3_760)); \
+ __ret_760; \
})
#else
-#define vqrdmlahs_lane_s32(__p0_788, __p1_788, __p2_788, __p3_788) __extension__ ({ \
- int32_t __ret_788; \
- int32_t __s0_788 = __p0_788; \
- int32_t __s1_788 = __p1_788; \
- int32x2_t __s2_788 = __p2_788; \
- int32x2_t __rev2_788; __rev2_788 = __builtin_shufflevector(__s2_788, __s2_788, 1, 0); \
- __ret_788 = vqrdmlahs_s32(__s0_788, __s1_788, __noswap_vget_lane_s32(__rev2_788, __p3_788)); \
- __ret_788; \
+#define vqrdmlahs_lane_s32(__p0_761, __p1_761, __p2_761, __p3_761) __extension__ ({ \
+ int32_t __ret_761; \
+ int32_t __s0_761 = __p0_761; \
+ int32_t __s1_761 = __p1_761; \
+ int32x2_t __s2_761 = __p2_761; \
+ int32x2_t __rev2_761; __rev2_761 = __builtin_shufflevector(__s2_761, __s2_761, 1, 0); \
+ __ret_761 = vqrdmlahs_s32(__s0_761, __s1_761, __noswap_vget_lane_s32(__rev2_761, __p3_761)); \
+ __ret_761; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmlahh_lane_s16(__p0_789, __p1_789, __p2_789, __p3_789) __extension__ ({ \
- int16_t __ret_789; \
- int16_t __s0_789 = __p0_789; \
- int16_t __s1_789 = __p1_789; \
- int16x4_t __s2_789 = __p2_789; \
- __ret_789 = vqrdmlahh_s16(__s0_789, __s1_789, vget_lane_s16(__s2_789, __p3_789)); \
- __ret_789; \
+#define vqrdmlahh_lane_s16(__p0_762, __p1_762, __p2_762, __p3_762) __extension__ ({ \
+ int16_t __ret_762; \
+ int16_t __s0_762 = __p0_762; \
+ int16_t __s1_762 = __p1_762; \
+ int16x4_t __s2_762 = __p2_762; \
+ __ret_762 = vqrdmlahh_s16(__s0_762, __s1_762, vget_lane_s16(__s2_762, __p3_762)); \
+ __ret_762; \
})
#else
-#define vqrdmlahh_lane_s16(__p0_790, __p1_790, __p2_790, __p3_790) __extension__ ({ \
- int16_t __ret_790; \
- int16_t __s0_790 = __p0_790; \
- int16_t __s1_790 = __p1_790; \
- int16x4_t __s2_790 = __p2_790; \
- int16x4_t __rev2_790; __rev2_790 = __builtin_shufflevector(__s2_790, __s2_790, 3, 2, 1, 0); \
- __ret_790 = vqrdmlahh_s16(__s0_790, __s1_790, __noswap_vget_lane_s16(__rev2_790, __p3_790)); \
- __ret_790; \
+#define vqrdmlahh_lane_s16(__p0_763, __p1_763, __p2_763, __p3_763) __extension__ ({ \
+ int16_t __ret_763; \
+ int16_t __s0_763 = __p0_763; \
+ int16_t __s1_763 = __p1_763; \
+ int16x4_t __s2_763 = __p2_763; \
+ int16x4_t __rev2_763; __rev2_763 = __builtin_shufflevector(__s2_763, __s2_763, 3, 2, 1, 0); \
+ __ret_763 = vqrdmlahh_s16(__s0_763, __s1_763, __noswap_vget_lane_s16(__rev2_763, __p3_763)); \
+ __ret_763; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmlahs_laneq_s32(__p0_791, __p1_791, __p2_791, __p3_791) __extension__ ({ \
- int32_t __ret_791; \
- int32_t __s0_791 = __p0_791; \
- int32_t __s1_791 = __p1_791; \
- int32x4_t __s2_791 = __p2_791; \
- __ret_791 = vqrdmlahs_s32(__s0_791, __s1_791, vgetq_lane_s32(__s2_791, __p3_791)); \
- __ret_791; \
+#define vqrdmlahs_laneq_s32(__p0_764, __p1_764, __p2_764, __p3_764) __extension__ ({ \
+ int32_t __ret_764; \
+ int32_t __s0_764 = __p0_764; \
+ int32_t __s1_764 = __p1_764; \
+ int32x4_t __s2_764 = __p2_764; \
+ __ret_764 = vqrdmlahs_s32(__s0_764, __s1_764, vgetq_lane_s32(__s2_764, __p3_764)); \
+ __ret_764; \
})
#else
-#define vqrdmlahs_laneq_s32(__p0_792, __p1_792, __p2_792, __p3_792) __extension__ ({ \
- int32_t __ret_792; \
- int32_t __s0_792 = __p0_792; \
- int32_t __s1_792 = __p1_792; \
- int32x4_t __s2_792 = __p2_792; \
- int32x4_t __rev2_792; __rev2_792 = __builtin_shufflevector(__s2_792, __s2_792, 3, 2, 1, 0); \
- __ret_792 = vqrdmlahs_s32(__s0_792, __s1_792, __noswap_vgetq_lane_s32(__rev2_792, __p3_792)); \
- __ret_792; \
+#define vqrdmlahs_laneq_s32(__p0_765, __p1_765, __p2_765, __p3_765) __extension__ ({ \
+ int32_t __ret_765; \
+ int32_t __s0_765 = __p0_765; \
+ int32_t __s1_765 = __p1_765; \
+ int32x4_t __s2_765 = __p2_765; \
+ int32x4_t __rev2_765; __rev2_765 = __builtin_shufflevector(__s2_765, __s2_765, 3, 2, 1, 0); \
+ __ret_765 = vqrdmlahs_s32(__s0_765, __s1_765, __noswap_vgetq_lane_s32(__rev2_765, __p3_765)); \
+ __ret_765; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmlahh_laneq_s16(__p0_793, __p1_793, __p2_793, __p3_793) __extension__ ({ \
- int16_t __ret_793; \
- int16_t __s0_793 = __p0_793; \
- int16_t __s1_793 = __p1_793; \
- int16x8_t __s2_793 = __p2_793; \
- __ret_793 = vqrdmlahh_s16(__s0_793, __s1_793, vgetq_lane_s16(__s2_793, __p3_793)); \
- __ret_793; \
+#define vqrdmlahh_laneq_s16(__p0_766, __p1_766, __p2_766, __p3_766) __extension__ ({ \
+ int16_t __ret_766; \
+ int16_t __s0_766 = __p0_766; \
+ int16_t __s1_766 = __p1_766; \
+ int16x8_t __s2_766 = __p2_766; \
+ __ret_766 = vqrdmlahh_s16(__s0_766, __s1_766, vgetq_lane_s16(__s2_766, __p3_766)); \
+ __ret_766; \
})
#else
-#define vqrdmlahh_laneq_s16(__p0_794, __p1_794, __p2_794, __p3_794) __extension__ ({ \
- int16_t __ret_794; \
- int16_t __s0_794 = __p0_794; \
- int16_t __s1_794 = __p1_794; \
- int16x8_t __s2_794 = __p2_794; \
- int16x8_t __rev2_794; __rev2_794 = __builtin_shufflevector(__s2_794, __s2_794, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_794 = vqrdmlahh_s16(__s0_794, __s1_794, __noswap_vgetq_lane_s16(__rev2_794, __p3_794)); \
- __ret_794; \
+#define vqrdmlahh_laneq_s16(__p0_767, __p1_767, __p2_767, __p3_767) __extension__ ({ \
+ int16_t __ret_767; \
+ int16_t __s0_767 = __p0_767; \
+ int16_t __s1_767 = __p1_767; \
+ int16x8_t __s2_767 = __p2_767; \
+ int16x8_t __rev2_767; __rev2_767 = __builtin_shufflevector(__s2_767, __s2_767, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_767 = vqrdmlahh_s16(__s0_767, __s1_767, __noswap_vgetq_lane_s16(__rev2_767, __p3_767)); \
+ __ret_767; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmlahq_laneq_s32(__p0_795, __p1_795, __p2_795, __p3_795) __extension__ ({ \
- int32x4_t __ret_795; \
- int32x4_t __s0_795 = __p0_795; \
- int32x4_t __s1_795 = __p1_795; \
- int32x4_t __s2_795 = __p2_795; \
- __ret_795 = vqrdmlahq_s32(__s0_795, __s1_795, splatq_laneq_s32(__s2_795, __p3_795)); \
- __ret_795; \
+#define vqrdmlahq_laneq_s32(__p0_768, __p1_768, __p2_768, __p3_768) __extension__ ({ \
+ int32x4_t __ret_768; \
+ int32x4_t __s0_768 = __p0_768; \
+ int32x4_t __s1_768 = __p1_768; \
+ int32x4_t __s2_768 = __p2_768; \
+ __ret_768 = vqrdmlahq_s32(__s0_768, __s1_768, splatq_laneq_s32(__s2_768, __p3_768)); \
+ __ret_768; \
})
#else
-#define vqrdmlahq_laneq_s32(__p0_796, __p1_796, __p2_796, __p3_796) __extension__ ({ \
- int32x4_t __ret_796; \
- int32x4_t __s0_796 = __p0_796; \
- int32x4_t __s1_796 = __p1_796; \
- int32x4_t __s2_796 = __p2_796; \
- int32x4_t __rev0_796; __rev0_796 = __builtin_shufflevector(__s0_796, __s0_796, 3, 2, 1, 0); \
- int32x4_t __rev1_796; __rev1_796 = __builtin_shufflevector(__s1_796, __s1_796, 3, 2, 1, 0); \
- int32x4_t __rev2_796; __rev2_796 = __builtin_shufflevector(__s2_796, __s2_796, 3, 2, 1, 0); \
- __ret_796 = __noswap_vqrdmlahq_s32(__rev0_796, __rev1_796, __noswap_splatq_laneq_s32(__rev2_796, __p3_796)); \
- __ret_796 = __builtin_shufflevector(__ret_796, __ret_796, 3, 2, 1, 0); \
- __ret_796; \
+#define vqrdmlahq_laneq_s32(__p0_769, __p1_769, __p2_769, __p3_769) __extension__ ({ \
+ int32x4_t __ret_769; \
+ int32x4_t __s0_769 = __p0_769; \
+ int32x4_t __s1_769 = __p1_769; \
+ int32x4_t __s2_769 = __p2_769; \
+ int32x4_t __rev0_769; __rev0_769 = __builtin_shufflevector(__s0_769, __s0_769, 3, 2, 1, 0); \
+ int32x4_t __rev1_769; __rev1_769 = __builtin_shufflevector(__s1_769, __s1_769, 3, 2, 1, 0); \
+ int32x4_t __rev2_769; __rev2_769 = __builtin_shufflevector(__s2_769, __s2_769, 3, 2, 1, 0); \
+ __ret_769 = __noswap_vqrdmlahq_s32(__rev0_769, __rev1_769, __noswap_splatq_laneq_s32(__rev2_769, __p3_769)); \
+ __ret_769 = __builtin_shufflevector(__ret_769, __ret_769, 3, 2, 1, 0); \
+ __ret_769; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmlahq_laneq_s16(__p0_797, __p1_797, __p2_797, __p3_797) __extension__ ({ \
- int16x8_t __ret_797; \
- int16x8_t __s0_797 = __p0_797; \
- int16x8_t __s1_797 = __p1_797; \
- int16x8_t __s2_797 = __p2_797; \
- __ret_797 = vqrdmlahq_s16(__s0_797, __s1_797, splatq_laneq_s16(__s2_797, __p3_797)); \
- __ret_797; \
+#define vqrdmlahq_laneq_s16(__p0_770, __p1_770, __p2_770, __p3_770) __extension__ ({ \
+ int16x8_t __ret_770; \
+ int16x8_t __s0_770 = __p0_770; \
+ int16x8_t __s1_770 = __p1_770; \
+ int16x8_t __s2_770 = __p2_770; \
+ __ret_770 = vqrdmlahq_s16(__s0_770, __s1_770, splatq_laneq_s16(__s2_770, __p3_770)); \
+ __ret_770; \
})
#else
-#define vqrdmlahq_laneq_s16(__p0_798, __p1_798, __p2_798, __p3_798) __extension__ ({ \
- int16x8_t __ret_798; \
- int16x8_t __s0_798 = __p0_798; \
- int16x8_t __s1_798 = __p1_798; \
- int16x8_t __s2_798 = __p2_798; \
- int16x8_t __rev0_798; __rev0_798 = __builtin_shufflevector(__s0_798, __s0_798, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1_798; __rev1_798 = __builtin_shufflevector(__s1_798, __s1_798, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev2_798; __rev2_798 = __builtin_shufflevector(__s2_798, __s2_798, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_798 = __noswap_vqrdmlahq_s16(__rev0_798, __rev1_798, __noswap_splatq_laneq_s16(__rev2_798, __p3_798)); \
- __ret_798 = __builtin_shufflevector(__ret_798, __ret_798, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_798; \
+#define vqrdmlahq_laneq_s16(__p0_771, __p1_771, __p2_771, __p3_771) __extension__ ({ \
+ int16x8_t __ret_771; \
+ int16x8_t __s0_771 = __p0_771; \
+ int16x8_t __s1_771 = __p1_771; \
+ int16x8_t __s2_771 = __p2_771; \
+ int16x8_t __rev0_771; __rev0_771 = __builtin_shufflevector(__s0_771, __s0_771, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1_771; __rev1_771 = __builtin_shufflevector(__s1_771, __s1_771, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev2_771; __rev2_771 = __builtin_shufflevector(__s2_771, __s2_771, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_771 = __noswap_vqrdmlahq_s16(__rev0_771, __rev1_771, __noswap_splatq_laneq_s16(__rev2_771, __p3_771)); \
+ __ret_771 = __builtin_shufflevector(__ret_771, __ret_771, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_771; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmlah_laneq_s32(__p0_799, __p1_799, __p2_799, __p3_799) __extension__ ({ \
- int32x2_t __ret_799; \
- int32x2_t __s0_799 = __p0_799; \
- int32x2_t __s1_799 = __p1_799; \
- int32x4_t __s2_799 = __p2_799; \
- __ret_799 = vqrdmlah_s32(__s0_799, __s1_799, splat_laneq_s32(__s2_799, __p3_799)); \
- __ret_799; \
+#define vqrdmlah_laneq_s32(__p0_772, __p1_772, __p2_772, __p3_772) __extension__ ({ \
+ int32x2_t __ret_772; \
+ int32x2_t __s0_772 = __p0_772; \
+ int32x2_t __s1_772 = __p1_772; \
+ int32x4_t __s2_772 = __p2_772; \
+ __ret_772 = vqrdmlah_s32(__s0_772, __s1_772, splat_laneq_s32(__s2_772, __p3_772)); \
+ __ret_772; \
})
#else
-#define vqrdmlah_laneq_s32(__p0_800, __p1_800, __p2_800, __p3_800) __extension__ ({ \
- int32x2_t __ret_800; \
- int32x2_t __s0_800 = __p0_800; \
- int32x2_t __s1_800 = __p1_800; \
- int32x4_t __s2_800 = __p2_800; \
- int32x2_t __rev0_800; __rev0_800 = __builtin_shufflevector(__s0_800, __s0_800, 1, 0); \
- int32x2_t __rev1_800; __rev1_800 = __builtin_shufflevector(__s1_800, __s1_800, 1, 0); \
- int32x4_t __rev2_800; __rev2_800 = __builtin_shufflevector(__s2_800, __s2_800, 3, 2, 1, 0); \
- __ret_800 = __noswap_vqrdmlah_s32(__rev0_800, __rev1_800, __noswap_splat_laneq_s32(__rev2_800, __p3_800)); \
- __ret_800 = __builtin_shufflevector(__ret_800, __ret_800, 1, 0); \
- __ret_800; \
+#define vqrdmlah_laneq_s32(__p0_773, __p1_773, __p2_773, __p3_773) __extension__ ({ \
+ int32x2_t __ret_773; \
+ int32x2_t __s0_773 = __p0_773; \
+ int32x2_t __s1_773 = __p1_773; \
+ int32x4_t __s2_773 = __p2_773; \
+ int32x2_t __rev0_773; __rev0_773 = __builtin_shufflevector(__s0_773, __s0_773, 1, 0); \
+ int32x2_t __rev1_773; __rev1_773 = __builtin_shufflevector(__s1_773, __s1_773, 1, 0); \
+ int32x4_t __rev2_773; __rev2_773 = __builtin_shufflevector(__s2_773, __s2_773, 3, 2, 1, 0); \
+ __ret_773 = __noswap_vqrdmlah_s32(__rev0_773, __rev1_773, __noswap_splat_laneq_s32(__rev2_773, __p3_773)); \
+ __ret_773 = __builtin_shufflevector(__ret_773, __ret_773, 1, 0); \
+ __ret_773; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmlah_laneq_s16(__p0_801, __p1_801, __p2_801, __p3_801) __extension__ ({ \
- int16x4_t __ret_801; \
- int16x4_t __s0_801 = __p0_801; \
- int16x4_t __s1_801 = __p1_801; \
- int16x8_t __s2_801 = __p2_801; \
- __ret_801 = vqrdmlah_s16(__s0_801, __s1_801, splat_laneq_s16(__s2_801, __p3_801)); \
- __ret_801; \
+#define vqrdmlah_laneq_s16(__p0_774, __p1_774, __p2_774, __p3_774) __extension__ ({ \
+ int16x4_t __ret_774; \
+ int16x4_t __s0_774 = __p0_774; \
+ int16x4_t __s1_774 = __p1_774; \
+ int16x8_t __s2_774 = __p2_774; \
+ __ret_774 = vqrdmlah_s16(__s0_774, __s1_774, splat_laneq_s16(__s2_774, __p3_774)); \
+ __ret_774; \
})
#else
-#define vqrdmlah_laneq_s16(__p0_802, __p1_802, __p2_802, __p3_802) __extension__ ({ \
- int16x4_t __ret_802; \
- int16x4_t __s0_802 = __p0_802; \
- int16x4_t __s1_802 = __p1_802; \
- int16x8_t __s2_802 = __p2_802; \
- int16x4_t __rev0_802; __rev0_802 = __builtin_shufflevector(__s0_802, __s0_802, 3, 2, 1, 0); \
- int16x4_t __rev1_802; __rev1_802 = __builtin_shufflevector(__s1_802, __s1_802, 3, 2, 1, 0); \
- int16x8_t __rev2_802; __rev2_802 = __builtin_shufflevector(__s2_802, __s2_802, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_802 = __noswap_vqrdmlah_s16(__rev0_802, __rev1_802, __noswap_splat_laneq_s16(__rev2_802, __p3_802)); \
- __ret_802 = __builtin_shufflevector(__ret_802, __ret_802, 3, 2, 1, 0); \
- __ret_802; \
+#define vqrdmlah_laneq_s16(__p0_775, __p1_775, __p2_775, __p3_775) __extension__ ({ \
+ int16x4_t __ret_775; \
+ int16x4_t __s0_775 = __p0_775; \
+ int16x4_t __s1_775 = __p1_775; \
+ int16x8_t __s2_775 = __p2_775; \
+ int16x4_t __rev0_775; __rev0_775 = __builtin_shufflevector(__s0_775, __s0_775, 3, 2, 1, 0); \
+ int16x4_t __rev1_775; __rev1_775 = __builtin_shufflevector(__s1_775, __s1_775, 3, 2, 1, 0); \
+ int16x8_t __rev2_775; __rev2_775 = __builtin_shufflevector(__s2_775, __s2_775, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_775 = __noswap_vqrdmlah_s16(__rev0_775, __rev1_775, __noswap_splat_laneq_s16(__rev2_775, __p3_775)); \
+ __ret_775 = __builtin_shufflevector(__ret_775, __ret_775, 3, 2, 1, 0); \
+ __ret_775; \
})
#endif
-__ai __attribute__((target("v8.1a"))) int32_t vqrdmlshs_s32(int32_t __p0, int32_t __p1, int32_t __p2) {
+__ai __attribute__((target("v8.1a,neon"))) int32_t vqrdmlshs_s32(int32_t __p0, int32_t __p1, int32_t __p2) {
int32_t __ret;
__ret = (int32_t) __builtin_neon_vqrdmlshs_s32(__p0, __p1, __p2);
return __ret;
}
-__ai __attribute__((target("v8.1a"))) int16_t vqrdmlshh_s16(int16_t __p0, int16_t __p1, int16_t __p2) {
+__ai __attribute__((target("v8.1a,neon"))) int16_t vqrdmlshh_s16(int16_t __p0, int16_t __p1, int16_t __p2) {
int16_t __ret;
__ret = (int16_t) __builtin_neon_vqrdmlshh_s16(__p0, __p1, __p2);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-#define vqrdmlshs_lane_s32(__p0_803, __p1_803, __p2_803, __p3_803) __extension__ ({ \
- int32_t __ret_803; \
- int32_t __s0_803 = __p0_803; \
- int32_t __s1_803 = __p1_803; \
- int32x2_t __s2_803 = __p2_803; \
- __ret_803 = vqrdmlshs_s32(__s0_803, __s1_803, vget_lane_s32(__s2_803, __p3_803)); \
- __ret_803; \
+#define vqrdmlshs_lane_s32(__p0_776, __p1_776, __p2_776, __p3_776) __extension__ ({ \
+ int32_t __ret_776; \
+ int32_t __s0_776 = __p0_776; \
+ int32_t __s1_776 = __p1_776; \
+ int32x2_t __s2_776 = __p2_776; \
+ __ret_776 = vqrdmlshs_s32(__s0_776, __s1_776, vget_lane_s32(__s2_776, __p3_776)); \
+ __ret_776; \
})
#else
-#define vqrdmlshs_lane_s32(__p0_804, __p1_804, __p2_804, __p3_804) __extension__ ({ \
- int32_t __ret_804; \
- int32_t __s0_804 = __p0_804; \
- int32_t __s1_804 = __p1_804; \
- int32x2_t __s2_804 = __p2_804; \
- int32x2_t __rev2_804; __rev2_804 = __builtin_shufflevector(__s2_804, __s2_804, 1, 0); \
- __ret_804 = vqrdmlshs_s32(__s0_804, __s1_804, __noswap_vget_lane_s32(__rev2_804, __p3_804)); \
- __ret_804; \
+#define vqrdmlshs_lane_s32(__p0_777, __p1_777, __p2_777, __p3_777) __extension__ ({ \
+ int32_t __ret_777; \
+ int32_t __s0_777 = __p0_777; \
+ int32_t __s1_777 = __p1_777; \
+ int32x2_t __s2_777 = __p2_777; \
+ int32x2_t __rev2_777; __rev2_777 = __builtin_shufflevector(__s2_777, __s2_777, 1, 0); \
+ __ret_777 = vqrdmlshs_s32(__s0_777, __s1_777, __noswap_vget_lane_s32(__rev2_777, __p3_777)); \
+ __ret_777; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmlshh_lane_s16(__p0_805, __p1_805, __p2_805, __p3_805) __extension__ ({ \
- int16_t __ret_805; \
- int16_t __s0_805 = __p0_805; \
- int16_t __s1_805 = __p1_805; \
- int16x4_t __s2_805 = __p2_805; \
- __ret_805 = vqrdmlshh_s16(__s0_805, __s1_805, vget_lane_s16(__s2_805, __p3_805)); \
- __ret_805; \
+#define vqrdmlshh_lane_s16(__p0_778, __p1_778, __p2_778, __p3_778) __extension__ ({ \
+ int16_t __ret_778; \
+ int16_t __s0_778 = __p0_778; \
+ int16_t __s1_778 = __p1_778; \
+ int16x4_t __s2_778 = __p2_778; \
+ __ret_778 = vqrdmlshh_s16(__s0_778, __s1_778, vget_lane_s16(__s2_778, __p3_778)); \
+ __ret_778; \
})
#else
-#define vqrdmlshh_lane_s16(__p0_806, __p1_806, __p2_806, __p3_806) __extension__ ({ \
- int16_t __ret_806; \
- int16_t __s0_806 = __p0_806; \
- int16_t __s1_806 = __p1_806; \
- int16x4_t __s2_806 = __p2_806; \
- int16x4_t __rev2_806; __rev2_806 = __builtin_shufflevector(__s2_806, __s2_806, 3, 2, 1, 0); \
- __ret_806 = vqrdmlshh_s16(__s0_806, __s1_806, __noswap_vget_lane_s16(__rev2_806, __p3_806)); \
- __ret_806; \
+#define vqrdmlshh_lane_s16(__p0_779, __p1_779, __p2_779, __p3_779) __extension__ ({ \
+ int16_t __ret_779; \
+ int16_t __s0_779 = __p0_779; \
+ int16_t __s1_779 = __p1_779; \
+ int16x4_t __s2_779 = __p2_779; \
+ int16x4_t __rev2_779; __rev2_779 = __builtin_shufflevector(__s2_779, __s2_779, 3, 2, 1, 0); \
+ __ret_779 = vqrdmlshh_s16(__s0_779, __s1_779, __noswap_vget_lane_s16(__rev2_779, __p3_779)); \
+ __ret_779; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmlshs_laneq_s32(__p0_807, __p1_807, __p2_807, __p3_807) __extension__ ({ \
- int32_t __ret_807; \
- int32_t __s0_807 = __p0_807; \
- int32_t __s1_807 = __p1_807; \
- int32x4_t __s2_807 = __p2_807; \
- __ret_807 = vqrdmlshs_s32(__s0_807, __s1_807, vgetq_lane_s32(__s2_807, __p3_807)); \
- __ret_807; \
+#define vqrdmlshs_laneq_s32(__p0_780, __p1_780, __p2_780, __p3_780) __extension__ ({ \
+ int32_t __ret_780; \
+ int32_t __s0_780 = __p0_780; \
+ int32_t __s1_780 = __p1_780; \
+ int32x4_t __s2_780 = __p2_780; \
+ __ret_780 = vqrdmlshs_s32(__s0_780, __s1_780, vgetq_lane_s32(__s2_780, __p3_780)); \
+ __ret_780; \
})
#else
-#define vqrdmlshs_laneq_s32(__p0_808, __p1_808, __p2_808, __p3_808) __extension__ ({ \
- int32_t __ret_808; \
- int32_t __s0_808 = __p0_808; \
- int32_t __s1_808 = __p1_808; \
- int32x4_t __s2_808 = __p2_808; \
- int32x4_t __rev2_808; __rev2_808 = __builtin_shufflevector(__s2_808, __s2_808, 3, 2, 1, 0); \
- __ret_808 = vqrdmlshs_s32(__s0_808, __s1_808, __noswap_vgetq_lane_s32(__rev2_808, __p3_808)); \
- __ret_808; \
+#define vqrdmlshs_laneq_s32(__p0_781, __p1_781, __p2_781, __p3_781) __extension__ ({ \
+ int32_t __ret_781; \
+ int32_t __s0_781 = __p0_781; \
+ int32_t __s1_781 = __p1_781; \
+ int32x4_t __s2_781 = __p2_781; \
+ int32x4_t __rev2_781; __rev2_781 = __builtin_shufflevector(__s2_781, __s2_781, 3, 2, 1, 0); \
+ __ret_781 = vqrdmlshs_s32(__s0_781, __s1_781, __noswap_vgetq_lane_s32(__rev2_781, __p3_781)); \
+ __ret_781; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmlshh_laneq_s16(__p0_809, __p1_809, __p2_809, __p3_809) __extension__ ({ \
- int16_t __ret_809; \
- int16_t __s0_809 = __p0_809; \
- int16_t __s1_809 = __p1_809; \
- int16x8_t __s2_809 = __p2_809; \
- __ret_809 = vqrdmlshh_s16(__s0_809, __s1_809, vgetq_lane_s16(__s2_809, __p3_809)); \
- __ret_809; \
+#define vqrdmlshh_laneq_s16(__p0_782, __p1_782, __p2_782, __p3_782) __extension__ ({ \
+ int16_t __ret_782; \
+ int16_t __s0_782 = __p0_782; \
+ int16_t __s1_782 = __p1_782; \
+ int16x8_t __s2_782 = __p2_782; \
+ __ret_782 = vqrdmlshh_s16(__s0_782, __s1_782, vgetq_lane_s16(__s2_782, __p3_782)); \
+ __ret_782; \
})
#else
-#define vqrdmlshh_laneq_s16(__p0_810, __p1_810, __p2_810, __p3_810) __extension__ ({ \
- int16_t __ret_810; \
- int16_t __s0_810 = __p0_810; \
- int16_t __s1_810 = __p1_810; \
- int16x8_t __s2_810 = __p2_810; \
- int16x8_t __rev2_810; __rev2_810 = __builtin_shufflevector(__s2_810, __s2_810, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_810 = vqrdmlshh_s16(__s0_810, __s1_810, __noswap_vgetq_lane_s16(__rev2_810, __p3_810)); \
- __ret_810; \
+#define vqrdmlshh_laneq_s16(__p0_783, __p1_783, __p2_783, __p3_783) __extension__ ({ \
+ int16_t __ret_783; \
+ int16_t __s0_783 = __p0_783; \
+ int16_t __s1_783 = __p1_783; \
+ int16x8_t __s2_783 = __p2_783; \
+ int16x8_t __rev2_783; __rev2_783 = __builtin_shufflevector(__s2_783, __s2_783, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_783 = vqrdmlshh_s16(__s0_783, __s1_783, __noswap_vgetq_lane_s16(__rev2_783, __p3_783)); \
+ __ret_783; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmlshq_laneq_s32(__p0_811, __p1_811, __p2_811, __p3_811) __extension__ ({ \
- int32x4_t __ret_811; \
- int32x4_t __s0_811 = __p0_811; \
- int32x4_t __s1_811 = __p1_811; \
- int32x4_t __s2_811 = __p2_811; \
- __ret_811 = vqrdmlshq_s32(__s0_811, __s1_811, splatq_laneq_s32(__s2_811, __p3_811)); \
- __ret_811; \
+#define vqrdmlshq_laneq_s32(__p0_784, __p1_784, __p2_784, __p3_784) __extension__ ({ \
+ int32x4_t __ret_784; \
+ int32x4_t __s0_784 = __p0_784; \
+ int32x4_t __s1_784 = __p1_784; \
+ int32x4_t __s2_784 = __p2_784; \
+ __ret_784 = vqrdmlshq_s32(__s0_784, __s1_784, splatq_laneq_s32(__s2_784, __p3_784)); \
+ __ret_784; \
})
#else
-#define vqrdmlshq_laneq_s32(__p0_812, __p1_812, __p2_812, __p3_812) __extension__ ({ \
- int32x4_t __ret_812; \
- int32x4_t __s0_812 = __p0_812; \
- int32x4_t __s1_812 = __p1_812; \
- int32x4_t __s2_812 = __p2_812; \
- int32x4_t __rev0_812; __rev0_812 = __builtin_shufflevector(__s0_812, __s0_812, 3, 2, 1, 0); \
- int32x4_t __rev1_812; __rev1_812 = __builtin_shufflevector(__s1_812, __s1_812, 3, 2, 1, 0); \
- int32x4_t __rev2_812; __rev2_812 = __builtin_shufflevector(__s2_812, __s2_812, 3, 2, 1, 0); \
- __ret_812 = __noswap_vqrdmlshq_s32(__rev0_812, __rev1_812, __noswap_splatq_laneq_s32(__rev2_812, __p3_812)); \
- __ret_812 = __builtin_shufflevector(__ret_812, __ret_812, 3, 2, 1, 0); \
- __ret_812; \
+#define vqrdmlshq_laneq_s32(__p0_785, __p1_785, __p2_785, __p3_785) __extension__ ({ \
+ int32x4_t __ret_785; \
+ int32x4_t __s0_785 = __p0_785; \
+ int32x4_t __s1_785 = __p1_785; \
+ int32x4_t __s2_785 = __p2_785; \
+ int32x4_t __rev0_785; __rev0_785 = __builtin_shufflevector(__s0_785, __s0_785, 3, 2, 1, 0); \
+ int32x4_t __rev1_785; __rev1_785 = __builtin_shufflevector(__s1_785, __s1_785, 3, 2, 1, 0); \
+ int32x4_t __rev2_785; __rev2_785 = __builtin_shufflevector(__s2_785, __s2_785, 3, 2, 1, 0); \
+ __ret_785 = __noswap_vqrdmlshq_s32(__rev0_785, __rev1_785, __noswap_splatq_laneq_s32(__rev2_785, __p3_785)); \
+ __ret_785 = __builtin_shufflevector(__ret_785, __ret_785, 3, 2, 1, 0); \
+ __ret_785; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmlshq_laneq_s16(__p0_813, __p1_813, __p2_813, __p3_813) __extension__ ({ \
- int16x8_t __ret_813; \
- int16x8_t __s0_813 = __p0_813; \
- int16x8_t __s1_813 = __p1_813; \
- int16x8_t __s2_813 = __p2_813; \
- __ret_813 = vqrdmlshq_s16(__s0_813, __s1_813, splatq_laneq_s16(__s2_813, __p3_813)); \
- __ret_813; \
+#define vqrdmlshq_laneq_s16(__p0_786, __p1_786, __p2_786, __p3_786) __extension__ ({ \
+ int16x8_t __ret_786; \
+ int16x8_t __s0_786 = __p0_786; \
+ int16x8_t __s1_786 = __p1_786; \
+ int16x8_t __s2_786 = __p2_786; \
+ __ret_786 = vqrdmlshq_s16(__s0_786, __s1_786, splatq_laneq_s16(__s2_786, __p3_786)); \
+ __ret_786; \
})
#else
-#define vqrdmlshq_laneq_s16(__p0_814, __p1_814, __p2_814, __p3_814) __extension__ ({ \
- int16x8_t __ret_814; \
- int16x8_t __s0_814 = __p0_814; \
- int16x8_t __s1_814 = __p1_814; \
- int16x8_t __s2_814 = __p2_814; \
- int16x8_t __rev0_814; __rev0_814 = __builtin_shufflevector(__s0_814, __s0_814, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev1_814; __rev1_814 = __builtin_shufflevector(__s1_814, __s1_814, 7, 6, 5, 4, 3, 2, 1, 0); \
- int16x8_t __rev2_814; __rev2_814 = __builtin_shufflevector(__s2_814, __s2_814, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_814 = __noswap_vqrdmlshq_s16(__rev0_814, __rev1_814, __noswap_splatq_laneq_s16(__rev2_814, __p3_814)); \
- __ret_814 = __builtin_shufflevector(__ret_814, __ret_814, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_814; \
+#define vqrdmlshq_laneq_s16(__p0_787, __p1_787, __p2_787, __p3_787) __extension__ ({ \
+ int16x8_t __ret_787; \
+ int16x8_t __s0_787 = __p0_787; \
+ int16x8_t __s1_787 = __p1_787; \
+ int16x8_t __s2_787 = __p2_787; \
+ int16x8_t __rev0_787; __rev0_787 = __builtin_shufflevector(__s0_787, __s0_787, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev1_787; __rev1_787 = __builtin_shufflevector(__s1_787, __s1_787, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int16x8_t __rev2_787; __rev2_787 = __builtin_shufflevector(__s2_787, __s2_787, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_787 = __noswap_vqrdmlshq_s16(__rev0_787, __rev1_787, __noswap_splatq_laneq_s16(__rev2_787, __p3_787)); \
+ __ret_787 = __builtin_shufflevector(__ret_787, __ret_787, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_787; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmlsh_laneq_s32(__p0_815, __p1_815, __p2_815, __p3_815) __extension__ ({ \
- int32x2_t __ret_815; \
- int32x2_t __s0_815 = __p0_815; \
- int32x2_t __s1_815 = __p1_815; \
- int32x4_t __s2_815 = __p2_815; \
- __ret_815 = vqrdmlsh_s32(__s0_815, __s1_815, splat_laneq_s32(__s2_815, __p3_815)); \
- __ret_815; \
+#define vqrdmlsh_laneq_s32(__p0_788, __p1_788, __p2_788, __p3_788) __extension__ ({ \
+ int32x2_t __ret_788; \
+ int32x2_t __s0_788 = __p0_788; \
+ int32x2_t __s1_788 = __p1_788; \
+ int32x4_t __s2_788 = __p2_788; \
+ __ret_788 = vqrdmlsh_s32(__s0_788, __s1_788, splat_laneq_s32(__s2_788, __p3_788)); \
+ __ret_788; \
})
#else
-#define vqrdmlsh_laneq_s32(__p0_816, __p1_816, __p2_816, __p3_816) __extension__ ({ \
- int32x2_t __ret_816; \
- int32x2_t __s0_816 = __p0_816; \
- int32x2_t __s1_816 = __p1_816; \
- int32x4_t __s2_816 = __p2_816; \
- int32x2_t __rev0_816; __rev0_816 = __builtin_shufflevector(__s0_816, __s0_816, 1, 0); \
- int32x2_t __rev1_816; __rev1_816 = __builtin_shufflevector(__s1_816, __s1_816, 1, 0); \
- int32x4_t __rev2_816; __rev2_816 = __builtin_shufflevector(__s2_816, __s2_816, 3, 2, 1, 0); \
- __ret_816 = __noswap_vqrdmlsh_s32(__rev0_816, __rev1_816, __noswap_splat_laneq_s32(__rev2_816, __p3_816)); \
- __ret_816 = __builtin_shufflevector(__ret_816, __ret_816, 1, 0); \
- __ret_816; \
+#define vqrdmlsh_laneq_s32(__p0_789, __p1_789, __p2_789, __p3_789) __extension__ ({ \
+ int32x2_t __ret_789; \
+ int32x2_t __s0_789 = __p0_789; \
+ int32x2_t __s1_789 = __p1_789; \
+ int32x4_t __s2_789 = __p2_789; \
+ int32x2_t __rev0_789; __rev0_789 = __builtin_shufflevector(__s0_789, __s0_789, 1, 0); \
+ int32x2_t __rev1_789; __rev1_789 = __builtin_shufflevector(__s1_789, __s1_789, 1, 0); \
+ int32x4_t __rev2_789; __rev2_789 = __builtin_shufflevector(__s2_789, __s2_789, 3, 2, 1, 0); \
+ __ret_789 = __noswap_vqrdmlsh_s32(__rev0_789, __rev1_789, __noswap_splat_laneq_s32(__rev2_789, __p3_789)); \
+ __ret_789 = __builtin_shufflevector(__ret_789, __ret_789, 1, 0); \
+ __ret_789; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vqrdmlsh_laneq_s16(__p0_817, __p1_817, __p2_817, __p3_817) __extension__ ({ \
- int16x4_t __ret_817; \
- int16x4_t __s0_817 = __p0_817; \
- int16x4_t __s1_817 = __p1_817; \
- int16x8_t __s2_817 = __p2_817; \
- __ret_817 = vqrdmlsh_s16(__s0_817, __s1_817, splat_laneq_s16(__s2_817, __p3_817)); \
- __ret_817; \
+#define vqrdmlsh_laneq_s16(__p0_790, __p1_790, __p2_790, __p3_790) __extension__ ({ \
+ int16x4_t __ret_790; \
+ int16x4_t __s0_790 = __p0_790; \
+ int16x4_t __s1_790 = __p1_790; \
+ int16x8_t __s2_790 = __p2_790; \
+ __ret_790 = vqrdmlsh_s16(__s0_790, __s1_790, splat_laneq_s16(__s2_790, __p3_790)); \
+ __ret_790; \
})
#else
-#define vqrdmlsh_laneq_s16(__p0_818, __p1_818, __p2_818, __p3_818) __extension__ ({ \
- int16x4_t __ret_818; \
- int16x4_t __s0_818 = __p0_818; \
- int16x4_t __s1_818 = __p1_818; \
- int16x8_t __s2_818 = __p2_818; \
- int16x4_t __rev0_818; __rev0_818 = __builtin_shufflevector(__s0_818, __s0_818, 3, 2, 1, 0); \
- int16x4_t __rev1_818; __rev1_818 = __builtin_shufflevector(__s1_818, __s1_818, 3, 2, 1, 0); \
- int16x8_t __rev2_818; __rev2_818 = __builtin_shufflevector(__s2_818, __s2_818, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_818 = __noswap_vqrdmlsh_s16(__rev0_818, __rev1_818, __noswap_splat_laneq_s16(__rev2_818, __p3_818)); \
- __ret_818 = __builtin_shufflevector(__ret_818, __ret_818, 3, 2, 1, 0); \
- __ret_818; \
+#define vqrdmlsh_laneq_s16(__p0_791, __p1_791, __p2_791, __p3_791) __extension__ ({ \
+ int16x4_t __ret_791; \
+ int16x4_t __s0_791 = __p0_791; \
+ int16x4_t __s1_791 = __p1_791; \
+ int16x8_t __s2_791 = __p2_791; \
+ int16x4_t __rev0_791; __rev0_791 = __builtin_shufflevector(__s0_791, __s0_791, 3, 2, 1, 0); \
+ int16x4_t __rev1_791; __rev1_791 = __builtin_shufflevector(__s1_791, __s1_791, 3, 2, 1, 0); \
+ int16x8_t __rev2_791; __rev2_791 = __builtin_shufflevector(__s2_791, __s2_791, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_791 = __noswap_vqrdmlsh_s16(__rev0_791, __rev1_791, __noswap_splat_laneq_s16(__rev2_791, __p3_791)); \
+ __ret_791 = __builtin_shufflevector(__ret_791, __ret_791, 3, 2, 1, 0); \
+ __ret_791; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a"))) float64x2_t vcaddq_rot270_f64(float64x2_t __p0, float64x2_t __p1) {
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcaddq_rot270_f64(float64x2_t __p0, float64x2_t __p1) {
float64x2_t __ret;
__ret = (float64x2_t) __builtin_neon_vcaddq_rot270_f64((int8x16_t)__p0, (int8x16_t)__p1, 42);
return __ret;
}
#else
-__ai __attribute__((target("v8.3a"))) float64x2_t vcaddq_rot270_f64(float64x2_t __p0, float64x2_t __p1) {
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcaddq_rot270_f64(float64x2_t __p0, float64x2_t __p1) {
float64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -65754,13 +65584,13 @@ __ai __attribute__((target("v8.3a"))) float64x2_t vcaddq_rot270_f64(float64x2_t
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a"))) float64x2_t vcaddq_rot90_f64(float64x2_t __p0, float64x2_t __p1) {
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcaddq_rot90_f64(float64x2_t __p0, float64x2_t __p1) {
float64x2_t __ret;
__ret = (float64x2_t) __builtin_neon_vcaddq_rot90_f64((int8x16_t)__p0, (int8x16_t)__p1, 42);
return __ret;
}
#else
-__ai __attribute__((target("v8.3a"))) float64x2_t vcaddq_rot90_f64(float64x2_t __p0, float64x2_t __p1) {
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcaddq_rot90_f64(float64x2_t __p0, float64x2_t __p1) {
float64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -65771,13 +65601,13 @@ __ai __attribute__((target("v8.3a"))) float64x2_t vcaddq_rot90_f64(float64x2_t _
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a"))) float64x2_t vcmlaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcmlaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
float64x2_t __ret;
__ret = (float64x2_t) __builtin_neon_vcmlaq_f64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
return __ret;
}
#else
-__ai __attribute__((target("v8.3a"))) float64x2_t vcmlaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcmlaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
float64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -65786,116 +65616,116 @@ __ai __attribute__((target("v8.3a"))) float64x2_t vcmlaq_f64(float64x2_t __p0, f
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai __attribute__((target("v8.3a"))) float64x2_t __noswap_vcmlaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t __noswap_vcmlaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
float64x2_t __ret;
__ret = (float64x2_t) __builtin_neon_vcmlaq_f64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
return __ret;
}
#endif
-__ai __attribute__((target("v8.3a"))) float64x1_t vcmla_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
+__ai __attribute__((target("v8.3a,neon"))) float64x1_t vcmla_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
float64x1_t __ret;
__ret = (float64x1_t) __builtin_neon_vcmla_f64((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 10);
return __ret;
}
-#define vcmla_lane_f64(__p0_819, __p1_819, __p2_819, __p3_819) __extension__ ({ \
- float64x1_t __ret_819; \
- float64x1_t __s0_819 = __p0_819; \
- float64x1_t __s1_819 = __p1_819; \
- float64x1_t __s2_819 = __p2_819; \
-float64x1_t __reint_819 = __s2_819; \
-uint64x2_t __reint1_819 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_819, __p3_819), vgetq_lane_u64(*(uint64x2_t *) &__reint_819, __p3_819)}; \
- __ret_819 = vcmla_f64(__s0_819, __s1_819, *(float64x1_t *) &__reint1_819); \
- __ret_819; \
+#define vcmla_lane_f64(__p0_792, __p1_792, __p2_792, __p3_792) __extension__ ({ \
+ float64x1_t __ret_792; \
+ float64x1_t __s0_792 = __p0_792; \
+ float64x1_t __s1_792 = __p1_792; \
+ float64x1_t __s2_792 = __p2_792; \
+float64x1_t __reint_792 = __s2_792; \
+uint64x2_t __reint1_792 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_792, __p3_792), vgetq_lane_u64(*(uint64x2_t *) &__reint_792, __p3_792)}; \
+ __ret_792 = vcmla_f64(__s0_792, __s1_792, *(float64x1_t *) &__reint1_792); \
+ __ret_792; \
})
#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_lane_f64(__p0_820, __p1_820, __p2_820, __p3_820) __extension__ ({ \
- float64x2_t __ret_820; \
- float64x2_t __s0_820 = __p0_820; \
- float64x2_t __s1_820 = __p1_820; \
- float64x1_t __s2_820 = __p2_820; \
-float64x1_t __reint_820 = __s2_820; \
-uint64x2_t __reint1_820 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_820, __p3_820), vgetq_lane_u64(*(uint64x2_t *) &__reint_820, __p3_820)}; \
- __ret_820 = vcmlaq_f64(__s0_820, __s1_820, *(float64x2_t *) &__reint1_820); \
- __ret_820; \
+#define vcmlaq_lane_f64(__p0_793, __p1_793, __p2_793, __p3_793) __extension__ ({ \
+ float64x2_t __ret_793; \
+ float64x2_t __s0_793 = __p0_793; \
+ float64x2_t __s1_793 = __p1_793; \
+ float64x1_t __s2_793 = __p2_793; \
+float64x1_t __reint_793 = __s2_793; \
+uint64x2_t __reint1_793 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_793, __p3_793), vgetq_lane_u64(*(uint64x2_t *) &__reint_793, __p3_793)}; \
+ __ret_793 = vcmlaq_f64(__s0_793, __s1_793, *(float64x2_t *) &__reint1_793); \
+ __ret_793; \
})
#else
-#define vcmlaq_lane_f64(__p0_821, __p1_821, __p2_821, __p3_821) __extension__ ({ \
- float64x2_t __ret_821; \
- float64x2_t __s0_821 = __p0_821; \
- float64x2_t __s1_821 = __p1_821; \
- float64x1_t __s2_821 = __p2_821; \
- float64x2_t __rev0_821; __rev0_821 = __builtin_shufflevector(__s0_821, __s0_821, 1, 0); \
- float64x2_t __rev1_821; __rev1_821 = __builtin_shufflevector(__s1_821, __s1_821, 1, 0); \
-float64x1_t __reint_821 = __s2_821; \
-uint64x2_t __reint1_821 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_821, __p3_821), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_821, __p3_821)}; \
- __ret_821 = __noswap_vcmlaq_f64(__rev0_821, __rev1_821, *(float64x2_t *) &__reint1_821); \
- __ret_821 = __builtin_shufflevector(__ret_821, __ret_821, 1, 0); \
- __ret_821; \
+#define vcmlaq_lane_f64(__p0_794, __p1_794, __p2_794, __p3_794) __extension__ ({ \
+ float64x2_t __ret_794; \
+ float64x2_t __s0_794 = __p0_794; \
+ float64x2_t __s1_794 = __p1_794; \
+ float64x1_t __s2_794 = __p2_794; \
+ float64x2_t __rev0_794; __rev0_794 = __builtin_shufflevector(__s0_794, __s0_794, 1, 0); \
+ float64x2_t __rev1_794; __rev1_794 = __builtin_shufflevector(__s1_794, __s1_794, 1, 0); \
+float64x1_t __reint_794 = __s2_794; \
+uint64x2_t __reint1_794 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_794, __p3_794), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_794, __p3_794)}; \
+ __ret_794 = __noswap_vcmlaq_f64(__rev0_794, __rev1_794, *(float64x2_t *) &__reint1_794); \
+ __ret_794 = __builtin_shufflevector(__ret_794, __ret_794, 1, 0); \
+ __ret_794; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcmla_laneq_f64(__p0_822, __p1_822, __p2_822, __p3_822) __extension__ ({ \
- float64x1_t __ret_822; \
- float64x1_t __s0_822 = __p0_822; \
- float64x1_t __s1_822 = __p1_822; \
- float64x2_t __s2_822 = __p2_822; \
-float64x2_t __reint_822 = __s2_822; \
-uint64x2_t __reint1_822 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_822, __p3_822), vgetq_lane_u64(*(uint64x2_t *) &__reint_822, __p3_822)}; \
- __ret_822 = vcmla_f64(__s0_822, __s1_822, *(float64x1_t *) &__reint1_822); \
- __ret_822; \
+#define vcmla_laneq_f64(__p0_795, __p1_795, __p2_795, __p3_795) __extension__ ({ \
+ float64x1_t __ret_795; \
+ float64x1_t __s0_795 = __p0_795; \
+ float64x1_t __s1_795 = __p1_795; \
+ float64x2_t __s2_795 = __p2_795; \
+float64x2_t __reint_795 = __s2_795; \
+uint64x2_t __reint1_795 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_795, __p3_795), vgetq_lane_u64(*(uint64x2_t *) &__reint_795, __p3_795)}; \
+ __ret_795 = vcmla_f64(__s0_795, __s1_795, *(float64x1_t *) &__reint1_795); \
+ __ret_795; \
})
#else
-#define vcmla_laneq_f64(__p0_823, __p1_823, __p2_823, __p3_823) __extension__ ({ \
- float64x1_t __ret_823; \
- float64x1_t __s0_823 = __p0_823; \
- float64x1_t __s1_823 = __p1_823; \
- float64x2_t __s2_823 = __p2_823; \
- float64x2_t __rev2_823; __rev2_823 = __builtin_shufflevector(__s2_823, __s2_823, 1, 0); \
-float64x2_t __reint_823 = __rev2_823; \
-uint64x2_t __reint1_823 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_823, __p3_823), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_823, __p3_823)}; \
- __ret_823 = vcmla_f64(__s0_823, __s1_823, *(float64x1_t *) &__reint1_823); \
- __ret_823; \
+#define vcmla_laneq_f64(__p0_796, __p1_796, __p2_796, __p3_796) __extension__ ({ \
+ float64x1_t __ret_796; \
+ float64x1_t __s0_796 = __p0_796; \
+ float64x1_t __s1_796 = __p1_796; \
+ float64x2_t __s2_796 = __p2_796; \
+ float64x2_t __rev2_796; __rev2_796 = __builtin_shufflevector(__s2_796, __s2_796, 1, 0); \
+float64x2_t __reint_796 = __rev2_796; \
+uint64x2_t __reint1_796 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_796, __p3_796), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_796, __p3_796)}; \
+ __ret_796 = vcmla_f64(__s0_796, __s1_796, *(float64x1_t *) &__reint1_796); \
+ __ret_796; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_laneq_f64(__p0_824, __p1_824, __p2_824, __p3_824) __extension__ ({ \
- float64x2_t __ret_824; \
- float64x2_t __s0_824 = __p0_824; \
- float64x2_t __s1_824 = __p1_824; \
- float64x2_t __s2_824 = __p2_824; \
-float64x2_t __reint_824 = __s2_824; \
-uint64x2_t __reint1_824 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_824, __p3_824), vgetq_lane_u64(*(uint64x2_t *) &__reint_824, __p3_824)}; \
- __ret_824 = vcmlaq_f64(__s0_824, __s1_824, *(float64x2_t *) &__reint1_824); \
- __ret_824; \
+#define vcmlaq_laneq_f64(__p0_797, __p1_797, __p2_797, __p3_797) __extension__ ({ \
+ float64x2_t __ret_797; \
+ float64x2_t __s0_797 = __p0_797; \
+ float64x2_t __s1_797 = __p1_797; \
+ float64x2_t __s2_797 = __p2_797; \
+float64x2_t __reint_797 = __s2_797; \
+uint64x2_t __reint1_797 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_797, __p3_797), vgetq_lane_u64(*(uint64x2_t *) &__reint_797, __p3_797)}; \
+ __ret_797 = vcmlaq_f64(__s0_797, __s1_797, *(float64x2_t *) &__reint1_797); \
+ __ret_797; \
})
#else
-#define vcmlaq_laneq_f64(__p0_825, __p1_825, __p2_825, __p3_825) __extension__ ({ \
- float64x2_t __ret_825; \
- float64x2_t __s0_825 = __p0_825; \
- float64x2_t __s1_825 = __p1_825; \
- float64x2_t __s2_825 = __p2_825; \
- float64x2_t __rev0_825; __rev0_825 = __builtin_shufflevector(__s0_825, __s0_825, 1, 0); \
- float64x2_t __rev1_825; __rev1_825 = __builtin_shufflevector(__s1_825, __s1_825, 1, 0); \
- float64x2_t __rev2_825; __rev2_825 = __builtin_shufflevector(__s2_825, __s2_825, 1, 0); \
-float64x2_t __reint_825 = __rev2_825; \
-uint64x2_t __reint1_825 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_825, __p3_825), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_825, __p3_825)}; \
- __ret_825 = __noswap_vcmlaq_f64(__rev0_825, __rev1_825, *(float64x2_t *) &__reint1_825); \
- __ret_825 = __builtin_shufflevector(__ret_825, __ret_825, 1, 0); \
- __ret_825; \
+#define vcmlaq_laneq_f64(__p0_798, __p1_798, __p2_798, __p3_798) __extension__ ({ \
+ float64x2_t __ret_798; \
+ float64x2_t __s0_798 = __p0_798; \
+ float64x2_t __s1_798 = __p1_798; \
+ float64x2_t __s2_798 = __p2_798; \
+ float64x2_t __rev0_798; __rev0_798 = __builtin_shufflevector(__s0_798, __s0_798, 1, 0); \
+ float64x2_t __rev1_798; __rev1_798 = __builtin_shufflevector(__s1_798, __s1_798, 1, 0); \
+ float64x2_t __rev2_798; __rev2_798 = __builtin_shufflevector(__s2_798, __s2_798, 1, 0); \
+float64x2_t __reint_798 = __rev2_798; \
+uint64x2_t __reint1_798 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_798, __p3_798), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_798, __p3_798)}; \
+ __ret_798 = __noswap_vcmlaq_f64(__rev0_798, __rev1_798, *(float64x2_t *) &__reint1_798); \
+ __ret_798 = __builtin_shufflevector(__ret_798, __ret_798, 1, 0); \
+ __ret_798; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a"))) float64x2_t vcmlaq_rot180_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcmlaq_rot180_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
float64x2_t __ret;
__ret = (float64x2_t) __builtin_neon_vcmlaq_rot180_f64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
return __ret;
}
#else
-__ai __attribute__((target("v8.3a"))) float64x2_t vcmlaq_rot180_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcmlaq_rot180_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
float64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -65904,116 +65734,116 @@ __ai __attribute__((target("v8.3a"))) float64x2_t vcmlaq_rot180_f64(float64x2_t
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai __attribute__((target("v8.3a"))) float64x2_t __noswap_vcmlaq_rot180_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t __noswap_vcmlaq_rot180_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
float64x2_t __ret;
__ret = (float64x2_t) __builtin_neon_vcmlaq_rot180_f64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
return __ret;
}
#endif
-__ai __attribute__((target("v8.3a"))) float64x1_t vcmla_rot180_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
+__ai __attribute__((target("v8.3a,neon"))) float64x1_t vcmla_rot180_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
float64x1_t __ret;
__ret = (float64x1_t) __builtin_neon_vcmla_rot180_f64((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 10);
return __ret;
}
-#define vcmla_rot180_lane_f64(__p0_826, __p1_826, __p2_826, __p3_826) __extension__ ({ \
- float64x1_t __ret_826; \
- float64x1_t __s0_826 = __p0_826; \
- float64x1_t __s1_826 = __p1_826; \
- float64x1_t __s2_826 = __p2_826; \
-float64x1_t __reint_826 = __s2_826; \
-uint64x2_t __reint1_826 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_826, __p3_826), vgetq_lane_u64(*(uint64x2_t *) &__reint_826, __p3_826)}; \
- __ret_826 = vcmla_rot180_f64(__s0_826, __s1_826, *(float64x1_t *) &__reint1_826); \
- __ret_826; \
+#define vcmla_rot180_lane_f64(__p0_799, __p1_799, __p2_799, __p3_799) __extension__ ({ \
+ float64x1_t __ret_799; \
+ float64x1_t __s0_799 = __p0_799; \
+ float64x1_t __s1_799 = __p1_799; \
+ float64x1_t __s2_799 = __p2_799; \
+float64x1_t __reint_799 = __s2_799; \
+uint64x2_t __reint1_799 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_799, __p3_799), vgetq_lane_u64(*(uint64x2_t *) &__reint_799, __p3_799)}; \
+ __ret_799 = vcmla_rot180_f64(__s0_799, __s1_799, *(float64x1_t *) &__reint1_799); \
+ __ret_799; \
})
#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_rot180_lane_f64(__p0_827, __p1_827, __p2_827, __p3_827) __extension__ ({ \
- float64x2_t __ret_827; \
- float64x2_t __s0_827 = __p0_827; \
- float64x2_t __s1_827 = __p1_827; \
- float64x1_t __s2_827 = __p2_827; \
-float64x1_t __reint_827 = __s2_827; \
-uint64x2_t __reint1_827 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_827, __p3_827), vgetq_lane_u64(*(uint64x2_t *) &__reint_827, __p3_827)}; \
- __ret_827 = vcmlaq_rot180_f64(__s0_827, __s1_827, *(float64x2_t *) &__reint1_827); \
- __ret_827; \
+#define vcmlaq_rot180_lane_f64(__p0_800, __p1_800, __p2_800, __p3_800) __extension__ ({ \
+ float64x2_t __ret_800; \
+ float64x2_t __s0_800 = __p0_800; \
+ float64x2_t __s1_800 = __p1_800; \
+ float64x1_t __s2_800 = __p2_800; \
+float64x1_t __reint_800 = __s2_800; \
+uint64x2_t __reint1_800 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_800, __p3_800), vgetq_lane_u64(*(uint64x2_t *) &__reint_800, __p3_800)}; \
+ __ret_800 = vcmlaq_rot180_f64(__s0_800, __s1_800, *(float64x2_t *) &__reint1_800); \
+ __ret_800; \
})
#else
-#define vcmlaq_rot180_lane_f64(__p0_828, __p1_828, __p2_828, __p3_828) __extension__ ({ \
- float64x2_t __ret_828; \
- float64x2_t __s0_828 = __p0_828; \
- float64x2_t __s1_828 = __p1_828; \
- float64x1_t __s2_828 = __p2_828; \
- float64x2_t __rev0_828; __rev0_828 = __builtin_shufflevector(__s0_828, __s0_828, 1, 0); \
- float64x2_t __rev1_828; __rev1_828 = __builtin_shufflevector(__s1_828, __s1_828, 1, 0); \
-float64x1_t __reint_828 = __s2_828; \
-uint64x2_t __reint1_828 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_828, __p3_828), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_828, __p3_828)}; \
- __ret_828 = __noswap_vcmlaq_rot180_f64(__rev0_828, __rev1_828, *(float64x2_t *) &__reint1_828); \
- __ret_828 = __builtin_shufflevector(__ret_828, __ret_828, 1, 0); \
- __ret_828; \
+#define vcmlaq_rot180_lane_f64(__p0_801, __p1_801, __p2_801, __p3_801) __extension__ ({ \
+ float64x2_t __ret_801; \
+ float64x2_t __s0_801 = __p0_801; \
+ float64x2_t __s1_801 = __p1_801; \
+ float64x1_t __s2_801 = __p2_801; \
+ float64x2_t __rev0_801; __rev0_801 = __builtin_shufflevector(__s0_801, __s0_801, 1, 0); \
+ float64x2_t __rev1_801; __rev1_801 = __builtin_shufflevector(__s1_801, __s1_801, 1, 0); \
+float64x1_t __reint_801 = __s2_801; \
+uint64x2_t __reint1_801 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_801, __p3_801), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_801, __p3_801)}; \
+ __ret_801 = __noswap_vcmlaq_rot180_f64(__rev0_801, __rev1_801, *(float64x2_t *) &__reint1_801); \
+ __ret_801 = __builtin_shufflevector(__ret_801, __ret_801, 1, 0); \
+ __ret_801; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcmla_rot180_laneq_f64(__p0_829, __p1_829, __p2_829, __p3_829) __extension__ ({ \
- float64x1_t __ret_829; \
- float64x1_t __s0_829 = __p0_829; \
- float64x1_t __s1_829 = __p1_829; \
- float64x2_t __s2_829 = __p2_829; \
-float64x2_t __reint_829 = __s2_829; \
-uint64x2_t __reint1_829 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_829, __p3_829), vgetq_lane_u64(*(uint64x2_t *) &__reint_829, __p3_829)}; \
- __ret_829 = vcmla_rot180_f64(__s0_829, __s1_829, *(float64x1_t *) &__reint1_829); \
- __ret_829; \
+#define vcmla_rot180_laneq_f64(__p0_802, __p1_802, __p2_802, __p3_802) __extension__ ({ \
+ float64x1_t __ret_802; \
+ float64x1_t __s0_802 = __p0_802; \
+ float64x1_t __s1_802 = __p1_802; \
+ float64x2_t __s2_802 = __p2_802; \
+float64x2_t __reint_802 = __s2_802; \
+uint64x2_t __reint1_802 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_802, __p3_802), vgetq_lane_u64(*(uint64x2_t *) &__reint_802, __p3_802)}; \
+ __ret_802 = vcmla_rot180_f64(__s0_802, __s1_802, *(float64x1_t *) &__reint1_802); \
+ __ret_802; \
})
#else
-#define vcmla_rot180_laneq_f64(__p0_830, __p1_830, __p2_830, __p3_830) __extension__ ({ \
- float64x1_t __ret_830; \
- float64x1_t __s0_830 = __p0_830; \
- float64x1_t __s1_830 = __p1_830; \
- float64x2_t __s2_830 = __p2_830; \
- float64x2_t __rev2_830; __rev2_830 = __builtin_shufflevector(__s2_830, __s2_830, 1, 0); \
-float64x2_t __reint_830 = __rev2_830; \
-uint64x2_t __reint1_830 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_830, __p3_830), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_830, __p3_830)}; \
- __ret_830 = vcmla_rot180_f64(__s0_830, __s1_830, *(float64x1_t *) &__reint1_830); \
- __ret_830; \
+#define vcmla_rot180_laneq_f64(__p0_803, __p1_803, __p2_803, __p3_803) __extension__ ({ \
+ float64x1_t __ret_803; \
+ float64x1_t __s0_803 = __p0_803; \
+ float64x1_t __s1_803 = __p1_803; \
+ float64x2_t __s2_803 = __p2_803; \
+ float64x2_t __rev2_803; __rev2_803 = __builtin_shufflevector(__s2_803, __s2_803, 1, 0); \
+float64x2_t __reint_803 = __rev2_803; \
+uint64x2_t __reint1_803 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_803, __p3_803), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_803, __p3_803)}; \
+ __ret_803 = vcmla_rot180_f64(__s0_803, __s1_803, *(float64x1_t *) &__reint1_803); \
+ __ret_803; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_rot180_laneq_f64(__p0_831, __p1_831, __p2_831, __p3_831) __extension__ ({ \
- float64x2_t __ret_831; \
- float64x2_t __s0_831 = __p0_831; \
- float64x2_t __s1_831 = __p1_831; \
- float64x2_t __s2_831 = __p2_831; \
-float64x2_t __reint_831 = __s2_831; \
-uint64x2_t __reint1_831 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_831, __p3_831), vgetq_lane_u64(*(uint64x2_t *) &__reint_831, __p3_831)}; \
- __ret_831 = vcmlaq_rot180_f64(__s0_831, __s1_831, *(float64x2_t *) &__reint1_831); \
- __ret_831; \
+#define vcmlaq_rot180_laneq_f64(__p0_804, __p1_804, __p2_804, __p3_804) __extension__ ({ \
+ float64x2_t __ret_804; \
+ float64x2_t __s0_804 = __p0_804; \
+ float64x2_t __s1_804 = __p1_804; \
+ float64x2_t __s2_804 = __p2_804; \
+float64x2_t __reint_804 = __s2_804; \
+uint64x2_t __reint1_804 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_804, __p3_804), vgetq_lane_u64(*(uint64x2_t *) &__reint_804, __p3_804)}; \
+ __ret_804 = vcmlaq_rot180_f64(__s0_804, __s1_804, *(float64x2_t *) &__reint1_804); \
+ __ret_804; \
})
#else
-#define vcmlaq_rot180_laneq_f64(__p0_832, __p1_832, __p2_832, __p3_832) __extension__ ({ \
- float64x2_t __ret_832; \
- float64x2_t __s0_832 = __p0_832; \
- float64x2_t __s1_832 = __p1_832; \
- float64x2_t __s2_832 = __p2_832; \
- float64x2_t __rev0_832; __rev0_832 = __builtin_shufflevector(__s0_832, __s0_832, 1, 0); \
- float64x2_t __rev1_832; __rev1_832 = __builtin_shufflevector(__s1_832, __s1_832, 1, 0); \
- float64x2_t __rev2_832; __rev2_832 = __builtin_shufflevector(__s2_832, __s2_832, 1, 0); \
-float64x2_t __reint_832 = __rev2_832; \
-uint64x2_t __reint1_832 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_832, __p3_832), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_832, __p3_832)}; \
- __ret_832 = __noswap_vcmlaq_rot180_f64(__rev0_832, __rev1_832, *(float64x2_t *) &__reint1_832); \
- __ret_832 = __builtin_shufflevector(__ret_832, __ret_832, 1, 0); \
- __ret_832; \
+#define vcmlaq_rot180_laneq_f64(__p0_805, __p1_805, __p2_805, __p3_805) __extension__ ({ \
+ float64x2_t __ret_805; \
+ float64x2_t __s0_805 = __p0_805; \
+ float64x2_t __s1_805 = __p1_805; \
+ float64x2_t __s2_805 = __p2_805; \
+ float64x2_t __rev0_805; __rev0_805 = __builtin_shufflevector(__s0_805, __s0_805, 1, 0); \
+ float64x2_t __rev1_805; __rev1_805 = __builtin_shufflevector(__s1_805, __s1_805, 1, 0); \
+ float64x2_t __rev2_805; __rev2_805 = __builtin_shufflevector(__s2_805, __s2_805, 1, 0); \
+float64x2_t __reint_805 = __rev2_805; \
+uint64x2_t __reint1_805 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_805, __p3_805), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_805, __p3_805)}; \
+ __ret_805 = __noswap_vcmlaq_rot180_f64(__rev0_805, __rev1_805, *(float64x2_t *) &__reint1_805); \
+ __ret_805 = __builtin_shufflevector(__ret_805, __ret_805, 1, 0); \
+ __ret_805; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a"))) float64x2_t vcmlaq_rot270_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcmlaq_rot270_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
float64x2_t __ret;
__ret = (float64x2_t) __builtin_neon_vcmlaq_rot270_f64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
return __ret;
}
#else
-__ai __attribute__((target("v8.3a"))) float64x2_t vcmlaq_rot270_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcmlaq_rot270_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
float64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -66022,116 +65852,116 @@ __ai __attribute__((target("v8.3a"))) float64x2_t vcmlaq_rot270_f64(float64x2_t
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai __attribute__((target("v8.3a"))) float64x2_t __noswap_vcmlaq_rot270_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t __noswap_vcmlaq_rot270_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
float64x2_t __ret;
__ret = (float64x2_t) __builtin_neon_vcmlaq_rot270_f64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
return __ret;
}
#endif
-__ai __attribute__((target("v8.3a"))) float64x1_t vcmla_rot270_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
+__ai __attribute__((target("v8.3a,neon"))) float64x1_t vcmla_rot270_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
float64x1_t __ret;
__ret = (float64x1_t) __builtin_neon_vcmla_rot270_f64((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 10);
return __ret;
}
-#define vcmla_rot270_lane_f64(__p0_833, __p1_833, __p2_833, __p3_833) __extension__ ({ \
- float64x1_t __ret_833; \
- float64x1_t __s0_833 = __p0_833; \
- float64x1_t __s1_833 = __p1_833; \
- float64x1_t __s2_833 = __p2_833; \
-float64x1_t __reint_833 = __s2_833; \
-uint64x2_t __reint1_833 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_833, __p3_833), vgetq_lane_u64(*(uint64x2_t *) &__reint_833, __p3_833)}; \
- __ret_833 = vcmla_rot270_f64(__s0_833, __s1_833, *(float64x1_t *) &__reint1_833); \
- __ret_833; \
+#define vcmla_rot270_lane_f64(__p0_806, __p1_806, __p2_806, __p3_806) __extension__ ({ \
+ float64x1_t __ret_806; \
+ float64x1_t __s0_806 = __p0_806; \
+ float64x1_t __s1_806 = __p1_806; \
+ float64x1_t __s2_806 = __p2_806; \
+float64x1_t __reint_806 = __s2_806; \
+uint64x2_t __reint1_806 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_806, __p3_806), vgetq_lane_u64(*(uint64x2_t *) &__reint_806, __p3_806)}; \
+ __ret_806 = vcmla_rot270_f64(__s0_806, __s1_806, *(float64x1_t *) &__reint1_806); \
+ __ret_806; \
})
#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_rot270_lane_f64(__p0_834, __p1_834, __p2_834, __p3_834) __extension__ ({ \
- float64x2_t __ret_834; \
- float64x2_t __s0_834 = __p0_834; \
- float64x2_t __s1_834 = __p1_834; \
- float64x1_t __s2_834 = __p2_834; \
-float64x1_t __reint_834 = __s2_834; \
-uint64x2_t __reint1_834 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_834, __p3_834), vgetq_lane_u64(*(uint64x2_t *) &__reint_834, __p3_834)}; \
- __ret_834 = vcmlaq_rot270_f64(__s0_834, __s1_834, *(float64x2_t *) &__reint1_834); \
- __ret_834; \
+#define vcmlaq_rot270_lane_f64(__p0_807, __p1_807, __p2_807, __p3_807) __extension__ ({ \
+ float64x2_t __ret_807; \
+ float64x2_t __s0_807 = __p0_807; \
+ float64x2_t __s1_807 = __p1_807; \
+ float64x1_t __s2_807 = __p2_807; \
+float64x1_t __reint_807 = __s2_807; \
+uint64x2_t __reint1_807 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_807, __p3_807), vgetq_lane_u64(*(uint64x2_t *) &__reint_807, __p3_807)}; \
+ __ret_807 = vcmlaq_rot270_f64(__s0_807, __s1_807, *(float64x2_t *) &__reint1_807); \
+ __ret_807; \
})
#else
-#define vcmlaq_rot270_lane_f64(__p0_835, __p1_835, __p2_835, __p3_835) __extension__ ({ \
- float64x2_t __ret_835; \
- float64x2_t __s0_835 = __p0_835; \
- float64x2_t __s1_835 = __p1_835; \
- float64x1_t __s2_835 = __p2_835; \
- float64x2_t __rev0_835; __rev0_835 = __builtin_shufflevector(__s0_835, __s0_835, 1, 0); \
- float64x2_t __rev1_835; __rev1_835 = __builtin_shufflevector(__s1_835, __s1_835, 1, 0); \
-float64x1_t __reint_835 = __s2_835; \
-uint64x2_t __reint1_835 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_835, __p3_835), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_835, __p3_835)}; \
- __ret_835 = __noswap_vcmlaq_rot270_f64(__rev0_835, __rev1_835, *(float64x2_t *) &__reint1_835); \
- __ret_835 = __builtin_shufflevector(__ret_835, __ret_835, 1, 0); \
- __ret_835; \
+#define vcmlaq_rot270_lane_f64(__p0_808, __p1_808, __p2_808, __p3_808) __extension__ ({ \
+ float64x2_t __ret_808; \
+ float64x2_t __s0_808 = __p0_808; \
+ float64x2_t __s1_808 = __p1_808; \
+ float64x1_t __s2_808 = __p2_808; \
+ float64x2_t __rev0_808; __rev0_808 = __builtin_shufflevector(__s0_808, __s0_808, 1, 0); \
+ float64x2_t __rev1_808; __rev1_808 = __builtin_shufflevector(__s1_808, __s1_808, 1, 0); \
+float64x1_t __reint_808 = __s2_808; \
+uint64x2_t __reint1_808 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_808, __p3_808), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_808, __p3_808)}; \
+ __ret_808 = __noswap_vcmlaq_rot270_f64(__rev0_808, __rev1_808, *(float64x2_t *) &__reint1_808); \
+ __ret_808 = __builtin_shufflevector(__ret_808, __ret_808, 1, 0); \
+ __ret_808; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcmla_rot270_laneq_f64(__p0_836, __p1_836, __p2_836, __p3_836) __extension__ ({ \
- float64x1_t __ret_836; \
- float64x1_t __s0_836 = __p0_836; \
- float64x1_t __s1_836 = __p1_836; \
- float64x2_t __s2_836 = __p2_836; \
-float64x2_t __reint_836 = __s2_836; \
-uint64x2_t __reint1_836 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_836, __p3_836), vgetq_lane_u64(*(uint64x2_t *) &__reint_836, __p3_836)}; \
- __ret_836 = vcmla_rot270_f64(__s0_836, __s1_836, *(float64x1_t *) &__reint1_836); \
- __ret_836; \
-})
-#else
-#define vcmla_rot270_laneq_f64(__p0_837, __p1_837, __p2_837, __p3_837) __extension__ ({ \
- float64x1_t __ret_837; \
- float64x1_t __s0_837 = __p0_837; \
- float64x1_t __s1_837 = __p1_837; \
- float64x2_t __s2_837 = __p2_837; \
- float64x2_t __rev2_837; __rev2_837 = __builtin_shufflevector(__s2_837, __s2_837, 1, 0); \
-float64x2_t __reint_837 = __rev2_837; \
-uint64x2_t __reint1_837 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_837, __p3_837), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_837, __p3_837)}; \
- __ret_837 = vcmla_rot270_f64(__s0_837, __s1_837, *(float64x1_t *) &__reint1_837); \
- __ret_837; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_rot270_laneq_f64(__p0_838, __p1_838, __p2_838, __p3_838) __extension__ ({ \
- float64x2_t __ret_838; \
- float64x2_t __s0_838 = __p0_838; \
- float64x2_t __s1_838 = __p1_838; \
- float64x2_t __s2_838 = __p2_838; \
-float64x2_t __reint_838 = __s2_838; \
-uint64x2_t __reint1_838 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_838, __p3_838), vgetq_lane_u64(*(uint64x2_t *) &__reint_838, __p3_838)}; \
- __ret_838 = vcmlaq_rot270_f64(__s0_838, __s1_838, *(float64x2_t *) &__reint1_838); \
- __ret_838; \
-})
-#else
-#define vcmlaq_rot270_laneq_f64(__p0_839, __p1_839, __p2_839, __p3_839) __extension__ ({ \
- float64x2_t __ret_839; \
- float64x2_t __s0_839 = __p0_839; \
- float64x2_t __s1_839 = __p1_839; \
- float64x2_t __s2_839 = __p2_839; \
- float64x2_t __rev0_839; __rev0_839 = __builtin_shufflevector(__s0_839, __s0_839, 1, 0); \
- float64x2_t __rev1_839; __rev1_839 = __builtin_shufflevector(__s1_839, __s1_839, 1, 0); \
- float64x2_t __rev2_839; __rev2_839 = __builtin_shufflevector(__s2_839, __s2_839, 1, 0); \
-float64x2_t __reint_839 = __rev2_839; \
-uint64x2_t __reint1_839 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_839, __p3_839), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_839, __p3_839)}; \
- __ret_839 = __noswap_vcmlaq_rot270_f64(__rev0_839, __rev1_839, *(float64x2_t *) &__reint1_839); \
- __ret_839 = __builtin_shufflevector(__ret_839, __ret_839, 1, 0); \
- __ret_839; \
+#define vcmla_rot270_laneq_f64(__p0_809, __p1_809, __p2_809, __p3_809) __extension__ ({ \
+ float64x1_t __ret_809; \
+ float64x1_t __s0_809 = __p0_809; \
+ float64x1_t __s1_809 = __p1_809; \
+ float64x2_t __s2_809 = __p2_809; \
+float64x2_t __reint_809 = __s2_809; \
+uint64x2_t __reint1_809 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_809, __p3_809), vgetq_lane_u64(*(uint64x2_t *) &__reint_809, __p3_809)}; \
+ __ret_809 = vcmla_rot270_f64(__s0_809, __s1_809, *(float64x1_t *) &__reint1_809); \
+ __ret_809; \
+})
+#else
+#define vcmla_rot270_laneq_f64(__p0_810, __p1_810, __p2_810, __p3_810) __extension__ ({ \
+ float64x1_t __ret_810; \
+ float64x1_t __s0_810 = __p0_810; \
+ float64x1_t __s1_810 = __p1_810; \
+ float64x2_t __s2_810 = __p2_810; \
+ float64x2_t __rev2_810; __rev2_810 = __builtin_shufflevector(__s2_810, __s2_810, 1, 0); \
+float64x2_t __reint_810 = __rev2_810; \
+uint64x2_t __reint1_810 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_810, __p3_810), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_810, __p3_810)}; \
+ __ret_810 = vcmla_rot270_f64(__s0_810, __s1_810, *(float64x1_t *) &__reint1_810); \
+ __ret_810; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.3a"))) float64x2_t vcmlaq_rot90_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+#define vcmlaq_rot270_laneq_f64(__p0_811, __p1_811, __p2_811, __p3_811) __extension__ ({ \
+ float64x2_t __ret_811; \
+ float64x2_t __s0_811 = __p0_811; \
+ float64x2_t __s1_811 = __p1_811; \
+ float64x2_t __s2_811 = __p2_811; \
+float64x2_t __reint_811 = __s2_811; \
+uint64x2_t __reint1_811 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_811, __p3_811), vgetq_lane_u64(*(uint64x2_t *) &__reint_811, __p3_811)}; \
+ __ret_811 = vcmlaq_rot270_f64(__s0_811, __s1_811, *(float64x2_t *) &__reint1_811); \
+ __ret_811; \
+})
+#else
+#define vcmlaq_rot270_laneq_f64(__p0_812, __p1_812, __p2_812, __p3_812) __extension__ ({ \
+ float64x2_t __ret_812; \
+ float64x2_t __s0_812 = __p0_812; \
+ float64x2_t __s1_812 = __p1_812; \
+ float64x2_t __s2_812 = __p2_812; \
+ float64x2_t __rev0_812; __rev0_812 = __builtin_shufflevector(__s0_812, __s0_812, 1, 0); \
+ float64x2_t __rev1_812; __rev1_812 = __builtin_shufflevector(__s1_812, __s1_812, 1, 0); \
+ float64x2_t __rev2_812; __rev2_812 = __builtin_shufflevector(__s2_812, __s2_812, 1, 0); \
+float64x2_t __reint_812 = __rev2_812; \
+uint64x2_t __reint1_812 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_812, __p3_812), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_812, __p3_812)}; \
+ __ret_812 = __noswap_vcmlaq_rot270_f64(__rev0_812, __rev1_812, *(float64x2_t *) &__reint1_812); \
+ __ret_812 = __builtin_shufflevector(__ret_812, __ret_812, 1, 0); \
+ __ret_812; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcmlaq_rot90_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
float64x2_t __ret;
__ret = (float64x2_t) __builtin_neon_vcmlaq_rot90_f64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
return __ret;
}
#else
-__ai __attribute__((target("v8.3a"))) float64x2_t vcmlaq_rot90_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcmlaq_rot90_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
float64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -66140,116 +65970,116 @@ __ai __attribute__((target("v8.3a"))) float64x2_t vcmlaq_rot90_f64(float64x2_t _
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai __attribute__((target("v8.3a"))) float64x2_t __noswap_vcmlaq_rot90_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t __noswap_vcmlaq_rot90_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
float64x2_t __ret;
__ret = (float64x2_t) __builtin_neon_vcmlaq_rot90_f64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
return __ret;
}
#endif
-__ai __attribute__((target("v8.3a"))) float64x1_t vcmla_rot90_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
+__ai __attribute__((target("v8.3a,neon"))) float64x1_t vcmla_rot90_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
float64x1_t __ret;
__ret = (float64x1_t) __builtin_neon_vcmla_rot90_f64((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 10);
return __ret;
}
-#define vcmla_rot90_lane_f64(__p0_840, __p1_840, __p2_840, __p3_840) __extension__ ({ \
- float64x1_t __ret_840; \
- float64x1_t __s0_840 = __p0_840; \
- float64x1_t __s1_840 = __p1_840; \
- float64x1_t __s2_840 = __p2_840; \
-float64x1_t __reint_840 = __s2_840; \
-uint64x2_t __reint1_840 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_840, __p3_840), vgetq_lane_u64(*(uint64x2_t *) &__reint_840, __p3_840)}; \
- __ret_840 = vcmla_rot90_f64(__s0_840, __s1_840, *(float64x1_t *) &__reint1_840); \
- __ret_840; \
+#define vcmla_rot90_lane_f64(__p0_813, __p1_813, __p2_813, __p3_813) __extension__ ({ \
+ float64x1_t __ret_813; \
+ float64x1_t __s0_813 = __p0_813; \
+ float64x1_t __s1_813 = __p1_813; \
+ float64x1_t __s2_813 = __p2_813; \
+float64x1_t __reint_813 = __s2_813; \
+uint64x2_t __reint1_813 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_813, __p3_813), vgetq_lane_u64(*(uint64x2_t *) &__reint_813, __p3_813)}; \
+ __ret_813 = vcmla_rot90_f64(__s0_813, __s1_813, *(float64x1_t *) &__reint1_813); \
+ __ret_813; \
})
#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_rot90_lane_f64(__p0_841, __p1_841, __p2_841, __p3_841) __extension__ ({ \
- float64x2_t __ret_841; \
- float64x2_t __s0_841 = __p0_841; \
- float64x2_t __s1_841 = __p1_841; \
- float64x1_t __s2_841 = __p2_841; \
-float64x1_t __reint_841 = __s2_841; \
-uint64x2_t __reint1_841 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_841, __p3_841), vgetq_lane_u64(*(uint64x2_t *) &__reint_841, __p3_841)}; \
- __ret_841 = vcmlaq_rot90_f64(__s0_841, __s1_841, *(float64x2_t *) &__reint1_841); \
- __ret_841; \
+#define vcmlaq_rot90_lane_f64(__p0_814, __p1_814, __p2_814, __p3_814) __extension__ ({ \
+ float64x2_t __ret_814; \
+ float64x2_t __s0_814 = __p0_814; \
+ float64x2_t __s1_814 = __p1_814; \
+ float64x1_t __s2_814 = __p2_814; \
+float64x1_t __reint_814 = __s2_814; \
+uint64x2_t __reint1_814 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_814, __p3_814), vgetq_lane_u64(*(uint64x2_t *) &__reint_814, __p3_814)}; \
+ __ret_814 = vcmlaq_rot90_f64(__s0_814, __s1_814, *(float64x2_t *) &__reint1_814); \
+ __ret_814; \
})
#else
-#define vcmlaq_rot90_lane_f64(__p0_842, __p1_842, __p2_842, __p3_842) __extension__ ({ \
- float64x2_t __ret_842; \
- float64x2_t __s0_842 = __p0_842; \
- float64x2_t __s1_842 = __p1_842; \
- float64x1_t __s2_842 = __p2_842; \
- float64x2_t __rev0_842; __rev0_842 = __builtin_shufflevector(__s0_842, __s0_842, 1, 0); \
- float64x2_t __rev1_842; __rev1_842 = __builtin_shufflevector(__s1_842, __s1_842, 1, 0); \
-float64x1_t __reint_842 = __s2_842; \
-uint64x2_t __reint1_842 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_842, __p3_842), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_842, __p3_842)}; \
- __ret_842 = __noswap_vcmlaq_rot90_f64(__rev0_842, __rev1_842, *(float64x2_t *) &__reint1_842); \
- __ret_842 = __builtin_shufflevector(__ret_842, __ret_842, 1, 0); \
- __ret_842; \
+#define vcmlaq_rot90_lane_f64(__p0_815, __p1_815, __p2_815, __p3_815) __extension__ ({ \
+ float64x2_t __ret_815; \
+ float64x2_t __s0_815 = __p0_815; \
+ float64x2_t __s1_815 = __p1_815; \
+ float64x1_t __s2_815 = __p2_815; \
+ float64x2_t __rev0_815; __rev0_815 = __builtin_shufflevector(__s0_815, __s0_815, 1, 0); \
+ float64x2_t __rev1_815; __rev1_815 = __builtin_shufflevector(__s1_815, __s1_815, 1, 0); \
+float64x1_t __reint_815 = __s2_815; \
+uint64x2_t __reint1_815 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_815, __p3_815), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_815, __p3_815)}; \
+ __ret_815 = __noswap_vcmlaq_rot90_f64(__rev0_815, __rev1_815, *(float64x2_t *) &__reint1_815); \
+ __ret_815 = __builtin_shufflevector(__ret_815, __ret_815, 1, 0); \
+ __ret_815; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcmla_rot90_laneq_f64(__p0_843, __p1_843, __p2_843, __p3_843) __extension__ ({ \
- float64x1_t __ret_843; \
- float64x1_t __s0_843 = __p0_843; \
- float64x1_t __s1_843 = __p1_843; \
- float64x2_t __s2_843 = __p2_843; \
-float64x2_t __reint_843 = __s2_843; \
-uint64x2_t __reint1_843 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_843, __p3_843), vgetq_lane_u64(*(uint64x2_t *) &__reint_843, __p3_843)}; \
- __ret_843 = vcmla_rot90_f64(__s0_843, __s1_843, *(float64x1_t *) &__reint1_843); \
- __ret_843; \
+#define vcmla_rot90_laneq_f64(__p0_816, __p1_816, __p2_816, __p3_816) __extension__ ({ \
+ float64x1_t __ret_816; \
+ float64x1_t __s0_816 = __p0_816; \
+ float64x1_t __s1_816 = __p1_816; \
+ float64x2_t __s2_816 = __p2_816; \
+float64x2_t __reint_816 = __s2_816; \
+uint64x2_t __reint1_816 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_816, __p3_816), vgetq_lane_u64(*(uint64x2_t *) &__reint_816, __p3_816)}; \
+ __ret_816 = vcmla_rot90_f64(__s0_816, __s1_816, *(float64x1_t *) &__reint1_816); \
+ __ret_816; \
})
#else
-#define vcmla_rot90_laneq_f64(__p0_844, __p1_844, __p2_844, __p3_844) __extension__ ({ \
- float64x1_t __ret_844; \
- float64x1_t __s0_844 = __p0_844; \
- float64x1_t __s1_844 = __p1_844; \
- float64x2_t __s2_844 = __p2_844; \
- float64x2_t __rev2_844; __rev2_844 = __builtin_shufflevector(__s2_844, __s2_844, 1, 0); \
-float64x2_t __reint_844 = __rev2_844; \
-uint64x2_t __reint1_844 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_844, __p3_844), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_844, __p3_844)}; \
- __ret_844 = vcmla_rot90_f64(__s0_844, __s1_844, *(float64x1_t *) &__reint1_844); \
- __ret_844; \
+#define vcmla_rot90_laneq_f64(__p0_817, __p1_817, __p2_817, __p3_817) __extension__ ({ \
+ float64x1_t __ret_817; \
+ float64x1_t __s0_817 = __p0_817; \
+ float64x1_t __s1_817 = __p1_817; \
+ float64x2_t __s2_817 = __p2_817; \
+ float64x2_t __rev2_817; __rev2_817 = __builtin_shufflevector(__s2_817, __s2_817, 1, 0); \
+float64x2_t __reint_817 = __rev2_817; \
+uint64x2_t __reint1_817 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_817, __p3_817), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_817, __p3_817)}; \
+ __ret_817 = vcmla_rot90_f64(__s0_817, __s1_817, *(float64x1_t *) &__reint1_817); \
+ __ret_817; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcmlaq_rot90_laneq_f64(__p0_845, __p1_845, __p2_845, __p3_845) __extension__ ({ \
- float64x2_t __ret_845; \
- float64x2_t __s0_845 = __p0_845; \
- float64x2_t __s1_845 = __p1_845; \
- float64x2_t __s2_845 = __p2_845; \
-float64x2_t __reint_845 = __s2_845; \
-uint64x2_t __reint1_845 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_845, __p3_845), vgetq_lane_u64(*(uint64x2_t *) &__reint_845, __p3_845)}; \
- __ret_845 = vcmlaq_rot90_f64(__s0_845, __s1_845, *(float64x2_t *) &__reint1_845); \
- __ret_845; \
+#define vcmlaq_rot90_laneq_f64(__p0_818, __p1_818, __p2_818, __p3_818) __extension__ ({ \
+ float64x2_t __ret_818; \
+ float64x2_t __s0_818 = __p0_818; \
+ float64x2_t __s1_818 = __p1_818; \
+ float64x2_t __s2_818 = __p2_818; \
+float64x2_t __reint_818 = __s2_818; \
+uint64x2_t __reint1_818 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_818, __p3_818), vgetq_lane_u64(*(uint64x2_t *) &__reint_818, __p3_818)}; \
+ __ret_818 = vcmlaq_rot90_f64(__s0_818, __s1_818, *(float64x2_t *) &__reint1_818); \
+ __ret_818; \
})
#else
-#define vcmlaq_rot90_laneq_f64(__p0_846, __p1_846, __p2_846, __p3_846) __extension__ ({ \
- float64x2_t __ret_846; \
- float64x2_t __s0_846 = __p0_846; \
- float64x2_t __s1_846 = __p1_846; \
- float64x2_t __s2_846 = __p2_846; \
- float64x2_t __rev0_846; __rev0_846 = __builtin_shufflevector(__s0_846, __s0_846, 1, 0); \
- float64x2_t __rev1_846; __rev1_846 = __builtin_shufflevector(__s1_846, __s1_846, 1, 0); \
- float64x2_t __rev2_846; __rev2_846 = __builtin_shufflevector(__s2_846, __s2_846, 1, 0); \
-float64x2_t __reint_846 = __rev2_846; \
-uint64x2_t __reint1_846 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_846, __p3_846), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_846, __p3_846)}; \
- __ret_846 = __noswap_vcmlaq_rot90_f64(__rev0_846, __rev1_846, *(float64x2_t *) &__reint1_846); \
- __ret_846 = __builtin_shufflevector(__ret_846, __ret_846, 1, 0); \
- __ret_846; \
+#define vcmlaq_rot90_laneq_f64(__p0_819, __p1_819, __p2_819, __p3_819) __extension__ ({ \
+ float64x2_t __ret_819; \
+ float64x2_t __s0_819 = __p0_819; \
+ float64x2_t __s1_819 = __p1_819; \
+ float64x2_t __s2_819 = __p2_819; \
+ float64x2_t __rev0_819; __rev0_819 = __builtin_shufflevector(__s0_819, __s0_819, 1, 0); \
+ float64x2_t __rev1_819; __rev1_819 = __builtin_shufflevector(__s1_819, __s1_819, 1, 0); \
+ float64x2_t __rev2_819; __rev2_819 = __builtin_shufflevector(__s2_819, __s2_819, 1, 0); \
+float64x2_t __reint_819 = __rev2_819; \
+uint64x2_t __reint1_819 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_819, __p3_819), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_819, __p3_819)}; \
+ __ret_819 = __noswap_vcmlaq_rot90_f64(__rev0_819, __rev1_819, *(float64x2_t *) &__reint1_819); \
+ __ret_819 = __builtin_shufflevector(__ret_819, __ret_819, 1, 0); \
+ __ret_819; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.5a"))) float32x4_t vrnd32xq_f32(float32x4_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float32x4_t vrnd32xq_f32(float32x4_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t) __builtin_neon_vrnd32xq_f32((int8x16_t)__p0, 41);
return __ret;
}
#else
-__ai __attribute__((target("v8.5a"))) float32x4_t vrnd32xq_f32(float32x4_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float32x4_t vrnd32xq_f32(float32x4_t __p0) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (float32x4_t) __builtin_neon_vrnd32xq_f32((int8x16_t)__rev0, 41);
@@ -66259,13 +66089,13 @@ __ai __attribute__((target("v8.5a"))) float32x4_t vrnd32xq_f32(float32x4_t __p0)
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.5a"))) float32x2_t vrnd32x_f32(float32x2_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float32x2_t vrnd32x_f32(float32x2_t __p0) {
float32x2_t __ret;
__ret = (float32x2_t) __builtin_neon_vrnd32x_f32((int8x8_t)__p0, 9);
return __ret;
}
#else
-__ai __attribute__((target("v8.5a"))) float32x2_t vrnd32x_f32(float32x2_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float32x2_t vrnd32x_f32(float32x2_t __p0) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (float32x2_t) __builtin_neon_vrnd32x_f32((int8x8_t)__rev0, 9);
@@ -66275,13 +66105,13 @@ __ai __attribute__((target("v8.5a"))) float32x2_t vrnd32x_f32(float32x2_t __p0)
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.5a"))) float64x2_t vrnd32xq_f64(float64x2_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float64x2_t vrnd32xq_f64(float64x2_t __p0) {
float64x2_t __ret;
__ret = (float64x2_t) __builtin_neon_vrnd32xq_f64((int8x16_t)__p0, 42);
return __ret;
}
#else
-__ai __attribute__((target("v8.5a"))) float64x2_t vrnd32xq_f64(float64x2_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float64x2_t vrnd32xq_f64(float64x2_t __p0) {
float64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (float64x2_t) __builtin_neon_vrnd32xq_f64((int8x16_t)__rev0, 42);
@@ -66290,19 +66120,19 @@ __ai __attribute__((target("v8.5a"))) float64x2_t vrnd32xq_f64(float64x2_t __p0)
}
#endif
-__ai __attribute__((target("v8.5a"))) float64x1_t vrnd32x_f64(float64x1_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float64x1_t vrnd32x_f64(float64x1_t __p0) {
float64x1_t __ret;
__ret = (float64x1_t) __builtin_neon_vrnd32x_f64((int8x8_t)__p0, 10);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.5a"))) float32x4_t vrnd32zq_f32(float32x4_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float32x4_t vrnd32zq_f32(float32x4_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t) __builtin_neon_vrnd32zq_f32((int8x16_t)__p0, 41);
return __ret;
}
#else
-__ai __attribute__((target("v8.5a"))) float32x4_t vrnd32zq_f32(float32x4_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float32x4_t vrnd32zq_f32(float32x4_t __p0) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (float32x4_t) __builtin_neon_vrnd32zq_f32((int8x16_t)__rev0, 41);
@@ -66312,13 +66142,13 @@ __ai __attribute__((target("v8.5a"))) float32x4_t vrnd32zq_f32(float32x4_t __p0)
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.5a"))) float32x2_t vrnd32z_f32(float32x2_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float32x2_t vrnd32z_f32(float32x2_t __p0) {
float32x2_t __ret;
__ret = (float32x2_t) __builtin_neon_vrnd32z_f32((int8x8_t)__p0, 9);
return __ret;
}
#else
-__ai __attribute__((target("v8.5a"))) float32x2_t vrnd32z_f32(float32x2_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float32x2_t vrnd32z_f32(float32x2_t __p0) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (float32x2_t) __builtin_neon_vrnd32z_f32((int8x8_t)__rev0, 9);
@@ -66328,13 +66158,13 @@ __ai __attribute__((target("v8.5a"))) float32x2_t vrnd32z_f32(float32x2_t __p0)
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.5a"))) float64x2_t vrnd32zq_f64(float64x2_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float64x2_t vrnd32zq_f64(float64x2_t __p0) {
float64x2_t __ret;
__ret = (float64x2_t) __builtin_neon_vrnd32zq_f64((int8x16_t)__p0, 42);
return __ret;
}
#else
-__ai __attribute__((target("v8.5a"))) float64x2_t vrnd32zq_f64(float64x2_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float64x2_t vrnd32zq_f64(float64x2_t __p0) {
float64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (float64x2_t) __builtin_neon_vrnd32zq_f64((int8x16_t)__rev0, 42);
@@ -66343,19 +66173,19 @@ __ai __attribute__((target("v8.5a"))) float64x2_t vrnd32zq_f64(float64x2_t __p0)
}
#endif
-__ai __attribute__((target("v8.5a"))) float64x1_t vrnd32z_f64(float64x1_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float64x1_t vrnd32z_f64(float64x1_t __p0) {
float64x1_t __ret;
__ret = (float64x1_t) __builtin_neon_vrnd32z_f64((int8x8_t)__p0, 10);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.5a"))) float32x4_t vrnd64xq_f32(float32x4_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float32x4_t vrnd64xq_f32(float32x4_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t) __builtin_neon_vrnd64xq_f32((int8x16_t)__p0, 41);
return __ret;
}
#else
-__ai __attribute__((target("v8.5a"))) float32x4_t vrnd64xq_f32(float32x4_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float32x4_t vrnd64xq_f32(float32x4_t __p0) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (float32x4_t) __builtin_neon_vrnd64xq_f32((int8x16_t)__rev0, 41);
@@ -66365,13 +66195,13 @@ __ai __attribute__((target("v8.5a"))) float32x4_t vrnd64xq_f32(float32x4_t __p0)
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.5a"))) float32x2_t vrnd64x_f32(float32x2_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float32x2_t vrnd64x_f32(float32x2_t __p0) {
float32x2_t __ret;
__ret = (float32x2_t) __builtin_neon_vrnd64x_f32((int8x8_t)__p0, 9);
return __ret;
}
#else
-__ai __attribute__((target("v8.5a"))) float32x2_t vrnd64x_f32(float32x2_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float32x2_t vrnd64x_f32(float32x2_t __p0) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (float32x2_t) __builtin_neon_vrnd64x_f32((int8x8_t)__rev0, 9);
@@ -66381,13 +66211,13 @@ __ai __attribute__((target("v8.5a"))) float32x2_t vrnd64x_f32(float32x2_t __p0)
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.5a"))) float64x2_t vrnd64xq_f64(float64x2_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float64x2_t vrnd64xq_f64(float64x2_t __p0) {
float64x2_t __ret;
__ret = (float64x2_t) __builtin_neon_vrnd64xq_f64((int8x16_t)__p0, 42);
return __ret;
}
#else
-__ai __attribute__((target("v8.5a"))) float64x2_t vrnd64xq_f64(float64x2_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float64x2_t vrnd64xq_f64(float64x2_t __p0) {
float64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (float64x2_t) __builtin_neon_vrnd64xq_f64((int8x16_t)__rev0, 42);
@@ -66396,19 +66226,19 @@ __ai __attribute__((target("v8.5a"))) float64x2_t vrnd64xq_f64(float64x2_t __p0)
}
#endif
-__ai __attribute__((target("v8.5a"))) float64x1_t vrnd64x_f64(float64x1_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float64x1_t vrnd64x_f64(float64x1_t __p0) {
float64x1_t __ret;
__ret = (float64x1_t) __builtin_neon_vrnd64x_f64((int8x8_t)__p0, 10);
return __ret;
}
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.5a"))) float32x4_t vrnd64zq_f32(float32x4_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float32x4_t vrnd64zq_f32(float32x4_t __p0) {
float32x4_t __ret;
__ret = (float32x4_t) __builtin_neon_vrnd64zq_f32((int8x16_t)__p0, 41);
return __ret;
}
#else
-__ai __attribute__((target("v8.5a"))) float32x4_t vrnd64zq_f32(float32x4_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float32x4_t vrnd64zq_f32(float32x4_t __p0) {
float32x4_t __ret;
float32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
__ret = (float32x4_t) __builtin_neon_vrnd64zq_f32((int8x16_t)__rev0, 41);
@@ -66418,13 +66248,13 @@ __ai __attribute__((target("v8.5a"))) float32x4_t vrnd64zq_f32(float32x4_t __p0)
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.5a"))) float32x2_t vrnd64z_f32(float32x2_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float32x2_t vrnd64z_f32(float32x2_t __p0) {
float32x2_t __ret;
__ret = (float32x2_t) __builtin_neon_vrnd64z_f32((int8x8_t)__p0, 9);
return __ret;
}
#else
-__ai __attribute__((target("v8.5a"))) float32x2_t vrnd64z_f32(float32x2_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float32x2_t vrnd64z_f32(float32x2_t __p0) {
float32x2_t __ret;
float32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (float32x2_t) __builtin_neon_vrnd64z_f32((int8x8_t)__rev0, 9);
@@ -66434,13 +66264,13 @@ __ai __attribute__((target("v8.5a"))) float32x2_t vrnd64z_f32(float32x2_t __p0)
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("v8.5a"))) float64x2_t vrnd64zq_f64(float64x2_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float64x2_t vrnd64zq_f64(float64x2_t __p0) {
float64x2_t __ret;
__ret = (float64x2_t) __builtin_neon_vrnd64zq_f64((int8x16_t)__p0, 42);
return __ret;
}
#else
-__ai __attribute__((target("v8.5a"))) float64x2_t vrnd64zq_f64(float64x2_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float64x2_t vrnd64zq_f64(float64x2_t __p0) {
float64x2_t __ret;
float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
__ret = (float64x2_t) __builtin_neon_vrnd64zq_f64((int8x16_t)__rev0, 42);
@@ -66449,215 +66279,545 @@ __ai __attribute__((target("v8.5a"))) float64x2_t vrnd64zq_f64(float64x2_t __p0)
}
#endif
-__ai __attribute__((target("v8.5a"))) float64x1_t vrnd64z_f64(float64x1_t __p0) {
+__ai __attribute__((target("v8.5a,neon"))) float64x1_t vrnd64z_f64(float64x1_t __p0) {
float64x1_t __ret;
__ret = (float64x1_t) __builtin_neon_vrnd64z_f64((int8x8_t)__p0, 10);
return __ret;
}
#endif
-#if defined(__aarch64__) && defined(__ARM_FEATURE_DIRECTED_ROUNDING)
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vrndq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vrndq_v((int8x16_t)__p0, 42);
- return __ret;
-}
+#define vbfdotq_lane_f32(__p0_820, __p1_820, __p2_820, __p3_820) __extension__ ({ \
+ float32x4_t __ret_820; \
+ float32x4_t __s0_820 = __p0_820; \
+ bfloat16x8_t __s1_820 = __p1_820; \
+ bfloat16x4_t __s2_820 = __p2_820; \
+bfloat16x4_t __reint_820 = __s2_820; \
+float32x4_t __reint1_820 = splatq_lane_f32(*(float32x2_t *) &__reint_820, __p3_820); \
+ __ret_820 = vbfdotq_f32(__s0_820, __s1_820, *(bfloat16x8_t *) &__reint1_820); \
+ __ret_820; \
+})
#else
-__ai float64x2_t vrndq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vrndq_v((int8x16_t)__rev0, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vbfdotq_lane_f32(__p0_821, __p1_821, __p2_821, __p3_821) __extension__ ({ \
+ float32x4_t __ret_821; \
+ float32x4_t __s0_821 = __p0_821; \
+ bfloat16x8_t __s1_821 = __p1_821; \
+ bfloat16x4_t __s2_821 = __p2_821; \
+ float32x4_t __rev0_821; __rev0_821 = __builtin_shufflevector(__s0_821, __s0_821, 3, 2, 1, 0); \
+ bfloat16x8_t __rev1_821; __rev1_821 = __builtin_shufflevector(__s1_821, __s1_821, 7, 6, 5, 4, 3, 2, 1, 0); \
+ bfloat16x4_t __rev2_821; __rev2_821 = __builtin_shufflevector(__s2_821, __s2_821, 3, 2, 1, 0); \
+bfloat16x4_t __reint_821 = __rev2_821; \
+float32x4_t __reint1_821 = __noswap_splatq_lane_f32(*(float32x2_t *) &__reint_821, __p3_821); \
+ __ret_821 = __noswap_vbfdotq_f32(__rev0_821, __rev1_821, *(bfloat16x8_t *) &__reint1_821); \
+ __ret_821 = __builtin_shufflevector(__ret_821, __ret_821, 3, 2, 1, 0); \
+ __ret_821; \
+})
#endif
-__ai float64x1_t vrnd_f64(float64x1_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vrnd_v((int8x8_t)__p0, 10);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vrndaq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vrndaq_v((int8x16_t)__p0, 42);
- return __ret;
-}
+#define vbfdot_lane_f32(__p0_822, __p1_822, __p2_822, __p3_822) __extension__ ({ \
+ float32x2_t __ret_822; \
+ float32x2_t __s0_822 = __p0_822; \
+ bfloat16x4_t __s1_822 = __p1_822; \
+ bfloat16x4_t __s2_822 = __p2_822; \
+bfloat16x4_t __reint_822 = __s2_822; \
+float32x2_t __reint1_822 = splat_lane_f32(*(float32x2_t *) &__reint_822, __p3_822); \
+ __ret_822 = vbfdot_f32(__s0_822, __s1_822, *(bfloat16x4_t *) &__reint1_822); \
+ __ret_822; \
+})
#else
-__ai float64x2_t vrndaq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vrndaq_v((int8x16_t)__rev0, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vbfdot_lane_f32(__p0_823, __p1_823, __p2_823, __p3_823) __extension__ ({ \
+ float32x2_t __ret_823; \
+ float32x2_t __s0_823 = __p0_823; \
+ bfloat16x4_t __s1_823 = __p1_823; \
+ bfloat16x4_t __s2_823 = __p2_823; \
+ float32x2_t __rev0_823; __rev0_823 = __builtin_shufflevector(__s0_823, __s0_823, 1, 0); \
+ bfloat16x4_t __rev1_823; __rev1_823 = __builtin_shufflevector(__s1_823, __s1_823, 3, 2, 1, 0); \
+ bfloat16x4_t __rev2_823; __rev2_823 = __builtin_shufflevector(__s2_823, __s2_823, 3, 2, 1, 0); \
+bfloat16x4_t __reint_823 = __rev2_823; \
+float32x2_t __reint1_823 = __noswap_splat_lane_f32(*(float32x2_t *) &__reint_823, __p3_823); \
+ __ret_823 = __noswap_vbfdot_f32(__rev0_823, __rev1_823, *(bfloat16x4_t *) &__reint1_823); \
+ __ret_823 = __builtin_shufflevector(__ret_823, __ret_823, 1, 0); \
+ __ret_823; \
+})
#endif
-__ai float64x1_t vrnda_f64(float64x1_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vrnda_v((int8x8_t)__p0, 10);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vrndiq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vrndiq_v((int8x16_t)__p0, 42);
- return __ret;
-}
+#define vbfdotq_laneq_f32(__p0_824, __p1_824, __p2_824, __p3_824) __extension__ ({ \
+ float32x4_t __ret_824; \
+ float32x4_t __s0_824 = __p0_824; \
+ bfloat16x8_t __s1_824 = __p1_824; \
+ bfloat16x8_t __s2_824 = __p2_824; \
+bfloat16x8_t __reint_824 = __s2_824; \
+float32x4_t __reint1_824 = splatq_laneq_f32(*(float32x4_t *) &__reint_824, __p3_824); \
+ __ret_824 = vbfdotq_f32(__s0_824, __s1_824, *(bfloat16x8_t *) &__reint1_824); \
+ __ret_824; \
+})
#else
-__ai float64x2_t vrndiq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vrndiq_v((int8x16_t)__rev0, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vbfdotq_laneq_f32(__p0_825, __p1_825, __p2_825, __p3_825) __extension__ ({ \
+ float32x4_t __ret_825; \
+ float32x4_t __s0_825 = __p0_825; \
+ bfloat16x8_t __s1_825 = __p1_825; \
+ bfloat16x8_t __s2_825 = __p2_825; \
+ float32x4_t __rev0_825; __rev0_825 = __builtin_shufflevector(__s0_825, __s0_825, 3, 2, 1, 0); \
+ bfloat16x8_t __rev1_825; __rev1_825 = __builtin_shufflevector(__s1_825, __s1_825, 7, 6, 5, 4, 3, 2, 1, 0); \
+ bfloat16x8_t __rev2_825; __rev2_825 = __builtin_shufflevector(__s2_825, __s2_825, 7, 6, 5, 4, 3, 2, 1, 0); \
+bfloat16x8_t __reint_825 = __rev2_825; \
+float32x4_t __reint1_825 = __noswap_splatq_laneq_f32(*(float32x4_t *) &__reint_825, __p3_825); \
+ __ret_825 = __noswap_vbfdotq_f32(__rev0_825, __rev1_825, *(bfloat16x8_t *) &__reint1_825); \
+ __ret_825 = __builtin_shufflevector(__ret_825, __ret_825, 3, 2, 1, 0); \
+ __ret_825; \
+})
#endif
-__ai float64x1_t vrndi_f64(float64x1_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vrndi_v((int8x8_t)__p0, 10);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vrndmq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vrndmq_v((int8x16_t)__p0, 42);
- return __ret;
-}
+#define vbfdot_laneq_f32(__p0_826, __p1_826, __p2_826, __p3_826) __extension__ ({ \
+ float32x2_t __ret_826; \
+ float32x2_t __s0_826 = __p0_826; \
+ bfloat16x4_t __s1_826 = __p1_826; \
+ bfloat16x8_t __s2_826 = __p2_826; \
+bfloat16x8_t __reint_826 = __s2_826; \
+float32x2_t __reint1_826 = splat_laneq_f32(*(float32x4_t *) &__reint_826, __p3_826); \
+ __ret_826 = vbfdot_f32(__s0_826, __s1_826, *(bfloat16x4_t *) &__reint1_826); \
+ __ret_826; \
+})
#else
-__ai float64x2_t vrndmq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vrndmq_v((int8x16_t)__rev0, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vbfdot_laneq_f32(__p0_827, __p1_827, __p2_827, __p3_827) __extension__ ({ \
+ float32x2_t __ret_827; \
+ float32x2_t __s0_827 = __p0_827; \
+ bfloat16x4_t __s1_827 = __p1_827; \
+ bfloat16x8_t __s2_827 = __p2_827; \
+ float32x2_t __rev0_827; __rev0_827 = __builtin_shufflevector(__s0_827, __s0_827, 1, 0); \
+ bfloat16x4_t __rev1_827; __rev1_827 = __builtin_shufflevector(__s1_827, __s1_827, 3, 2, 1, 0); \
+ bfloat16x8_t __rev2_827; __rev2_827 = __builtin_shufflevector(__s2_827, __s2_827, 7, 6, 5, 4, 3, 2, 1, 0); \
+bfloat16x8_t __reint_827 = __rev2_827; \
+float32x2_t __reint1_827 = __noswap_splat_laneq_f32(*(float32x4_t *) &__reint_827, __p3_827); \
+ __ret_827 = __noswap_vbfdot_f32(__rev0_827, __rev1_827, *(bfloat16x4_t *) &__reint1_827); \
+ __ret_827 = __builtin_shufflevector(__ret_827, __ret_827, 1, 0); \
+ __ret_827; \
+})
#endif
-__ai float64x1_t vrndm_f64(float64x1_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vrndm_v((int8x8_t)__p0, 10);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vrndnq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vrndnq_v((int8x16_t)__p0, 42);
- return __ret;
+#define vbfmlalbq_lane_f32(__p0_828, __p1_828, __p2_828, __p3_828) __extension__ ({ \
+ float32x4_t __ret_828; \
+ float32x4_t __s0_828 = __p0_828; \
+ bfloat16x8_t __s1_828 = __p1_828; \
+ bfloat16x4_t __s2_828 = __p2_828; \
+ __ret_828 = vbfmlalbq_f32(__s0_828, __s1_828, (bfloat16x8_t) {vget_lane_bf16(__s2_828, __p3_828), vget_lane_bf16(__s2_828, __p3_828), vget_lane_bf16(__s2_828, __p3_828), vget_lane_bf16(__s2_828, __p3_828), vget_lane_bf16(__s2_828, __p3_828), vget_lane_bf16(__s2_828, __p3_828), vget_lane_bf16(__s2_828, __p3_828), vget_lane_bf16(__s2_828, __p3_828)}); \
+ __ret_828; \
+})
+#else
+#define vbfmlalbq_lane_f32(__p0_829, __p1_829, __p2_829, __p3_829) __extension__ ({ \
+ float32x4_t __ret_829; \
+ float32x4_t __s0_829 = __p0_829; \
+ bfloat16x8_t __s1_829 = __p1_829; \
+ bfloat16x4_t __s2_829 = __p2_829; \
+ float32x4_t __rev0_829; __rev0_829 = __builtin_shufflevector(__s0_829, __s0_829, 3, 2, 1, 0); \
+ bfloat16x8_t __rev1_829; __rev1_829 = __builtin_shufflevector(__s1_829, __s1_829, 7, 6, 5, 4, 3, 2, 1, 0); \
+ bfloat16x4_t __rev2_829; __rev2_829 = __builtin_shufflevector(__s2_829, __s2_829, 3, 2, 1, 0); \
+ __ret_829 = __noswap_vbfmlalbq_f32(__rev0_829, __rev1_829, (bfloat16x8_t) {__noswap_vget_lane_bf16(__rev2_829, __p3_829), __noswap_vget_lane_bf16(__rev2_829, __p3_829), __noswap_vget_lane_bf16(__rev2_829, __p3_829), __noswap_vget_lane_bf16(__rev2_829, __p3_829), __noswap_vget_lane_bf16(__rev2_829, __p3_829), __noswap_vget_lane_bf16(__rev2_829, __p3_829), __noswap_vget_lane_bf16(__rev2_829, __p3_829), __noswap_vget_lane_bf16(__rev2_829, __p3_829)}); \
+ __ret_829 = __builtin_shufflevector(__ret_829, __ret_829, 3, 2, 1, 0); \
+ __ret_829; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vbfmlalbq_laneq_f32(__p0_830, __p1_830, __p2_830, __p3_830) __extension__ ({ \
+ float32x4_t __ret_830; \
+ float32x4_t __s0_830 = __p0_830; \
+ bfloat16x8_t __s1_830 = __p1_830; \
+ bfloat16x8_t __s2_830 = __p2_830; \
+ __ret_830 = vbfmlalbq_f32(__s0_830, __s1_830, (bfloat16x8_t) {vgetq_lane_bf16(__s2_830, __p3_830), vgetq_lane_bf16(__s2_830, __p3_830), vgetq_lane_bf16(__s2_830, __p3_830), vgetq_lane_bf16(__s2_830, __p3_830), vgetq_lane_bf16(__s2_830, __p3_830), vgetq_lane_bf16(__s2_830, __p3_830), vgetq_lane_bf16(__s2_830, __p3_830), vgetq_lane_bf16(__s2_830, __p3_830)}); \
+ __ret_830; \
+})
+#else
+#define vbfmlalbq_laneq_f32(__p0_831, __p1_831, __p2_831, __p3_831) __extension__ ({ \
+ float32x4_t __ret_831; \
+ float32x4_t __s0_831 = __p0_831; \
+ bfloat16x8_t __s1_831 = __p1_831; \
+ bfloat16x8_t __s2_831 = __p2_831; \
+ float32x4_t __rev0_831; __rev0_831 = __builtin_shufflevector(__s0_831, __s0_831, 3, 2, 1, 0); \
+ bfloat16x8_t __rev1_831; __rev1_831 = __builtin_shufflevector(__s1_831, __s1_831, 7, 6, 5, 4, 3, 2, 1, 0); \
+ bfloat16x8_t __rev2_831; __rev2_831 = __builtin_shufflevector(__s2_831, __s2_831, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_831 = __noswap_vbfmlalbq_f32(__rev0_831, __rev1_831, (bfloat16x8_t) {__noswap_vgetq_lane_bf16(__rev2_831, __p3_831), __noswap_vgetq_lane_bf16(__rev2_831, __p3_831), __noswap_vgetq_lane_bf16(__rev2_831, __p3_831), __noswap_vgetq_lane_bf16(__rev2_831, __p3_831), __noswap_vgetq_lane_bf16(__rev2_831, __p3_831), __noswap_vgetq_lane_bf16(__rev2_831, __p3_831), __noswap_vgetq_lane_bf16(__rev2_831, __p3_831), __noswap_vgetq_lane_bf16(__rev2_831, __p3_831)}); \
+ __ret_831 = __builtin_shufflevector(__ret_831, __ret_831, 3, 2, 1, 0); \
+ __ret_831; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vbfmlaltq_lane_f32(__p0_832, __p1_832, __p2_832, __p3_832) __extension__ ({ \
+ float32x4_t __ret_832; \
+ float32x4_t __s0_832 = __p0_832; \
+ bfloat16x8_t __s1_832 = __p1_832; \
+ bfloat16x4_t __s2_832 = __p2_832; \
+ __ret_832 = vbfmlaltq_f32(__s0_832, __s1_832, (bfloat16x8_t) {vget_lane_bf16(__s2_832, __p3_832), vget_lane_bf16(__s2_832, __p3_832), vget_lane_bf16(__s2_832, __p3_832), vget_lane_bf16(__s2_832, __p3_832), vget_lane_bf16(__s2_832, __p3_832), vget_lane_bf16(__s2_832, __p3_832), vget_lane_bf16(__s2_832, __p3_832), vget_lane_bf16(__s2_832, __p3_832)}); \
+ __ret_832; \
+})
+#else
+#define vbfmlaltq_lane_f32(__p0_833, __p1_833, __p2_833, __p3_833) __extension__ ({ \
+ float32x4_t __ret_833; \
+ float32x4_t __s0_833 = __p0_833; \
+ bfloat16x8_t __s1_833 = __p1_833; \
+ bfloat16x4_t __s2_833 = __p2_833; \
+ float32x4_t __rev0_833; __rev0_833 = __builtin_shufflevector(__s0_833, __s0_833, 3, 2, 1, 0); \
+ bfloat16x8_t __rev1_833; __rev1_833 = __builtin_shufflevector(__s1_833, __s1_833, 7, 6, 5, 4, 3, 2, 1, 0); \
+ bfloat16x4_t __rev2_833; __rev2_833 = __builtin_shufflevector(__s2_833, __s2_833, 3, 2, 1, 0); \
+ __ret_833 = __noswap_vbfmlaltq_f32(__rev0_833, __rev1_833, (bfloat16x8_t) {__noswap_vget_lane_bf16(__rev2_833, __p3_833), __noswap_vget_lane_bf16(__rev2_833, __p3_833), __noswap_vget_lane_bf16(__rev2_833, __p3_833), __noswap_vget_lane_bf16(__rev2_833, __p3_833), __noswap_vget_lane_bf16(__rev2_833, __p3_833), __noswap_vget_lane_bf16(__rev2_833, __p3_833), __noswap_vget_lane_bf16(__rev2_833, __p3_833), __noswap_vget_lane_bf16(__rev2_833, __p3_833)}); \
+ __ret_833 = __builtin_shufflevector(__ret_833, __ret_833, 3, 2, 1, 0); \
+ __ret_833; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vbfmlaltq_laneq_f32(__p0_834, __p1_834, __p2_834, __p3_834) __extension__ ({ \
+ float32x4_t __ret_834; \
+ float32x4_t __s0_834 = __p0_834; \
+ bfloat16x8_t __s1_834 = __p1_834; \
+ bfloat16x8_t __s2_834 = __p2_834; \
+ __ret_834 = vbfmlaltq_f32(__s0_834, __s1_834, (bfloat16x8_t) {vgetq_lane_bf16(__s2_834, __p3_834), vgetq_lane_bf16(__s2_834, __p3_834), vgetq_lane_bf16(__s2_834, __p3_834), vgetq_lane_bf16(__s2_834, __p3_834), vgetq_lane_bf16(__s2_834, __p3_834), vgetq_lane_bf16(__s2_834, __p3_834), vgetq_lane_bf16(__s2_834, __p3_834), vgetq_lane_bf16(__s2_834, __p3_834)}); \
+ __ret_834; \
+})
+#else
+#define vbfmlaltq_laneq_f32(__p0_835, __p1_835, __p2_835, __p3_835) __extension__ ({ \
+ float32x4_t __ret_835; \
+ float32x4_t __s0_835 = __p0_835; \
+ bfloat16x8_t __s1_835 = __p1_835; \
+ bfloat16x8_t __s2_835 = __p2_835; \
+ float32x4_t __rev0_835; __rev0_835 = __builtin_shufflevector(__s0_835, __s0_835, 3, 2, 1, 0); \
+ bfloat16x8_t __rev1_835; __rev1_835 = __builtin_shufflevector(__s1_835, __s1_835, 7, 6, 5, 4, 3, 2, 1, 0); \
+ bfloat16x8_t __rev2_835; __rev2_835 = __builtin_shufflevector(__s2_835, __s2_835, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_835 = __noswap_vbfmlaltq_f32(__rev0_835, __rev1_835, (bfloat16x8_t) {__noswap_vgetq_lane_bf16(__rev2_835, __p3_835), __noswap_vgetq_lane_bf16(__rev2_835, __p3_835), __noswap_vgetq_lane_bf16(__rev2_835, __p3_835), __noswap_vgetq_lane_bf16(__rev2_835, __p3_835), __noswap_vgetq_lane_bf16(__rev2_835, __p3_835), __noswap_vgetq_lane_bf16(__rev2_835, __p3_835), __noswap_vgetq_lane_bf16(__rev2_835, __p3_835), __noswap_vgetq_lane_bf16(__rev2_835, __p3_835)}); \
+ __ret_835 = __builtin_shufflevector(__ret_835, __ret_835, 3, 2, 1, 0); \
+ __ret_835; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) float32x4_t vcvt_f32_bf16(bfloat16x4_t __p0_836) {
+ float32x4_t __ret_836;
+bfloat16x4_t __reint_836 = __p0_836;
+int32x4_t __reint1_836 = vshll_n_s16(*(int16x4_t *) &__reint_836, 16);
+ __ret_836 = *(float32x4_t *) &__reint1_836;
+ return __ret_836;
}
#else
-__ai float64x2_t vrndnq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vrndnq_v((int8x16_t)__rev0, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
+__ai __attribute__((target("bf16,neon"))) float32x4_t vcvt_f32_bf16(bfloat16x4_t __p0_837) {
+ float32x4_t __ret_837;
+ bfloat16x4_t __rev0_837; __rev0_837 = __builtin_shufflevector(__p0_837, __p0_837, 3, 2, 1, 0);
+bfloat16x4_t __reint_837 = __rev0_837;
+int32x4_t __reint1_837 = __noswap_vshll_n_s16(*(int16x4_t *) &__reint_837, 16);
+ __ret_837 = *(float32x4_t *) &__reint1_837;
+ __ret_837 = __builtin_shufflevector(__ret_837, __ret_837, 3, 2, 1, 0);
+ return __ret_837;
+}
+__ai __attribute__((target("bf16,neon"))) float32x4_t __noswap_vcvt_f32_bf16(bfloat16x4_t __p0_838) {
+ float32x4_t __ret_838;
+bfloat16x4_t __reint_838 = __p0_838;
+int32x4_t __reint1_838 = __noswap_vshll_n_s16(*(int16x4_t *) &__reint_838, 16);
+ __ret_838 = *(float32x4_t *) &__reint1_838;
+ return __ret_838;
}
#endif
-__ai float64x1_t vrndn_f64(float64x1_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vrndn_v((int8x8_t)__p0, 10);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vrndpq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vrndpq_v((int8x16_t)__p0, 42);
+__ai __attribute__((target("bf16,neon"))) float32x4_t vcvtq_high_f32_bf16(bfloat16x8_t __p0) {
+ float32x4_t __ret;
+ __ret = vcvt_f32_bf16(vget_high_bf16(__p0));
return __ret;
}
#else
-__ai float64x2_t vrndpq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vrndpq_v((int8x16_t)__rev0, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("bf16,neon"))) float32x4_t vcvtq_high_f32_bf16(bfloat16x8_t __p0) {
+ float32x4_t __ret;
+ bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vcvt_f32_bf16(__noswap_vget_high_bf16(__rev0));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai float64x1_t vrndp_f64(float64x1_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vrndp_v((int8x8_t)__p0, 10);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vrndxq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vrndxq_v((int8x16_t)__p0, 42);
+__ai __attribute__((target("bf16,neon"))) float32x4_t vcvtq_low_f32_bf16(bfloat16x8_t __p0) {
+ float32x4_t __ret;
+ __ret = vcvt_f32_bf16(vget_low_bf16(__p0));
return __ret;
}
#else
-__ai float64x2_t vrndxq_f64(float64x2_t __p0) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vrndxq_v((int8x16_t)__rev0, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+__ai __attribute__((target("bf16,neon"))) float32x4_t vcvtq_low_f32_bf16(bfloat16x8_t __p0) {
+ float32x4_t __ret;
+ bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+ __ret = __noswap_vcvt_f32_bf16(__noswap_vget_low_bf16(__rev0));
+ __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
#endif
-__ai float64x1_t vrndx_f64(float64x1_t __p0) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vrndx_v((int8x8_t)__p0, 10);
- return __ret;
-}
+#ifdef __LITTLE_ENDIAN__
+#define vdotq_lane_u32(__p0_839, __p1_839, __p2_839, __p3_839) __extension__ ({ \
+ uint32x4_t __ret_839; \
+ uint32x4_t __s0_839 = __p0_839; \
+ uint8x16_t __s1_839 = __p1_839; \
+ uint8x8_t __s2_839 = __p2_839; \
+uint8x8_t __reint_839 = __s2_839; \
+uint32x4_t __reint1_839 = splatq_lane_u32(*(uint32x2_t *) &__reint_839, __p3_839); \
+ __ret_839 = vdotq_u32(__s0_839, __s1_839, *(uint8x16_t *) &__reint1_839); \
+ __ret_839; \
+})
+#else
+#define vdotq_lane_u32(__p0_840, __p1_840, __p2_840, __p3_840) __extension__ ({ \
+ uint32x4_t __ret_840; \
+ uint32x4_t __s0_840 = __p0_840; \
+ uint8x16_t __s1_840 = __p1_840; \
+ uint8x8_t __s2_840 = __p2_840; \
+ uint32x4_t __rev0_840; __rev0_840 = __builtin_shufflevector(__s0_840, __s0_840, 3, 2, 1, 0); \
+ uint8x16_t __rev1_840; __rev1_840 = __builtin_shufflevector(__s1_840, __s1_840, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x8_t __rev2_840; __rev2_840 = __builtin_shufflevector(__s2_840, __s2_840, 7, 6, 5, 4, 3, 2, 1, 0); \
+uint8x8_t __reint_840 = __rev2_840; \
+uint32x4_t __reint1_840 = __noswap_splatq_lane_u32(*(uint32x2_t *) &__reint_840, __p3_840); \
+ __ret_840 = __noswap_vdotq_u32(__rev0_840, __rev1_840, *(uint8x16_t *) &__reint1_840); \
+ __ret_840 = __builtin_shufflevector(__ret_840, __ret_840, 3, 2, 1, 0); \
+ __ret_840; \
+})
#endif
-#if defined(__aarch64__) && defined(__ARM_FEATURE_NUMERIC_MAXMIN)
+
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vmaxnmq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vmaxnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
- return __ret;
-}
+#define vdotq_lane_s32(__p0_841, __p1_841, __p2_841, __p3_841) __extension__ ({ \
+ int32x4_t __ret_841; \
+ int32x4_t __s0_841 = __p0_841; \
+ int8x16_t __s1_841 = __p1_841; \
+ int8x8_t __s2_841 = __p2_841; \
+int8x8_t __reint_841 = __s2_841; \
+int32x4_t __reint1_841 = splatq_lane_s32(*(int32x2_t *) &__reint_841, __p3_841); \
+ __ret_841 = vdotq_s32(__s0_841, __s1_841, *(int8x16_t *) &__reint1_841); \
+ __ret_841; \
+})
#else
-__ai float64x2_t vmaxnmq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vmaxnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vdotq_lane_s32(__p0_842, __p1_842, __p2_842, __p3_842) __extension__ ({ \
+ int32x4_t __ret_842; \
+ int32x4_t __s0_842 = __p0_842; \
+ int8x16_t __s1_842 = __p1_842; \
+ int8x8_t __s2_842 = __p2_842; \
+ int32x4_t __rev0_842; __rev0_842 = __builtin_shufflevector(__s0_842, __s0_842, 3, 2, 1, 0); \
+ int8x16_t __rev1_842; __rev1_842 = __builtin_shufflevector(__s1_842, __s1_842, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x8_t __rev2_842; __rev2_842 = __builtin_shufflevector(__s2_842, __s2_842, 7, 6, 5, 4, 3, 2, 1, 0); \
+int8x8_t __reint_842 = __rev2_842; \
+int32x4_t __reint1_842 = __noswap_splatq_lane_s32(*(int32x2_t *) &__reint_842, __p3_842); \
+ __ret_842 = __noswap_vdotq_s32(__rev0_842, __rev1_842, *(int8x16_t *) &__reint1_842); \
+ __ret_842 = __builtin_shufflevector(__ret_842, __ret_842, 3, 2, 1, 0); \
+ __ret_842; \
+})
#endif
-__ai float64x1_t vmaxnm_f64(float64x1_t __p0, float64x1_t __p1) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vmaxnm_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
- return __ret;
-}
#ifdef __LITTLE_ENDIAN__
-__ai float64x2_t vminnmq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- __ret = (float64x2_t) __builtin_neon_vminnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
- return __ret;
-}
+#define vdot_lane_u32(__p0_843, __p1_843, __p2_843, __p3_843) __extension__ ({ \
+ uint32x2_t __ret_843; \
+ uint32x2_t __s0_843 = __p0_843; \
+ uint8x8_t __s1_843 = __p1_843; \
+ uint8x8_t __s2_843 = __p2_843; \
+uint8x8_t __reint_843 = __s2_843; \
+uint32x2_t __reint1_843 = splat_lane_u32(*(uint32x2_t *) &__reint_843, __p3_843); \
+ __ret_843 = vdot_u32(__s0_843, __s1_843, *(uint8x8_t *) &__reint1_843); \
+ __ret_843; \
+})
#else
-__ai float64x2_t vminnmq_f64(float64x2_t __p0, float64x2_t __p1) {
- float64x2_t __ret;
- float64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
- float64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
- __ret = (float64x2_t) __builtin_neon_vminnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
- __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
- return __ret;
-}
+#define vdot_lane_u32(__p0_844, __p1_844, __p2_844, __p3_844) __extension__ ({ \
+ uint32x2_t __ret_844; \
+ uint32x2_t __s0_844 = __p0_844; \
+ uint8x8_t __s1_844 = __p1_844; \
+ uint8x8_t __s2_844 = __p2_844; \
+ uint32x2_t __rev0_844; __rev0_844 = __builtin_shufflevector(__s0_844, __s0_844, 1, 0); \
+ uint8x8_t __rev1_844; __rev1_844 = __builtin_shufflevector(__s1_844, __s1_844, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x8_t __rev2_844; __rev2_844 = __builtin_shufflevector(__s2_844, __s2_844, 7, 6, 5, 4, 3, 2, 1, 0); \
+uint8x8_t __reint_844 = __rev2_844; \
+uint32x2_t __reint1_844 = __noswap_splat_lane_u32(*(uint32x2_t *) &__reint_844, __p3_844); \
+ __ret_844 = __noswap_vdot_u32(__rev0_844, __rev1_844, *(uint8x8_t *) &__reint1_844); \
+ __ret_844 = __builtin_shufflevector(__ret_844, __ret_844, 1, 0); \
+ __ret_844; \
+})
#endif
-__ai float64x1_t vminnm_f64(float64x1_t __p0, float64x1_t __p1) {
- float64x1_t __ret;
- __ret = (float64x1_t) __builtin_neon_vminnm_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
- return __ret;
-}
+#ifdef __LITTLE_ENDIAN__
+#define vdot_lane_s32(__p0_845, __p1_845, __p2_845, __p3_845) __extension__ ({ \
+ int32x2_t __ret_845; \
+ int32x2_t __s0_845 = __p0_845; \
+ int8x8_t __s1_845 = __p1_845; \
+ int8x8_t __s2_845 = __p2_845; \
+int8x8_t __reint_845 = __s2_845; \
+int32x2_t __reint1_845 = splat_lane_s32(*(int32x2_t *) &__reint_845, __p3_845); \
+ __ret_845 = vdot_s32(__s0_845, __s1_845, *(int8x8_t *) &__reint1_845); \
+ __ret_845; \
+})
+#else
+#define vdot_lane_s32(__p0_846, __p1_846, __p2_846, __p3_846) __extension__ ({ \
+ int32x2_t __ret_846; \
+ int32x2_t __s0_846 = __p0_846; \
+ int8x8_t __s1_846 = __p1_846; \
+ int8x8_t __s2_846 = __p2_846; \
+ int32x2_t __rev0_846; __rev0_846 = __builtin_shufflevector(__s0_846, __s0_846, 1, 0); \
+ int8x8_t __rev1_846; __rev1_846 = __builtin_shufflevector(__s1_846, __s1_846, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x8_t __rev2_846; __rev2_846 = __builtin_shufflevector(__s2_846, __s2_846, 7, 6, 5, 4, 3, 2, 1, 0); \
+int8x8_t __reint_846 = __rev2_846; \
+int32x2_t __reint1_846 = __noswap_splat_lane_s32(*(int32x2_t *) &__reint_846, __p3_846); \
+ __ret_846 = __noswap_vdot_s32(__rev0_846, __rev1_846, *(int8x8_t *) &__reint1_846); \
+ __ret_846 = __builtin_shufflevector(__ret_846, __ret_846, 1, 0); \
+ __ret_846; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulq_lane_f16(__p0_847, __p1_847, __p2_847) __extension__ ({ \
+ float16x8_t __ret_847; \
+ float16x8_t __s0_847 = __p0_847; \
+ float16x4_t __s1_847 = __p1_847; \
+ __ret_847 = __s0_847 * splatq_lane_f16(__s1_847, __p2_847); \
+ __ret_847; \
+})
+#else
+#define vmulq_lane_f16(__p0_848, __p1_848, __p2_848) __extension__ ({ \
+ float16x8_t __ret_848; \
+ float16x8_t __s0_848 = __p0_848; \
+ float16x4_t __s1_848 = __p1_848; \
+ float16x8_t __rev0_848; __rev0_848 = __builtin_shufflevector(__s0_848, __s0_848, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x4_t __rev1_848; __rev1_848 = __builtin_shufflevector(__s1_848, __s1_848, 3, 2, 1, 0); \
+ __ret_848 = __rev0_848 * __noswap_splatq_lane_f16(__rev1_848, __p2_848); \
+ __ret_848 = __builtin_shufflevector(__ret_848, __ret_848, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_848; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmul_lane_f16(__p0_849, __p1_849, __p2_849) __extension__ ({ \
+ float16x4_t __ret_849; \
+ float16x4_t __s0_849 = __p0_849; \
+ float16x4_t __s1_849 = __p1_849; \
+ __ret_849 = __s0_849 * splat_lane_f16(__s1_849, __p2_849); \
+ __ret_849; \
+})
+#else
+#define vmul_lane_f16(__p0_850, __p1_850, __p2_850) __extension__ ({ \
+ float16x4_t __ret_850; \
+ float16x4_t __s0_850 = __p0_850; \
+ float16x4_t __s1_850 = __p1_850; \
+ float16x4_t __rev0_850; __rev0_850 = __builtin_shufflevector(__s0_850, __s0_850, 3, 2, 1, 0); \
+ float16x4_t __rev1_850; __rev1_850 = __builtin_shufflevector(__s1_850, __s1_850, 3, 2, 1, 0); \
+ __ret_850 = __rev0_850 * __noswap_splat_lane_f16(__rev1_850, __p2_850); \
+ __ret_850 = __builtin_shufflevector(__ret_850, __ret_850, 3, 2, 1, 0); \
+ __ret_850; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsudotq_lane_s32(__p0_851, __p1_851, __p2_851, __p3_851) __extension__ ({ \
+ int32x4_t __ret_851; \
+ int32x4_t __s0_851 = __p0_851; \
+ int8x16_t __s1_851 = __p1_851; \
+ uint8x8_t __s2_851 = __p2_851; \
+uint8x8_t __reint_851 = __s2_851; \
+ __ret_851 = vusdotq_s32(__s0_851, (uint8x16_t)(splatq_lane_s32(*(int32x2_t *) &__reint_851, __p3_851)), __s1_851); \
+ __ret_851; \
+})
+#else
+#define vsudotq_lane_s32(__p0_852, __p1_852, __p2_852, __p3_852) __extension__ ({ \
+ int32x4_t __ret_852; \
+ int32x4_t __s0_852 = __p0_852; \
+ int8x16_t __s1_852 = __p1_852; \
+ uint8x8_t __s2_852 = __p2_852; \
+ int32x4_t __rev0_852; __rev0_852 = __builtin_shufflevector(__s0_852, __s0_852, 3, 2, 1, 0); \
+ int8x16_t __rev1_852; __rev1_852 = __builtin_shufflevector(__s1_852, __s1_852, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x8_t __rev2_852; __rev2_852 = __builtin_shufflevector(__s2_852, __s2_852, 7, 6, 5, 4, 3, 2, 1, 0); \
+uint8x8_t __reint_852 = __rev2_852; \
+ __ret_852 = __noswap_vusdotq_s32(__rev0_852, (uint8x16_t)(__noswap_splatq_lane_s32(*(int32x2_t *) &__reint_852, __p3_852)), __rev1_852); \
+ __ret_852 = __builtin_shufflevector(__ret_852, __ret_852, 3, 2, 1, 0); \
+ __ret_852; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsudot_lane_s32(__p0_853, __p1_853, __p2_853, __p3_853) __extension__ ({ \
+ int32x2_t __ret_853; \
+ int32x2_t __s0_853 = __p0_853; \
+ int8x8_t __s1_853 = __p1_853; \
+ uint8x8_t __s2_853 = __p2_853; \
+uint8x8_t __reint_853 = __s2_853; \
+ __ret_853 = vusdot_s32(__s0_853, (uint8x8_t)(splat_lane_s32(*(int32x2_t *) &__reint_853, __p3_853)), __s1_853); \
+ __ret_853; \
+})
+#else
+#define vsudot_lane_s32(__p0_854, __p1_854, __p2_854, __p3_854) __extension__ ({ \
+ int32x2_t __ret_854; \
+ int32x2_t __s0_854 = __p0_854; \
+ int8x8_t __s1_854 = __p1_854; \
+ uint8x8_t __s2_854 = __p2_854; \
+ int32x2_t __rev0_854; __rev0_854 = __builtin_shufflevector(__s0_854, __s0_854, 1, 0); \
+ int8x8_t __rev1_854; __rev1_854 = __builtin_shufflevector(__s1_854, __s1_854, 7, 6, 5, 4, 3, 2, 1, 0); \
+ uint8x8_t __rev2_854; __rev2_854 = __builtin_shufflevector(__s2_854, __s2_854, 7, 6, 5, 4, 3, 2, 1, 0); \
+uint8x8_t __reint_854 = __rev2_854; \
+ __ret_854 = __noswap_vusdot_s32(__rev0_854, (uint8x8_t)(__noswap_splat_lane_s32(*(int32x2_t *) &__reint_854, __p3_854)), __rev1_854); \
+ __ret_854 = __builtin_shufflevector(__ret_854, __ret_854, 1, 0); \
+ __ret_854; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vusdotq_lane_s32(__p0_855, __p1_855, __p2_855, __p3_855) __extension__ ({ \
+ int32x4_t __ret_855; \
+ int32x4_t __s0_855 = __p0_855; \
+ uint8x16_t __s1_855 = __p1_855; \
+ int8x8_t __s2_855 = __p2_855; \
+int8x8_t __reint_855 = __s2_855; \
+ __ret_855 = vusdotq_s32(__s0_855, __s1_855, (int8x16_t)(splatq_lane_s32(*(int32x2_t *) &__reint_855, __p3_855))); \
+ __ret_855; \
+})
+#else
+#define vusdotq_lane_s32(__p0_856, __p1_856, __p2_856, __p3_856) __extension__ ({ \
+ int32x4_t __ret_856; \
+ int32x4_t __s0_856 = __p0_856; \
+ uint8x16_t __s1_856 = __p1_856; \
+ int8x8_t __s2_856 = __p2_856; \
+ int32x4_t __rev0_856; __rev0_856 = __builtin_shufflevector(__s0_856, __s0_856, 3, 2, 1, 0); \
+ uint8x16_t __rev1_856; __rev1_856 = __builtin_shufflevector(__s1_856, __s1_856, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x8_t __rev2_856; __rev2_856 = __builtin_shufflevector(__s2_856, __s2_856, 7, 6, 5, 4, 3, 2, 1, 0); \
+int8x8_t __reint_856 = __rev2_856; \
+ __ret_856 = __noswap_vusdotq_s32(__rev0_856, __rev1_856, (int8x16_t)(__noswap_splatq_lane_s32(*(int32x2_t *) &__reint_856, __p3_856))); \
+ __ret_856 = __builtin_shufflevector(__ret_856, __ret_856, 3, 2, 1, 0); \
+ __ret_856; \
+})
#endif
+
#ifdef __LITTLE_ENDIAN__
-__ai uint8x16_t vabaq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+#define vusdot_lane_s32(__p0_857, __p1_857, __p2_857, __p3_857) __extension__ ({ \
+ int32x2_t __ret_857; \
+ int32x2_t __s0_857 = __p0_857; \
+ uint8x8_t __s1_857 = __p1_857; \
+ int8x8_t __s2_857 = __p2_857; \
+int8x8_t __reint_857 = __s2_857; \
+ __ret_857 = vusdot_s32(__s0_857, __s1_857, (int8x8_t)(splat_lane_s32(*(int32x2_t *) &__reint_857, __p3_857))); \
+ __ret_857; \
+})
+#else
+#define vusdot_lane_s32(__p0_858, __p1_858, __p2_858, __p3_858) __extension__ ({ \
+ int32x2_t __ret_858; \
+ int32x2_t __s0_858 = __p0_858; \
+ uint8x8_t __s1_858 = __p1_858; \
+ int8x8_t __s2_858 = __p2_858; \
+ int32x2_t __rev0_858; __rev0_858 = __builtin_shufflevector(__s0_858, __s0_858, 1, 0); \
+ uint8x8_t __rev1_858; __rev1_858 = __builtin_shufflevector(__s1_858, __s1_858, 7, 6, 5, 4, 3, 2, 1, 0); \
+ int8x8_t __rev2_858; __rev2_858 = __builtin_shufflevector(__s2_858, __s2_858, 7, 6, 5, 4, 3, 2, 1, 0); \
+int8x8_t __reint_858 = __rev2_858; \
+ __ret_858 = __noswap_vusdot_s32(__rev0_858, __rev1_858, (int8x8_t)(__noswap_splat_lane_s32(*(int32x2_t *) &__reint_858, __p3_858))); \
+ __ret_858 = __builtin_shufflevector(__ret_858, __ret_858, 1, 0); \
+ __ret_858; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vabaq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint8x16_t __ret;
__ret = __p0 + vabdq_u8(__p1, __p2);
return __ret;
}
#else
-__ai uint8x16_t vabaq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+__ai __attribute__((target("neon"))) uint8x16_t vabaq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint8x16_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -66669,13 +66829,13 @@ __ai uint8x16_t vabaq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vabaq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vabaq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
__ret = __p0 + vabdq_u32(__p1, __p2);
return __ret;
}
#else
-__ai uint32x4_t vabaq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vabaq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -66687,13 +66847,13 @@ __ai uint32x4_t vabaq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vabaq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+__ai __attribute__((target("neon"))) uint16x8_t vabaq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
uint16x8_t __ret;
__ret = __p0 + vabdq_u16(__p1, __p2);
return __ret;
}
#else
-__ai uint16x8_t vabaq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+__ai __attribute__((target("neon"))) uint16x8_t vabaq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -66705,13 +66865,13 @@ __ai uint16x8_t vabaq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x16_t vabaq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
+__ai __attribute__((target("neon"))) int8x16_t vabaq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
int8x16_t __ret;
__ret = __p0 + vabdq_s8(__p1, __p2);
return __ret;
}
#else
-__ai int8x16_t vabaq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
+__ai __attribute__((target("neon"))) int8x16_t vabaq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
int8x16_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -66723,13 +66883,13 @@ __ai int8x16_t vabaq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vabaq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vabaq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
int32x4_t __ret;
__ret = __p0 + vabdq_s32(__p1, __p2);
return __ret;
}
#else
-__ai int32x4_t vabaq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vabaq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -66741,13 +66901,13 @@ __ai int32x4_t vabaq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vabaq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+__ai __attribute__((target("neon"))) int16x8_t vabaq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
int16x8_t __ret;
__ret = __p0 + vabdq_s16(__p1, __p2);
return __ret;
}
#else
-__ai int16x8_t vabaq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+__ai __attribute__((target("neon"))) int16x8_t vabaq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -66759,13 +66919,13 @@ __ai int16x8_t vabaq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint8x8_t vaba_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+__ai __attribute__((target("neon"))) uint8x8_t vaba_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint8x8_t __ret;
__ret = __p0 + vabd_u8(__p1, __p2);
return __ret;
}
#else
-__ai uint8x8_t vaba_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+__ai __attribute__((target("neon"))) uint8x8_t vaba_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint8x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -66777,13 +66937,13 @@ __ai uint8x8_t vaba_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x2_t vaba_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+__ai __attribute__((target("neon"))) uint32x2_t vaba_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
uint32x2_t __ret;
__ret = __p0 + vabd_u32(__p1, __p2);
return __ret;
}
#else
-__ai uint32x2_t vaba_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+__ai __attribute__((target("neon"))) uint32x2_t vaba_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
uint32x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -66795,13 +66955,13 @@ __ai uint32x2_t vaba_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x4_t vaba_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+__ai __attribute__((target("neon"))) uint16x4_t vaba_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
uint16x4_t __ret;
__ret = __p0 + vabd_u16(__p1, __p2);
return __ret;
}
#else
-__ai uint16x4_t vaba_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+__ai __attribute__((target("neon"))) uint16x4_t vaba_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
uint16x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -66813,13 +66973,13 @@ __ai uint16x4_t vaba_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int8x8_t vaba_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+__ai __attribute__((target("neon"))) int8x8_t vaba_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
int8x8_t __ret;
__ret = __p0 + vabd_s8(__p1, __p2);
return __ret;
}
#else
-__ai int8x8_t vaba_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+__ai __attribute__((target("neon"))) int8x8_t vaba_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
int8x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -66831,13 +66991,13 @@ __ai int8x8_t vaba_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x2_t vaba_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+__ai __attribute__((target("neon"))) int32x2_t vaba_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int32x2_t __ret;
__ret = __p0 + vabd_s32(__p1, __p2);
return __ret;
}
#else
-__ai int32x2_t vaba_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+__ai __attribute__((target("neon"))) int32x2_t vaba_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int32x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -66849,13 +67009,13 @@ __ai int32x2_t vaba_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x4_t vaba_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+__ai __attribute__((target("neon"))) int16x4_t vaba_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
int16x4_t __ret;
__ret = __p0 + vabd_s16(__p1, __p2);
return __ret;
}
#else
-__ai int16x4_t vaba_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+__ai __attribute__((target("neon"))) int16x4_t vaba_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
int16x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -66867,13 +67027,13 @@ __ai int16x4_t vaba_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vabdl_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vabdl_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint16x8_t __ret;
__ret = (uint16x8_t)(vmovl_u8((uint8x8_t)(vabd_u8(__p0, __p1))));
return __ret;
}
#else
-__ai uint16x8_t vabdl_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vabdl_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint16x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -66881,7 +67041,7 @@ __ai uint16x8_t vabdl_u8(uint8x8_t __p0, uint8x8_t __p1) {
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai uint16x8_t __noswap_vabdl_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t __noswap_vabdl_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint16x8_t __ret;
__ret = (uint16x8_t)(__noswap_vmovl_u8((uint8x8_t)(__noswap_vabd_u8(__p0, __p1))));
return __ret;
@@ -66889,13 +67049,13 @@ __ai uint16x8_t __noswap_vabdl_u8(uint8x8_t __p0, uint8x8_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vabdl_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vabdl_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint64x2_t __ret;
__ret = (uint64x2_t)(vmovl_u32((uint32x2_t)(vabd_u32(__p0, __p1))));
return __ret;
}
#else
-__ai uint64x2_t vabdl_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vabdl_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint64x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -66903,7 +67063,7 @@ __ai uint64x2_t vabdl_u32(uint32x2_t __p0, uint32x2_t __p1) {
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai uint64x2_t __noswap_vabdl_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vabdl_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint64x2_t __ret;
__ret = (uint64x2_t)(__noswap_vmovl_u32((uint32x2_t)(__noswap_vabd_u32(__p0, __p1))));
return __ret;
@@ -66911,13 +67071,13 @@ __ai uint64x2_t __noswap_vabdl_u32(uint32x2_t __p0, uint32x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vabdl_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vabdl_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint32x4_t __ret;
__ret = (uint32x4_t)(vmovl_u16((uint16x4_t)(vabd_u16(__p0, __p1))));
return __ret;
}
#else
-__ai uint32x4_t vabdl_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vabdl_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint32x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -66925,7 +67085,7 @@ __ai uint32x4_t vabdl_u16(uint16x4_t __p0, uint16x4_t __p1) {
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai uint32x4_t __noswap_vabdl_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vabdl_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint32x4_t __ret;
__ret = (uint32x4_t)(__noswap_vmovl_u16((uint16x4_t)(__noswap_vabd_u16(__p0, __p1))));
return __ret;
@@ -66933,13 +67093,13 @@ __ai uint32x4_t __noswap_vabdl_u16(uint16x4_t __p0, uint16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vabdl_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vabdl_s8(int8x8_t __p0, int8x8_t __p1) {
int16x8_t __ret;
__ret = (int16x8_t)(vmovl_u8((uint8x8_t)(vabd_s8(__p0, __p1))));
return __ret;
}
#else
-__ai int16x8_t vabdl_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vabdl_s8(int8x8_t __p0, int8x8_t __p1) {
int16x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -66947,7 +67107,7 @@ __ai int16x8_t vabdl_s8(int8x8_t __p0, int8x8_t __p1) {
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai int16x8_t __noswap_vabdl_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vabdl_s8(int8x8_t __p0, int8x8_t __p1) {
int16x8_t __ret;
__ret = (int16x8_t)(__noswap_vmovl_u8((uint8x8_t)(__noswap_vabd_s8(__p0, __p1))));
return __ret;
@@ -66955,13 +67115,13 @@ __ai int16x8_t __noswap_vabdl_s8(int8x8_t __p0, int8x8_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vabdl_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vabdl_s32(int32x2_t __p0, int32x2_t __p1) {
int64x2_t __ret;
__ret = (int64x2_t)(vmovl_u32((uint32x2_t)(vabd_s32(__p0, __p1))));
return __ret;
}
#else
-__ai int64x2_t vabdl_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vabdl_s32(int32x2_t __p0, int32x2_t __p1) {
int64x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -66969,7 +67129,7 @@ __ai int64x2_t vabdl_s32(int32x2_t __p0, int32x2_t __p1) {
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai int64x2_t __noswap_vabdl_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vabdl_s32(int32x2_t __p0, int32x2_t __p1) {
int64x2_t __ret;
__ret = (int64x2_t)(__noswap_vmovl_u32((uint32x2_t)(__noswap_vabd_s32(__p0, __p1))));
return __ret;
@@ -66977,13 +67137,13 @@ __ai int64x2_t __noswap_vabdl_s32(int32x2_t __p0, int32x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vabdl_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vabdl_s16(int16x4_t __p0, int16x4_t __p1) {
int32x4_t __ret;
__ret = (int32x4_t)(vmovl_u16((uint16x4_t)(vabd_s16(__p0, __p1))));
return __ret;
}
#else
-__ai int32x4_t vabdl_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vabdl_s16(int16x4_t __p0, int16x4_t __p1) {
int32x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -66991,7 +67151,7 @@ __ai int32x4_t vabdl_s16(int16x4_t __p0, int16x4_t __p1) {
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int32x4_t __noswap_vabdl_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vabdl_s16(int16x4_t __p0, int16x4_t __p1) {
int32x4_t __ret;
__ret = (int32x4_t)(__noswap_vmovl_u16((uint16x4_t)(__noswap_vabd_s16(__p0, __p1))));
return __ret;
@@ -66999,13 +67159,13 @@ __ai int32x4_t __noswap_vabdl_s16(int16x4_t __p0, int16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vaddl_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vaddl_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint16x8_t __ret;
__ret = vmovl_u8(__p0) + vmovl_u8(__p1);
return __ret;
}
#else
-__ai uint16x8_t vaddl_u8(uint8x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vaddl_u8(uint8x8_t __p0, uint8x8_t __p1) {
uint16x8_t __ret;
uint8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -67016,13 +67176,13 @@ __ai uint16x8_t vaddl_u8(uint8x8_t __p0, uint8x8_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vaddl_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vaddl_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint64x2_t __ret;
__ret = vmovl_u32(__p0) + vmovl_u32(__p1);
return __ret;
}
#else
-__ai uint64x2_t vaddl_u32(uint32x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vaddl_u32(uint32x2_t __p0, uint32x2_t __p1) {
uint64x2_t __ret;
uint32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -67033,13 +67193,13 @@ __ai uint64x2_t vaddl_u32(uint32x2_t __p0, uint32x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vaddl_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vaddl_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint32x4_t __ret;
__ret = vmovl_u16(__p0) + vmovl_u16(__p1);
return __ret;
}
#else
-__ai uint32x4_t vaddl_u16(uint16x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vaddl_u16(uint16x4_t __p0, uint16x4_t __p1) {
uint32x4_t __ret;
uint16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -67050,13 +67210,13 @@ __ai uint32x4_t vaddl_u16(uint16x4_t __p0, uint16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vaddl_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vaddl_s8(int8x8_t __p0, int8x8_t __p1) {
int16x8_t __ret;
__ret = vmovl_s8(__p0) + vmovl_s8(__p1);
return __ret;
}
#else
-__ai int16x8_t vaddl_s8(int8x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vaddl_s8(int8x8_t __p0, int8x8_t __p1) {
int16x8_t __ret;
int8x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -67067,13 +67227,13 @@ __ai int16x8_t vaddl_s8(int8x8_t __p0, int8x8_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vaddl_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vaddl_s32(int32x2_t __p0, int32x2_t __p1) {
int64x2_t __ret;
__ret = vmovl_s32(__p0) + vmovl_s32(__p1);
return __ret;
}
#else
-__ai int64x2_t vaddl_s32(int32x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vaddl_s32(int32x2_t __p0, int32x2_t __p1) {
int64x2_t __ret;
int32x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -67084,13 +67244,13 @@ __ai int64x2_t vaddl_s32(int32x2_t __p0, int32x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vaddl_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vaddl_s16(int16x4_t __p0, int16x4_t __p1) {
int32x4_t __ret;
__ret = vmovl_s16(__p0) + vmovl_s16(__p1);
return __ret;
}
#else
-__ai int32x4_t vaddl_s16(int16x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vaddl_s16(int16x4_t __p0, int16x4_t __p1) {
int32x4_t __ret;
int16x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -67101,13 +67261,13 @@ __ai int32x4_t vaddl_s16(int16x4_t __p0, int16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vaddw_u8(uint16x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vaddw_u8(uint16x8_t __p0, uint8x8_t __p1) {
uint16x8_t __ret;
__ret = __p0 + vmovl_u8(__p1);
return __ret;
}
#else
-__ai uint16x8_t vaddw_u8(uint16x8_t __p0, uint8x8_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vaddw_u8(uint16x8_t __p0, uint8x8_t __p1) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -67118,13 +67278,13 @@ __ai uint16x8_t vaddw_u8(uint16x8_t __p0, uint8x8_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vaddw_u32(uint64x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vaddw_u32(uint64x2_t __p0, uint32x2_t __p1) {
uint64x2_t __ret;
__ret = __p0 + vmovl_u32(__p1);
return __ret;
}
#else
-__ai uint64x2_t vaddw_u32(uint64x2_t __p0, uint32x2_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vaddw_u32(uint64x2_t __p0, uint32x2_t __p1) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -67135,13 +67295,13 @@ __ai uint64x2_t vaddw_u32(uint64x2_t __p0, uint32x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vaddw_u16(uint32x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vaddw_u16(uint32x4_t __p0, uint16x4_t __p1) {
uint32x4_t __ret;
__ret = __p0 + vmovl_u16(__p1);
return __ret;
}
#else
-__ai uint32x4_t vaddw_u16(uint32x4_t __p0, uint16x4_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vaddw_u16(uint32x4_t __p0, uint16x4_t __p1) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -67152,13 +67312,13 @@ __ai uint32x4_t vaddw_u16(uint32x4_t __p0, uint16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vaddw_s8(int16x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vaddw_s8(int16x8_t __p0, int8x8_t __p1) {
int16x8_t __ret;
__ret = __p0 + vmovl_s8(__p1);
return __ret;
}
#else
-__ai int16x8_t vaddw_s8(int16x8_t __p0, int8x8_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vaddw_s8(int16x8_t __p0, int8x8_t __p1) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -67169,13 +67329,13 @@ __ai int16x8_t vaddw_s8(int16x8_t __p0, int8x8_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vaddw_s32(int64x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vaddw_s32(int64x2_t __p0, int32x2_t __p1) {
int64x2_t __ret;
__ret = __p0 + vmovl_s32(__p1);
return __ret;
}
#else
-__ai int64x2_t vaddw_s32(int64x2_t __p0, int32x2_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vaddw_s32(int64x2_t __p0, int32x2_t __p1) {
int64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -67186,13 +67346,13 @@ __ai int64x2_t vaddw_s32(int64x2_t __p0, int32x2_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vaddw_s16(int32x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vaddw_s16(int32x4_t __p0, int16x4_t __p1) {
int32x4_t __ret;
__ret = __p0 + vmovl_s16(__p1);
return __ret;
}
#else
-__ai int32x4_t vaddw_s16(int32x4_t __p0, int16x4_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vaddw_s16(int32x4_t __p0, int16x4_t __p1) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -67203,71 +67363,71 @@ __ai int32x4_t vaddw_s16(int32x4_t __p0, int16x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-#define vget_lane_f16(__p0_847, __p1_847) __extension__ ({ \
- float16_t __ret_847; \
- float16x4_t __s0_847 = __p0_847; \
-float16x4_t __reint_847 = __s0_847; \
-int16_t __reint1_847 = vget_lane_s16(*(int16x4_t *) &__reint_847, __p1_847); \
- __ret_847 = *(float16_t *) &__reint1_847; \
- __ret_847; \
+#define vget_lane_f16(__p0_859, __p1_859) __extension__ ({ \
+ float16_t __ret_859; \
+ float16x4_t __s0_859 = __p0_859; \
+float16x4_t __reint_859 = __s0_859; \
+int16_t __reint1_859 = vget_lane_s16(*(int16x4_t *) &__reint_859, __p1_859); \
+ __ret_859 = *(float16_t *) &__reint1_859; \
+ __ret_859; \
})
#else
-#define vget_lane_f16(__p0_848, __p1_848) __extension__ ({ \
- float16_t __ret_848; \
- float16x4_t __s0_848 = __p0_848; \
- float16x4_t __rev0_848; __rev0_848 = __builtin_shufflevector(__s0_848, __s0_848, 3, 2, 1, 0); \
-float16x4_t __reint_848 = __rev0_848; \
-int16_t __reint1_848 = __noswap_vget_lane_s16(*(int16x4_t *) &__reint_848, __p1_848); \
- __ret_848 = *(float16_t *) &__reint1_848; \
- __ret_848; \
+#define vget_lane_f16(__p0_860, __p1_860) __extension__ ({ \
+ float16_t __ret_860; \
+ float16x4_t __s0_860 = __p0_860; \
+ float16x4_t __rev0_860; __rev0_860 = __builtin_shufflevector(__s0_860, __s0_860, 3, 2, 1, 0); \
+float16x4_t __reint_860 = __rev0_860; \
+int16_t __reint1_860 = __noswap_vget_lane_s16(*(int16x4_t *) &__reint_860, __p1_860); \
+ __ret_860 = *(float16_t *) &__reint1_860; \
+ __ret_860; \
})
-#define __noswap_vget_lane_f16(__p0_849, __p1_849) __extension__ ({ \
- float16_t __ret_849; \
- float16x4_t __s0_849 = __p0_849; \
-float16x4_t __reint_849 = __s0_849; \
-int16_t __reint1_849 = __noswap_vget_lane_s16(*(int16x4_t *) &__reint_849, __p1_849); \
- __ret_849 = *(float16_t *) &__reint1_849; \
- __ret_849; \
+#define __noswap_vget_lane_f16(__p0_861, __p1_861) __extension__ ({ \
+ float16_t __ret_861; \
+ float16x4_t __s0_861 = __p0_861; \
+float16x4_t __reint_861 = __s0_861; \
+int16_t __reint1_861 = __noswap_vget_lane_s16(*(int16x4_t *) &__reint_861, __p1_861); \
+ __ret_861 = *(float16_t *) &__reint1_861; \
+ __ret_861; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vgetq_lane_f16(__p0_850, __p1_850) __extension__ ({ \
- float16_t __ret_850; \
- float16x8_t __s0_850 = __p0_850; \
-float16x8_t __reint_850 = __s0_850; \
-int16_t __reint1_850 = vgetq_lane_s16(*(int16x8_t *) &__reint_850, __p1_850); \
- __ret_850 = *(float16_t *) &__reint1_850; \
- __ret_850; \
+#define vgetq_lane_f16(__p0_862, __p1_862) __extension__ ({ \
+ float16_t __ret_862; \
+ float16x8_t __s0_862 = __p0_862; \
+float16x8_t __reint_862 = __s0_862; \
+int16_t __reint1_862 = vgetq_lane_s16(*(int16x8_t *) &__reint_862, __p1_862); \
+ __ret_862 = *(float16_t *) &__reint1_862; \
+ __ret_862; \
})
#else
-#define vgetq_lane_f16(__p0_851, __p1_851) __extension__ ({ \
- float16_t __ret_851; \
- float16x8_t __s0_851 = __p0_851; \
- float16x8_t __rev0_851; __rev0_851 = __builtin_shufflevector(__s0_851, __s0_851, 7, 6, 5, 4, 3, 2, 1, 0); \
-float16x8_t __reint_851 = __rev0_851; \
-int16_t __reint1_851 = __noswap_vgetq_lane_s16(*(int16x8_t *) &__reint_851, __p1_851); \
- __ret_851 = *(float16_t *) &__reint1_851; \
- __ret_851; \
+#define vgetq_lane_f16(__p0_863, __p1_863) __extension__ ({ \
+ float16_t __ret_863; \
+ float16x8_t __s0_863 = __p0_863; \
+ float16x8_t __rev0_863; __rev0_863 = __builtin_shufflevector(__s0_863, __s0_863, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16x8_t __reint_863 = __rev0_863; \
+int16_t __reint1_863 = __noswap_vgetq_lane_s16(*(int16x8_t *) &__reint_863, __p1_863); \
+ __ret_863 = *(float16_t *) &__reint1_863; \
+ __ret_863; \
})
-#define __noswap_vgetq_lane_f16(__p0_852, __p1_852) __extension__ ({ \
- float16_t __ret_852; \
- float16x8_t __s0_852 = __p0_852; \
-float16x8_t __reint_852 = __s0_852; \
-int16_t __reint1_852 = __noswap_vgetq_lane_s16(*(int16x8_t *) &__reint_852, __p1_852); \
- __ret_852 = *(float16_t *) &__reint1_852; \
- __ret_852; \
+#define __noswap_vgetq_lane_f16(__p0_864, __p1_864) __extension__ ({ \
+ float16_t __ret_864; \
+ float16x8_t __s0_864 = __p0_864; \
+float16x8_t __reint_864 = __s0_864; \
+int16_t __reint1_864 = __noswap_vgetq_lane_s16(*(int16x8_t *) &__reint_864, __p1_864); \
+ __ret_864 = *(float16_t *) &__reint1_864; \
+ __ret_864; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vmlal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+__ai __attribute__((target("neon"))) uint16x8_t vmlal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint16x8_t __ret;
__ret = __p0 + vmull_u8(__p1, __p2);
return __ret;
}
#else
-__ai uint16x8_t vmlal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+__ai __attribute__((target("neon"))) uint16x8_t vmlal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -67276,7 +67436,7 @@ __ai uint16x8_t vmlal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai uint16x8_t __noswap_vmlal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+__ai __attribute__((target("neon"))) uint16x8_t __noswap_vmlal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint16x8_t __ret;
__ret = __p0 + __noswap_vmull_u8(__p1, __p2);
return __ret;
@@ -67284,13 +67444,13 @@ __ai uint16x8_t __noswap_vmlal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vmlal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vmlal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
uint64x2_t __ret;
__ret = __p0 + vmull_u32(__p1, __p2);
return __ret;
}
#else
-__ai uint64x2_t vmlal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vmlal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -67299,7 +67459,7 @@ __ai uint64x2_t vmlal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai uint64x2_t __noswap_vmlal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vmlal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
uint64x2_t __ret;
__ret = __p0 + __noswap_vmull_u32(__p1, __p2);
return __ret;
@@ -67307,13 +67467,13 @@ __ai uint64x2_t __noswap_vmlal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmlal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
uint32x4_t __ret;
__ret = __p0 + vmull_u16(__p1, __p2);
return __ret;
}
#else
-__ai uint32x4_t vmlal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -67322,7 +67482,7 @@ __ai uint32x4_t vmlal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai uint32x4_t __noswap_vmlal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vmlal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
uint32x4_t __ret;
__ret = __p0 + __noswap_vmull_u16(__p1, __p2);
return __ret;
@@ -67330,13 +67490,13 @@ __ai uint32x4_t __noswap_vmlal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vmlal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+__ai __attribute__((target("neon"))) int16x8_t vmlal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
int16x8_t __ret;
__ret = __p0 + vmull_s8(__p1, __p2);
return __ret;
}
#else
-__ai int16x8_t vmlal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+__ai __attribute__((target("neon"))) int16x8_t vmlal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -67345,7 +67505,7 @@ __ai int16x8_t vmlal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai int16x8_t __noswap_vmlal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vmlal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
int16x8_t __ret;
__ret = __p0 + __noswap_vmull_s8(__p1, __p2);
return __ret;
@@ -67353,13 +67513,13 @@ __ai int16x8_t __noswap_vmlal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int64x2_t __ret;
__ret = __p0 + vmull_s32(__p1, __p2);
return __ret;
}
#else
-__ai int64x2_t vmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -67368,7 +67528,7 @@ __ai int64x2_t vmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai int64x2_t __noswap_vmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int64x2_t __ret;
__ret = __p0 + __noswap_vmull_s32(__p1, __p2);
return __ret;
@@ -67376,13 +67536,13 @@ __ai int64x2_t __noswap_vmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
int32x4_t __ret;
__ret = __p0 + vmull_s16(__p1, __p2);
return __ret;
}
#else
-__ai int32x4_t vmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -67391,7 +67551,7 @@ __ai int32x4_t vmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int32x4_t __noswap_vmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
int32x4_t __ret;
__ret = __p0 + __noswap_vmull_s16(__p1, __p2);
return __ret;
@@ -67399,109 +67559,109 @@ __ai int32x4_t __noswap_vmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlal_lane_u32(__p0_853, __p1_853, __p2_853, __p3_853) __extension__ ({ \
- uint64x2_t __ret_853; \
- uint64x2_t __s0_853 = __p0_853; \
- uint32x2_t __s1_853 = __p1_853; \
- uint32x2_t __s2_853 = __p2_853; \
- __ret_853 = __s0_853 + vmull_u32(__s1_853, splat_lane_u32(__s2_853, __p3_853)); \
- __ret_853; \
+#define vmlal_lane_u32(__p0_865, __p1_865, __p2_865, __p3_865) __extension__ ({ \
+ uint64x2_t __ret_865; \
+ uint64x2_t __s0_865 = __p0_865; \
+ uint32x2_t __s1_865 = __p1_865; \
+ uint32x2_t __s2_865 = __p2_865; \
+ __ret_865 = __s0_865 + vmull_u32(__s1_865, splat_lane_u32(__s2_865, __p3_865)); \
+ __ret_865; \
})
#else
-#define vmlal_lane_u32(__p0_854, __p1_854, __p2_854, __p3_854) __extension__ ({ \
- uint64x2_t __ret_854; \
- uint64x2_t __s0_854 = __p0_854; \
- uint32x2_t __s1_854 = __p1_854; \
- uint32x2_t __s2_854 = __p2_854; \
- uint64x2_t __rev0_854; __rev0_854 = __builtin_shufflevector(__s0_854, __s0_854, 1, 0); \
- uint32x2_t __rev1_854; __rev1_854 = __builtin_shufflevector(__s1_854, __s1_854, 1, 0); \
- uint32x2_t __rev2_854; __rev2_854 = __builtin_shufflevector(__s2_854, __s2_854, 1, 0); \
- __ret_854 = __rev0_854 + __noswap_vmull_u32(__rev1_854, __noswap_splat_lane_u32(__rev2_854, __p3_854)); \
- __ret_854 = __builtin_shufflevector(__ret_854, __ret_854, 1, 0); \
- __ret_854; \
+#define vmlal_lane_u32(__p0_866, __p1_866, __p2_866, __p3_866) __extension__ ({ \
+ uint64x2_t __ret_866; \
+ uint64x2_t __s0_866 = __p0_866; \
+ uint32x2_t __s1_866 = __p1_866; \
+ uint32x2_t __s2_866 = __p2_866; \
+ uint64x2_t __rev0_866; __rev0_866 = __builtin_shufflevector(__s0_866, __s0_866, 1, 0); \
+ uint32x2_t __rev1_866; __rev1_866 = __builtin_shufflevector(__s1_866, __s1_866, 1, 0); \
+ uint32x2_t __rev2_866; __rev2_866 = __builtin_shufflevector(__s2_866, __s2_866, 1, 0); \
+ __ret_866 = __rev0_866 + __noswap_vmull_u32(__rev1_866, __noswap_splat_lane_u32(__rev2_866, __p3_866)); \
+ __ret_866 = __builtin_shufflevector(__ret_866, __ret_866, 1, 0); \
+ __ret_866; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlal_lane_u16(__p0_855, __p1_855, __p2_855, __p3_855) __extension__ ({ \
- uint32x4_t __ret_855; \
- uint32x4_t __s0_855 = __p0_855; \
- uint16x4_t __s1_855 = __p1_855; \
- uint16x4_t __s2_855 = __p2_855; \
- __ret_855 = __s0_855 + vmull_u16(__s1_855, splat_lane_u16(__s2_855, __p3_855)); \
- __ret_855; \
+#define vmlal_lane_u16(__p0_867, __p1_867, __p2_867, __p3_867) __extension__ ({ \
+ uint32x4_t __ret_867; \
+ uint32x4_t __s0_867 = __p0_867; \
+ uint16x4_t __s1_867 = __p1_867; \
+ uint16x4_t __s2_867 = __p2_867; \
+ __ret_867 = __s0_867 + vmull_u16(__s1_867, splat_lane_u16(__s2_867, __p3_867)); \
+ __ret_867; \
})
#else
-#define vmlal_lane_u16(__p0_856, __p1_856, __p2_856, __p3_856) __extension__ ({ \
- uint32x4_t __ret_856; \
- uint32x4_t __s0_856 = __p0_856; \
- uint16x4_t __s1_856 = __p1_856; \
- uint16x4_t __s2_856 = __p2_856; \
- uint32x4_t __rev0_856; __rev0_856 = __builtin_shufflevector(__s0_856, __s0_856, 3, 2, 1, 0); \
- uint16x4_t __rev1_856; __rev1_856 = __builtin_shufflevector(__s1_856, __s1_856, 3, 2, 1, 0); \
- uint16x4_t __rev2_856; __rev2_856 = __builtin_shufflevector(__s2_856, __s2_856, 3, 2, 1, 0); \
- __ret_856 = __rev0_856 + __noswap_vmull_u16(__rev1_856, __noswap_splat_lane_u16(__rev2_856, __p3_856)); \
- __ret_856 = __builtin_shufflevector(__ret_856, __ret_856, 3, 2, 1, 0); \
- __ret_856; \
+#define vmlal_lane_u16(__p0_868, __p1_868, __p2_868, __p3_868) __extension__ ({ \
+ uint32x4_t __ret_868; \
+ uint32x4_t __s0_868 = __p0_868; \
+ uint16x4_t __s1_868 = __p1_868; \
+ uint16x4_t __s2_868 = __p2_868; \
+ uint32x4_t __rev0_868; __rev0_868 = __builtin_shufflevector(__s0_868, __s0_868, 3, 2, 1, 0); \
+ uint16x4_t __rev1_868; __rev1_868 = __builtin_shufflevector(__s1_868, __s1_868, 3, 2, 1, 0); \
+ uint16x4_t __rev2_868; __rev2_868 = __builtin_shufflevector(__s2_868, __s2_868, 3, 2, 1, 0); \
+ __ret_868 = __rev0_868 + __noswap_vmull_u16(__rev1_868, __noswap_splat_lane_u16(__rev2_868, __p3_868)); \
+ __ret_868 = __builtin_shufflevector(__ret_868, __ret_868, 3, 2, 1, 0); \
+ __ret_868; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlal_lane_s32(__p0_857, __p1_857, __p2_857, __p3_857) __extension__ ({ \
- int64x2_t __ret_857; \
- int64x2_t __s0_857 = __p0_857; \
- int32x2_t __s1_857 = __p1_857; \
- int32x2_t __s2_857 = __p2_857; \
- __ret_857 = __s0_857 + vmull_s32(__s1_857, splat_lane_s32(__s2_857, __p3_857)); \
- __ret_857; \
+#define vmlal_lane_s32(__p0_869, __p1_869, __p2_869, __p3_869) __extension__ ({ \
+ int64x2_t __ret_869; \
+ int64x2_t __s0_869 = __p0_869; \
+ int32x2_t __s1_869 = __p1_869; \
+ int32x2_t __s2_869 = __p2_869; \
+ __ret_869 = __s0_869 + vmull_s32(__s1_869, splat_lane_s32(__s2_869, __p3_869)); \
+ __ret_869; \
})
#else
-#define vmlal_lane_s32(__p0_858, __p1_858, __p2_858, __p3_858) __extension__ ({ \
- int64x2_t __ret_858; \
- int64x2_t __s0_858 = __p0_858; \
- int32x2_t __s1_858 = __p1_858; \
- int32x2_t __s2_858 = __p2_858; \
- int64x2_t __rev0_858; __rev0_858 = __builtin_shufflevector(__s0_858, __s0_858, 1, 0); \
- int32x2_t __rev1_858; __rev1_858 = __builtin_shufflevector(__s1_858, __s1_858, 1, 0); \
- int32x2_t __rev2_858; __rev2_858 = __builtin_shufflevector(__s2_858, __s2_858, 1, 0); \
- __ret_858 = __rev0_858 + __noswap_vmull_s32(__rev1_858, __noswap_splat_lane_s32(__rev2_858, __p3_858)); \
- __ret_858 = __builtin_shufflevector(__ret_858, __ret_858, 1, 0); \
- __ret_858; \
+#define vmlal_lane_s32(__p0_870, __p1_870, __p2_870, __p3_870) __extension__ ({ \
+ int64x2_t __ret_870; \
+ int64x2_t __s0_870 = __p0_870; \
+ int32x2_t __s1_870 = __p1_870; \
+ int32x2_t __s2_870 = __p2_870; \
+ int64x2_t __rev0_870; __rev0_870 = __builtin_shufflevector(__s0_870, __s0_870, 1, 0); \
+ int32x2_t __rev1_870; __rev1_870 = __builtin_shufflevector(__s1_870, __s1_870, 1, 0); \
+ int32x2_t __rev2_870; __rev2_870 = __builtin_shufflevector(__s2_870, __s2_870, 1, 0); \
+ __ret_870 = __rev0_870 + __noswap_vmull_s32(__rev1_870, __noswap_splat_lane_s32(__rev2_870, __p3_870)); \
+ __ret_870 = __builtin_shufflevector(__ret_870, __ret_870, 1, 0); \
+ __ret_870; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlal_lane_s16(__p0_859, __p1_859, __p2_859, __p3_859) __extension__ ({ \
- int32x4_t __ret_859; \
- int32x4_t __s0_859 = __p0_859; \
- int16x4_t __s1_859 = __p1_859; \
- int16x4_t __s2_859 = __p2_859; \
- __ret_859 = __s0_859 + vmull_s16(__s1_859, splat_lane_s16(__s2_859, __p3_859)); \
- __ret_859; \
+#define vmlal_lane_s16(__p0_871, __p1_871, __p2_871, __p3_871) __extension__ ({ \
+ int32x4_t __ret_871; \
+ int32x4_t __s0_871 = __p0_871; \
+ int16x4_t __s1_871 = __p1_871; \
+ int16x4_t __s2_871 = __p2_871; \
+ __ret_871 = __s0_871 + vmull_s16(__s1_871, splat_lane_s16(__s2_871, __p3_871)); \
+ __ret_871; \
})
#else
-#define vmlal_lane_s16(__p0_860, __p1_860, __p2_860, __p3_860) __extension__ ({ \
- int32x4_t __ret_860; \
- int32x4_t __s0_860 = __p0_860; \
- int16x4_t __s1_860 = __p1_860; \
- int16x4_t __s2_860 = __p2_860; \
- int32x4_t __rev0_860; __rev0_860 = __builtin_shufflevector(__s0_860, __s0_860, 3, 2, 1, 0); \
- int16x4_t __rev1_860; __rev1_860 = __builtin_shufflevector(__s1_860, __s1_860, 3, 2, 1, 0); \
- int16x4_t __rev2_860; __rev2_860 = __builtin_shufflevector(__s2_860, __s2_860, 3, 2, 1, 0); \
- __ret_860 = __rev0_860 + __noswap_vmull_s16(__rev1_860, __noswap_splat_lane_s16(__rev2_860, __p3_860)); \
- __ret_860 = __builtin_shufflevector(__ret_860, __ret_860, 3, 2, 1, 0); \
- __ret_860; \
+#define vmlal_lane_s16(__p0_872, __p1_872, __p2_872, __p3_872) __extension__ ({ \
+ int32x4_t __ret_872; \
+ int32x4_t __s0_872 = __p0_872; \
+ int16x4_t __s1_872 = __p1_872; \
+ int16x4_t __s2_872 = __p2_872; \
+ int32x4_t __rev0_872; __rev0_872 = __builtin_shufflevector(__s0_872, __s0_872, 3, 2, 1, 0); \
+ int16x4_t __rev1_872; __rev1_872 = __builtin_shufflevector(__s1_872, __s1_872, 3, 2, 1, 0); \
+ int16x4_t __rev2_872; __rev2_872 = __builtin_shufflevector(__s2_872, __s2_872, 3, 2, 1, 0); \
+ __ret_872 = __rev0_872 + __noswap_vmull_s16(__rev1_872, __noswap_splat_lane_s16(__rev2_872, __p3_872)); \
+ __ret_872 = __builtin_shufflevector(__ret_872, __ret_872, 3, 2, 1, 0); \
+ __ret_872; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vmlal_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vmlal_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
uint64x2_t __ret;
__ret = __p0 + vmull_u32(__p1, (uint32x2_t) {__p2, __p2});
return __ret;
}
#else
-__ai uint64x2_t vmlal_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vmlal_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -67509,7 +67669,7 @@ __ai uint64x2_t vmlal_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai uint64x2_t __noswap_vmlal_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vmlal_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
uint64x2_t __ret;
__ret = __p0 + __noswap_vmull_u32(__p1, (uint32x2_t) {__p2, __p2});
return __ret;
@@ -67517,13 +67677,13 @@ __ai uint64x2_t __noswap_vmlal_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmlal_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlal_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
uint32x4_t __ret;
__ret = __p0 + vmull_u16(__p1, (uint16x4_t) {__p2, __p2, __p2, __p2});
return __ret;
}
#else
-__ai uint32x4_t vmlal_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlal_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -67531,7 +67691,7 @@ __ai uint32x4_t vmlal_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai uint32x4_t __noswap_vmlal_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vmlal_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
uint32x4_t __ret;
__ret = __p0 + __noswap_vmull_u16(__p1, (uint16x4_t) {__p2, __p2, __p2, __p2});
return __ret;
@@ -67539,13 +67699,13 @@ __ai uint32x4_t __noswap_vmlal_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
int64x2_t __ret;
__ret = __p0 + vmull_s32(__p1, (int32x2_t) {__p2, __p2});
return __ret;
}
#else
-__ai int64x2_t vmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
int64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -67553,7 +67713,7 @@ __ai int64x2_t vmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai int64x2_t __noswap_vmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
int64x2_t __ret;
__ret = __p0 + __noswap_vmull_s32(__p1, (int32x2_t) {__p2, __p2});
return __ret;
@@ -67561,13 +67721,13 @@ __ai int64x2_t __noswap_vmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
int32x4_t __ret;
__ret = __p0 + vmull_s16(__p1, (int16x4_t) {__p2, __p2, __p2, __p2});
return __ret;
}
#else
-__ai int32x4_t vmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -67575,7 +67735,7 @@ __ai int32x4_t vmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int32x4_t __noswap_vmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
int32x4_t __ret;
__ret = __p0 + __noswap_vmull_s16(__p1, (int16x4_t) {__p2, __p2, __p2, __p2});
return __ret;
@@ -67583,13 +67743,13 @@ __ai int32x4_t __noswap_vmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vmlsl_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+__ai __attribute__((target("neon"))) uint16x8_t vmlsl_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint16x8_t __ret;
__ret = __p0 - vmull_u8(__p1, __p2);
return __ret;
}
#else
-__ai uint16x8_t vmlsl_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+__ai __attribute__((target("neon"))) uint16x8_t vmlsl_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -67598,7 +67758,7 @@ __ai uint16x8_t vmlsl_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai uint16x8_t __noswap_vmlsl_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+__ai __attribute__((target("neon"))) uint16x8_t __noswap_vmlsl_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint16x8_t __ret;
__ret = __p0 - __noswap_vmull_u8(__p1, __p2);
return __ret;
@@ -67606,13 +67766,13 @@ __ai uint16x8_t __noswap_vmlsl_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vmlsl_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vmlsl_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
uint64x2_t __ret;
__ret = __p0 - vmull_u32(__p1, __p2);
return __ret;
}
#else
-__ai uint64x2_t vmlsl_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vmlsl_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -67621,7 +67781,7 @@ __ai uint64x2_t vmlsl_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai uint64x2_t __noswap_vmlsl_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vmlsl_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
uint64x2_t __ret;
__ret = __p0 - __noswap_vmull_u32(__p1, __p2);
return __ret;
@@ -67629,13 +67789,13 @@ __ai uint64x2_t __noswap_vmlsl_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmlsl_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlsl_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
uint32x4_t __ret;
__ret = __p0 - vmull_u16(__p1, __p2);
return __ret;
}
#else
-__ai uint32x4_t vmlsl_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlsl_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -67644,7 +67804,7 @@ __ai uint32x4_t vmlsl_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai uint32x4_t __noswap_vmlsl_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vmlsl_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
uint32x4_t __ret;
__ret = __p0 - __noswap_vmull_u16(__p1, __p2);
return __ret;
@@ -67652,13 +67812,13 @@ __ai uint32x4_t __noswap_vmlsl_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vmlsl_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+__ai __attribute__((target("neon"))) int16x8_t vmlsl_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
int16x8_t __ret;
__ret = __p0 - vmull_s8(__p1, __p2);
return __ret;
}
#else
-__ai int16x8_t vmlsl_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+__ai __attribute__((target("neon"))) int16x8_t vmlsl_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -67667,7 +67827,7 @@ __ai int16x8_t vmlsl_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai int16x8_t __noswap_vmlsl_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vmlsl_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
int16x8_t __ret;
__ret = __p0 - __noswap_vmull_s8(__p1, __p2);
return __ret;
@@ -67675,13 +67835,13 @@ __ai int16x8_t __noswap_vmlsl_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int64x2_t __ret;
__ret = __p0 - vmull_s32(__p1, __p2);
return __ret;
}
#else
-__ai int64x2_t vmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -67690,7 +67850,7 @@ __ai int64x2_t vmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai int64x2_t __noswap_vmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int64x2_t __ret;
__ret = __p0 - __noswap_vmull_s32(__p1, __p2);
return __ret;
@@ -67698,13 +67858,13 @@ __ai int64x2_t __noswap_vmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
int32x4_t __ret;
__ret = __p0 - vmull_s16(__p1, __p2);
return __ret;
}
#else
-__ai int32x4_t vmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -67713,7 +67873,7 @@ __ai int32x4_t vmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int32x4_t __noswap_vmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
int32x4_t __ret;
__ret = __p0 - __noswap_vmull_s16(__p1, __p2);
return __ret;
@@ -67721,109 +67881,109 @@ __ai int32x4_t __noswap_vmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsl_lane_u32(__p0_861, __p1_861, __p2_861, __p3_861) __extension__ ({ \
- uint64x2_t __ret_861; \
- uint64x2_t __s0_861 = __p0_861; \
- uint32x2_t __s1_861 = __p1_861; \
- uint32x2_t __s2_861 = __p2_861; \
- __ret_861 = __s0_861 - vmull_u32(__s1_861, splat_lane_u32(__s2_861, __p3_861)); \
- __ret_861; \
+#define vmlsl_lane_u32(__p0_873, __p1_873, __p2_873, __p3_873) __extension__ ({ \
+ uint64x2_t __ret_873; \
+ uint64x2_t __s0_873 = __p0_873; \
+ uint32x2_t __s1_873 = __p1_873; \
+ uint32x2_t __s2_873 = __p2_873; \
+ __ret_873 = __s0_873 - vmull_u32(__s1_873, splat_lane_u32(__s2_873, __p3_873)); \
+ __ret_873; \
})
#else
-#define vmlsl_lane_u32(__p0_862, __p1_862, __p2_862, __p3_862) __extension__ ({ \
- uint64x2_t __ret_862; \
- uint64x2_t __s0_862 = __p0_862; \
- uint32x2_t __s1_862 = __p1_862; \
- uint32x2_t __s2_862 = __p2_862; \
- uint64x2_t __rev0_862; __rev0_862 = __builtin_shufflevector(__s0_862, __s0_862, 1, 0); \
- uint32x2_t __rev1_862; __rev1_862 = __builtin_shufflevector(__s1_862, __s1_862, 1, 0); \
- uint32x2_t __rev2_862; __rev2_862 = __builtin_shufflevector(__s2_862, __s2_862, 1, 0); \
- __ret_862 = __rev0_862 - __noswap_vmull_u32(__rev1_862, __noswap_splat_lane_u32(__rev2_862, __p3_862)); \
- __ret_862 = __builtin_shufflevector(__ret_862, __ret_862, 1, 0); \
- __ret_862; \
+#define vmlsl_lane_u32(__p0_874, __p1_874, __p2_874, __p3_874) __extension__ ({ \
+ uint64x2_t __ret_874; \
+ uint64x2_t __s0_874 = __p0_874; \
+ uint32x2_t __s1_874 = __p1_874; \
+ uint32x2_t __s2_874 = __p2_874; \
+ uint64x2_t __rev0_874; __rev0_874 = __builtin_shufflevector(__s0_874, __s0_874, 1, 0); \
+ uint32x2_t __rev1_874; __rev1_874 = __builtin_shufflevector(__s1_874, __s1_874, 1, 0); \
+ uint32x2_t __rev2_874; __rev2_874 = __builtin_shufflevector(__s2_874, __s2_874, 1, 0); \
+ __ret_874 = __rev0_874 - __noswap_vmull_u32(__rev1_874, __noswap_splat_lane_u32(__rev2_874, __p3_874)); \
+ __ret_874 = __builtin_shufflevector(__ret_874, __ret_874, 1, 0); \
+ __ret_874; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsl_lane_u16(__p0_863, __p1_863, __p2_863, __p3_863) __extension__ ({ \
- uint32x4_t __ret_863; \
- uint32x4_t __s0_863 = __p0_863; \
- uint16x4_t __s1_863 = __p1_863; \
- uint16x4_t __s2_863 = __p2_863; \
- __ret_863 = __s0_863 - vmull_u16(__s1_863, splat_lane_u16(__s2_863, __p3_863)); \
- __ret_863; \
+#define vmlsl_lane_u16(__p0_875, __p1_875, __p2_875, __p3_875) __extension__ ({ \
+ uint32x4_t __ret_875; \
+ uint32x4_t __s0_875 = __p0_875; \
+ uint16x4_t __s1_875 = __p1_875; \
+ uint16x4_t __s2_875 = __p2_875; \
+ __ret_875 = __s0_875 - vmull_u16(__s1_875, splat_lane_u16(__s2_875, __p3_875)); \
+ __ret_875; \
})
#else
-#define vmlsl_lane_u16(__p0_864, __p1_864, __p2_864, __p3_864) __extension__ ({ \
- uint32x4_t __ret_864; \
- uint32x4_t __s0_864 = __p0_864; \
- uint16x4_t __s1_864 = __p1_864; \
- uint16x4_t __s2_864 = __p2_864; \
- uint32x4_t __rev0_864; __rev0_864 = __builtin_shufflevector(__s0_864, __s0_864, 3, 2, 1, 0); \
- uint16x4_t __rev1_864; __rev1_864 = __builtin_shufflevector(__s1_864, __s1_864, 3, 2, 1, 0); \
- uint16x4_t __rev2_864; __rev2_864 = __builtin_shufflevector(__s2_864, __s2_864, 3, 2, 1, 0); \
- __ret_864 = __rev0_864 - __noswap_vmull_u16(__rev1_864, __noswap_splat_lane_u16(__rev2_864, __p3_864)); \
- __ret_864 = __builtin_shufflevector(__ret_864, __ret_864, 3, 2, 1, 0); \
- __ret_864; \
+#define vmlsl_lane_u16(__p0_876, __p1_876, __p2_876, __p3_876) __extension__ ({ \
+ uint32x4_t __ret_876; \
+ uint32x4_t __s0_876 = __p0_876; \
+ uint16x4_t __s1_876 = __p1_876; \
+ uint16x4_t __s2_876 = __p2_876; \
+ uint32x4_t __rev0_876; __rev0_876 = __builtin_shufflevector(__s0_876, __s0_876, 3, 2, 1, 0); \
+ uint16x4_t __rev1_876; __rev1_876 = __builtin_shufflevector(__s1_876, __s1_876, 3, 2, 1, 0); \
+ uint16x4_t __rev2_876; __rev2_876 = __builtin_shufflevector(__s2_876, __s2_876, 3, 2, 1, 0); \
+ __ret_876 = __rev0_876 - __noswap_vmull_u16(__rev1_876, __noswap_splat_lane_u16(__rev2_876, __p3_876)); \
+ __ret_876 = __builtin_shufflevector(__ret_876, __ret_876, 3, 2, 1, 0); \
+ __ret_876; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsl_lane_s32(__p0_865, __p1_865, __p2_865, __p3_865) __extension__ ({ \
- int64x2_t __ret_865; \
- int64x2_t __s0_865 = __p0_865; \
- int32x2_t __s1_865 = __p1_865; \
- int32x2_t __s2_865 = __p2_865; \
- __ret_865 = __s0_865 - vmull_s32(__s1_865, splat_lane_s32(__s2_865, __p3_865)); \
- __ret_865; \
+#define vmlsl_lane_s32(__p0_877, __p1_877, __p2_877, __p3_877) __extension__ ({ \
+ int64x2_t __ret_877; \
+ int64x2_t __s0_877 = __p0_877; \
+ int32x2_t __s1_877 = __p1_877; \
+ int32x2_t __s2_877 = __p2_877; \
+ __ret_877 = __s0_877 - vmull_s32(__s1_877, splat_lane_s32(__s2_877, __p3_877)); \
+ __ret_877; \
})
#else
-#define vmlsl_lane_s32(__p0_866, __p1_866, __p2_866, __p3_866) __extension__ ({ \
- int64x2_t __ret_866; \
- int64x2_t __s0_866 = __p0_866; \
- int32x2_t __s1_866 = __p1_866; \
- int32x2_t __s2_866 = __p2_866; \
- int64x2_t __rev0_866; __rev0_866 = __builtin_shufflevector(__s0_866, __s0_866, 1, 0); \
- int32x2_t __rev1_866; __rev1_866 = __builtin_shufflevector(__s1_866, __s1_866, 1, 0); \
- int32x2_t __rev2_866; __rev2_866 = __builtin_shufflevector(__s2_866, __s2_866, 1, 0); \
- __ret_866 = __rev0_866 - __noswap_vmull_s32(__rev1_866, __noswap_splat_lane_s32(__rev2_866, __p3_866)); \
- __ret_866 = __builtin_shufflevector(__ret_866, __ret_866, 1, 0); \
- __ret_866; \
+#define vmlsl_lane_s32(__p0_878, __p1_878, __p2_878, __p3_878) __extension__ ({ \
+ int64x2_t __ret_878; \
+ int64x2_t __s0_878 = __p0_878; \
+ int32x2_t __s1_878 = __p1_878; \
+ int32x2_t __s2_878 = __p2_878; \
+ int64x2_t __rev0_878; __rev0_878 = __builtin_shufflevector(__s0_878, __s0_878, 1, 0); \
+ int32x2_t __rev1_878; __rev1_878 = __builtin_shufflevector(__s1_878, __s1_878, 1, 0); \
+ int32x2_t __rev2_878; __rev2_878 = __builtin_shufflevector(__s2_878, __s2_878, 1, 0); \
+ __ret_878 = __rev0_878 - __noswap_vmull_s32(__rev1_878, __noswap_splat_lane_s32(__rev2_878, __p3_878)); \
+ __ret_878 = __builtin_shufflevector(__ret_878, __ret_878, 1, 0); \
+ __ret_878; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vmlsl_lane_s16(__p0_867, __p1_867, __p2_867, __p3_867) __extension__ ({ \
- int32x4_t __ret_867; \
- int32x4_t __s0_867 = __p0_867; \
- int16x4_t __s1_867 = __p1_867; \
- int16x4_t __s2_867 = __p2_867; \
- __ret_867 = __s0_867 - vmull_s16(__s1_867, splat_lane_s16(__s2_867, __p3_867)); \
- __ret_867; \
+#define vmlsl_lane_s16(__p0_879, __p1_879, __p2_879, __p3_879) __extension__ ({ \
+ int32x4_t __ret_879; \
+ int32x4_t __s0_879 = __p0_879; \
+ int16x4_t __s1_879 = __p1_879; \
+ int16x4_t __s2_879 = __p2_879; \
+ __ret_879 = __s0_879 - vmull_s16(__s1_879, splat_lane_s16(__s2_879, __p3_879)); \
+ __ret_879; \
})
#else
-#define vmlsl_lane_s16(__p0_868, __p1_868, __p2_868, __p3_868) __extension__ ({ \
- int32x4_t __ret_868; \
- int32x4_t __s0_868 = __p0_868; \
- int16x4_t __s1_868 = __p1_868; \
- int16x4_t __s2_868 = __p2_868; \
- int32x4_t __rev0_868; __rev0_868 = __builtin_shufflevector(__s0_868, __s0_868, 3, 2, 1, 0); \
- int16x4_t __rev1_868; __rev1_868 = __builtin_shufflevector(__s1_868, __s1_868, 3, 2, 1, 0); \
- int16x4_t __rev2_868; __rev2_868 = __builtin_shufflevector(__s2_868, __s2_868, 3, 2, 1, 0); \
- __ret_868 = __rev0_868 - __noswap_vmull_s16(__rev1_868, __noswap_splat_lane_s16(__rev2_868, __p3_868)); \
- __ret_868 = __builtin_shufflevector(__ret_868, __ret_868, 3, 2, 1, 0); \
- __ret_868; \
+#define vmlsl_lane_s16(__p0_880, __p1_880, __p2_880, __p3_880) __extension__ ({ \
+ int32x4_t __ret_880; \
+ int32x4_t __s0_880 = __p0_880; \
+ int16x4_t __s1_880 = __p1_880; \
+ int16x4_t __s2_880 = __p2_880; \
+ int32x4_t __rev0_880; __rev0_880 = __builtin_shufflevector(__s0_880, __s0_880, 3, 2, 1, 0); \
+ int16x4_t __rev1_880; __rev1_880 = __builtin_shufflevector(__s1_880, __s1_880, 3, 2, 1, 0); \
+ int16x4_t __rev2_880; __rev2_880 = __builtin_shufflevector(__s2_880, __s2_880, 3, 2, 1, 0); \
+ __ret_880 = __rev0_880 - __noswap_vmull_s16(__rev1_880, __noswap_splat_lane_s16(__rev2_880, __p3_880)); \
+ __ret_880 = __builtin_shufflevector(__ret_880, __ret_880, 3, 2, 1, 0); \
+ __ret_880; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vmlsl_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vmlsl_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
uint64x2_t __ret;
__ret = __p0 - vmull_u32(__p1, (uint32x2_t) {__p2, __p2});
return __ret;
}
#else
-__ai uint64x2_t vmlsl_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vmlsl_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -67831,7 +67991,7 @@ __ai uint64x2_t vmlsl_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai uint64x2_t __noswap_vmlsl_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vmlsl_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
uint64x2_t __ret;
__ret = __p0 - __noswap_vmull_u32(__p1, (uint32x2_t) {__p2, __p2});
return __ret;
@@ -67839,13 +67999,13 @@ __ai uint64x2_t __noswap_vmlsl_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmlsl_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlsl_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
uint32x4_t __ret;
__ret = __p0 - vmull_u16(__p1, (uint16x4_t) {__p2, __p2, __p2, __p2});
return __ret;
}
#else
-__ai uint32x4_t vmlsl_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlsl_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -67853,7 +68013,7 @@ __ai uint32x4_t vmlsl_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai uint32x4_t __noswap_vmlsl_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vmlsl_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
uint32x4_t __ret;
__ret = __p0 - __noswap_vmull_u16(__p1, (uint16x4_t) {__p2, __p2, __p2, __p2});
return __ret;
@@ -67861,13 +68021,13 @@ __ai uint32x4_t __noswap_vmlsl_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
int64x2_t __ret;
__ret = __p0 - vmull_s32(__p1, (int32x2_t) {__p2, __p2});
return __ret;
}
#else
-__ai int64x2_t vmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
int64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -67875,7 +68035,7 @@ __ai int64x2_t vmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai int64x2_t __noswap_vmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
int64x2_t __ret;
__ret = __p0 - __noswap_vmull_s32(__p1, (int32x2_t) {__p2, __p2});
return __ret;
@@ -67883,13 +68043,13 @@ __ai int64x2_t __noswap_vmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
int32x4_t __ret;
__ret = __p0 - vmull_s16(__p1, (int16x4_t) {__p2, __p2, __p2, __p2});
return __ret;
}
#else
-__ai int32x4_t vmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -67897,7 +68057,7 @@ __ai int32x4_t vmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int32x4_t __noswap_vmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
int32x4_t __ret;
__ret = __p0 - __noswap_vmull_s16(__p1, (int16x4_t) {__p2, __p2, __p2, __p2});
return __ret;
@@ -67905,246 +68065,504 @@ __ai int32x4_t __noswap_vmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-#define vset_lane_f16(__p0_869, __p1_869, __p2_869) __extension__ ({ \
- float16x4_t __ret_869; \
- float16_t __s0_869 = __p0_869; \
- float16x4_t __s1_869 = __p1_869; \
-float16_t __reint_869 = __s0_869; \
-float16x4_t __reint1_869 = __s1_869; \
-int16x4_t __reint2_869 = vset_lane_s16(*(int16_t *) &__reint_869, *(int16x4_t *) &__reint1_869, __p2_869); \
- __ret_869 = *(float16x4_t *) &__reint2_869; \
- __ret_869; \
+#define vset_lane_f16(__p0_881, __p1_881, __p2_881) __extension__ ({ \
+ float16x4_t __ret_881; \
+ float16_t __s0_881 = __p0_881; \
+ float16x4_t __s1_881 = __p1_881; \
+float16_t __reint_881 = __s0_881; \
+float16x4_t __reint1_881 = __s1_881; \
+int16x4_t __reint2_881 = vset_lane_s16(*(int16_t *) &__reint_881, *(int16x4_t *) &__reint1_881, __p2_881); \
+ __ret_881 = *(float16x4_t *) &__reint2_881; \
+ __ret_881; \
})
#else
-#define vset_lane_f16(__p0_870, __p1_870, __p2_870) __extension__ ({ \
- float16x4_t __ret_870; \
- float16_t __s0_870 = __p0_870; \
- float16x4_t __s1_870 = __p1_870; \
- float16x4_t __rev1_870; __rev1_870 = __builtin_shufflevector(__s1_870, __s1_870, 3, 2, 1, 0); \
-float16_t __reint_870 = __s0_870; \
-float16x4_t __reint1_870 = __rev1_870; \
-int16x4_t __reint2_870 = __noswap_vset_lane_s16(*(int16_t *) &__reint_870, *(int16x4_t *) &__reint1_870, __p2_870); \
- __ret_870 = *(float16x4_t *) &__reint2_870; \
- __ret_870 = __builtin_shufflevector(__ret_870, __ret_870, 3, 2, 1, 0); \
- __ret_870; \
+#define vset_lane_f16(__p0_882, __p1_882, __p2_882) __extension__ ({ \
+ float16x4_t __ret_882; \
+ float16_t __s0_882 = __p0_882; \
+ float16x4_t __s1_882 = __p1_882; \
+ float16x4_t __rev1_882; __rev1_882 = __builtin_shufflevector(__s1_882, __s1_882, 3, 2, 1, 0); \
+float16_t __reint_882 = __s0_882; \
+float16x4_t __reint1_882 = __rev1_882; \
+int16x4_t __reint2_882 = __noswap_vset_lane_s16(*(int16_t *) &__reint_882, *(int16x4_t *) &__reint1_882, __p2_882); \
+ __ret_882 = *(float16x4_t *) &__reint2_882; \
+ __ret_882 = __builtin_shufflevector(__ret_882, __ret_882, 3, 2, 1, 0); \
+ __ret_882; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsetq_lane_f16(__p0_871, __p1_871, __p2_871) __extension__ ({ \
- float16x8_t __ret_871; \
- float16_t __s0_871 = __p0_871; \
- float16x8_t __s1_871 = __p1_871; \
-float16_t __reint_871 = __s0_871; \
-float16x8_t __reint1_871 = __s1_871; \
-int16x8_t __reint2_871 = vsetq_lane_s16(*(int16_t *) &__reint_871, *(int16x8_t *) &__reint1_871, __p2_871); \
- __ret_871 = *(float16x8_t *) &__reint2_871; \
- __ret_871; \
+#define vsetq_lane_f16(__p0_883, __p1_883, __p2_883) __extension__ ({ \
+ float16x8_t __ret_883; \
+ float16_t __s0_883 = __p0_883; \
+ float16x8_t __s1_883 = __p1_883; \
+float16_t __reint_883 = __s0_883; \
+float16x8_t __reint1_883 = __s1_883; \
+int16x8_t __reint2_883 = vsetq_lane_s16(*(int16_t *) &__reint_883, *(int16x8_t *) &__reint1_883, __p2_883); \
+ __ret_883 = *(float16x8_t *) &__reint2_883; \
+ __ret_883; \
})
#else
-#define vsetq_lane_f16(__p0_872, __p1_872, __p2_872) __extension__ ({ \
- float16x8_t __ret_872; \
- float16_t __s0_872 = __p0_872; \
- float16x8_t __s1_872 = __p1_872; \
- float16x8_t __rev1_872; __rev1_872 = __builtin_shufflevector(__s1_872, __s1_872, 7, 6, 5, 4, 3, 2, 1, 0); \
-float16_t __reint_872 = __s0_872; \
-float16x8_t __reint1_872 = __rev1_872; \
-int16x8_t __reint2_872 = __noswap_vsetq_lane_s16(*(int16_t *) &__reint_872, *(int16x8_t *) &__reint1_872, __p2_872); \
- __ret_872 = *(float16x8_t *) &__reint2_872; \
- __ret_872 = __builtin_shufflevector(__ret_872, __ret_872, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_872; \
+#define vsetq_lane_f16(__p0_884, __p1_884, __p2_884) __extension__ ({ \
+ float16x8_t __ret_884; \
+ float16_t __s0_884 = __p0_884; \
+ float16x8_t __s1_884 = __p1_884; \
+ float16x8_t __rev1_884; __rev1_884 = __builtin_shufflevector(__s1_884, __s1_884, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16_t __reint_884 = __s0_884; \
+float16x8_t __reint1_884 = __rev1_884; \
+int16x8_t __reint2_884 = __noswap_vsetq_lane_s16(*(int16_t *) &__reint_884, *(int16x8_t *) &__reint1_884, __p2_884); \
+ __ret_884 = *(float16x8_t *) &__reint2_884; \
+ __ret_884 = __builtin_shufflevector(__ret_884, __ret_884, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_884; \
})
#endif
+#if defined(__aarch64__) || defined(__arm64ec__)
#ifdef __LITTLE_ENDIAN__
-#define vbfmlalbq_lane_f32(__p0_873, __p1_873, __p2_873, __p3_873) __extension__ ({ \
- float32x4_t __ret_873; \
- float32x4_t __s0_873 = __p0_873; \
- bfloat16x8_t __s1_873 = __p1_873; \
- bfloat16x4_t __s2_873 = __p2_873; \
- __ret_873 = vbfmlalbq_f32(__s0_873, __s1_873, (bfloat16x8_t) {vget_lane_bf16(__s2_873, __p3_873), vget_lane_bf16(__s2_873, __p3_873), vget_lane_bf16(__s2_873, __p3_873), vget_lane_bf16(__s2_873, __p3_873), vget_lane_bf16(__s2_873, __p3_873), vget_lane_bf16(__s2_873, __p3_873), vget_lane_bf16(__s2_873, __p3_873), vget_lane_bf16(__s2_873, __p3_873)}); \
- __ret_873; \
+__ai __attribute__((target("aes,neon"))) poly128_t vmull_high_p64(poly64x2_t __p0, poly64x2_t __p1) {
+ poly128_t __ret;
+ __ret = vmull_p64((poly64_t)(vget_high_p64(__p0)), (poly64_t)(vget_high_p64(__p1)));
+ return __ret;
+}
+#else
+__ai __attribute__((target("aes,neon"))) poly128_t vmull_high_p64(poly64x2_t __p0, poly64x2_t __p1) {
+ poly128_t __ret;
+ poly64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+ poly64x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+ __ret = vmull_p64((poly64_t)(__noswap_vget_high_p64(__rev0)), (poly64_t)(__noswap_vget_high_p64(__rev1)));
+ return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlalq_lane_high_f16(__p0_885, __p1_885, __p2_885, __p3_885) __extension__ ({ \
+ float32x4_t __ret_885; \
+ float32x4_t __s0_885 = __p0_885; \
+ float16x8_t __s1_885 = __p1_885; \
+ float16x4_t __s2_885 = __p2_885; \
+ __ret_885 = vfmlalq_high_f16(__s0_885, __s1_885, (float16x8_t) {vget_lane_f16(__s2_885, __p3_885), vget_lane_f16(__s2_885, __p3_885), vget_lane_f16(__s2_885, __p3_885), vget_lane_f16(__s2_885, __p3_885), vget_lane_f16(__s2_885, __p3_885), vget_lane_f16(__s2_885, __p3_885), vget_lane_f16(__s2_885, __p3_885), vget_lane_f16(__s2_885, __p3_885)}); \
+ __ret_885; \
})
#else
-#define vbfmlalbq_lane_f32(__p0_874, __p1_874, __p2_874, __p3_874) __extension__ ({ \
- float32x4_t __ret_874; \
- float32x4_t __s0_874 = __p0_874; \
- bfloat16x8_t __s1_874 = __p1_874; \
- bfloat16x4_t __s2_874 = __p2_874; \
- float32x4_t __rev0_874; __rev0_874 = __builtin_shufflevector(__s0_874, __s0_874, 3, 2, 1, 0); \
- bfloat16x8_t __rev1_874; __rev1_874 = __builtin_shufflevector(__s1_874, __s1_874, 7, 6, 5, 4, 3, 2, 1, 0); \
- bfloat16x4_t __rev2_874; __rev2_874 = __builtin_shufflevector(__s2_874, __s2_874, 3, 2, 1, 0); \
- __ret_874 = __noswap_vbfmlalbq_f32(__rev0_874, __rev1_874, (bfloat16x8_t) {__noswap_vget_lane_bf16(__rev2_874, __p3_874), __noswap_vget_lane_bf16(__rev2_874, __p3_874), __noswap_vget_lane_bf16(__rev2_874, __p3_874), __noswap_vget_lane_bf16(__rev2_874, __p3_874), __noswap_vget_lane_bf16(__rev2_874, __p3_874), __noswap_vget_lane_bf16(__rev2_874, __p3_874), __noswap_vget_lane_bf16(__rev2_874, __p3_874), __noswap_vget_lane_bf16(__rev2_874, __p3_874)}); \
- __ret_874 = __builtin_shufflevector(__ret_874, __ret_874, 3, 2, 1, 0); \
- __ret_874; \
+#define vfmlalq_lane_high_f16(__p0_886, __p1_886, __p2_886, __p3_886) __extension__ ({ \
+ float32x4_t __ret_886; \
+ float32x4_t __s0_886 = __p0_886; \
+ float16x8_t __s1_886 = __p1_886; \
+ float16x4_t __s2_886 = __p2_886; \
+ float32x4_t __rev0_886; __rev0_886 = __builtin_shufflevector(__s0_886, __s0_886, 3, 2, 1, 0); \
+ float16x8_t __rev1_886; __rev1_886 = __builtin_shufflevector(__s1_886, __s1_886, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x4_t __rev2_886; __rev2_886 = __builtin_shufflevector(__s2_886, __s2_886, 3, 2, 1, 0); \
+ __ret_886 = __noswap_vfmlalq_high_f16(__rev0_886, __rev1_886, (float16x8_t) {__noswap_vget_lane_f16(__rev2_886, __p3_886), __noswap_vget_lane_f16(__rev2_886, __p3_886), __noswap_vget_lane_f16(__rev2_886, __p3_886), __noswap_vget_lane_f16(__rev2_886, __p3_886), __noswap_vget_lane_f16(__rev2_886, __p3_886), __noswap_vget_lane_f16(__rev2_886, __p3_886), __noswap_vget_lane_f16(__rev2_886, __p3_886), __noswap_vget_lane_f16(__rev2_886, __p3_886)}); \
+ __ret_886 = __builtin_shufflevector(__ret_886, __ret_886, 3, 2, 1, 0); \
+ __ret_886; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vbfmlalbq_laneq_f32(__p0_875, __p1_875, __p2_875, __p3_875) __extension__ ({ \
- float32x4_t __ret_875; \
- float32x4_t __s0_875 = __p0_875; \
- bfloat16x8_t __s1_875 = __p1_875; \
- bfloat16x8_t __s2_875 = __p2_875; \
- __ret_875 = vbfmlalbq_f32(__s0_875, __s1_875, (bfloat16x8_t) {vgetq_lane_bf16(__s2_875, __p3_875), vgetq_lane_bf16(__s2_875, __p3_875), vgetq_lane_bf16(__s2_875, __p3_875), vgetq_lane_bf16(__s2_875, __p3_875), vgetq_lane_bf16(__s2_875, __p3_875), vgetq_lane_bf16(__s2_875, __p3_875), vgetq_lane_bf16(__s2_875, __p3_875), vgetq_lane_bf16(__s2_875, __p3_875)}); \
- __ret_875; \
+#define vfmlal_lane_high_f16(__p0_887, __p1_887, __p2_887, __p3_887) __extension__ ({ \
+ float32x2_t __ret_887; \
+ float32x2_t __s0_887 = __p0_887; \
+ float16x4_t __s1_887 = __p1_887; \
+ float16x4_t __s2_887 = __p2_887; \
+ __ret_887 = vfmlal_high_f16(__s0_887, __s1_887, (float16x4_t) {vget_lane_f16(__s2_887, __p3_887), vget_lane_f16(__s2_887, __p3_887), vget_lane_f16(__s2_887, __p3_887), vget_lane_f16(__s2_887, __p3_887)}); \
+ __ret_887; \
})
#else
-#define vbfmlalbq_laneq_f32(__p0_876, __p1_876, __p2_876, __p3_876) __extension__ ({ \
- float32x4_t __ret_876; \
- float32x4_t __s0_876 = __p0_876; \
- bfloat16x8_t __s1_876 = __p1_876; \
- bfloat16x8_t __s2_876 = __p2_876; \
- float32x4_t __rev0_876; __rev0_876 = __builtin_shufflevector(__s0_876, __s0_876, 3, 2, 1, 0); \
- bfloat16x8_t __rev1_876; __rev1_876 = __builtin_shufflevector(__s1_876, __s1_876, 7, 6, 5, 4, 3, 2, 1, 0); \
- bfloat16x8_t __rev2_876; __rev2_876 = __builtin_shufflevector(__s2_876, __s2_876, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_876 = __noswap_vbfmlalbq_f32(__rev0_876, __rev1_876, (bfloat16x8_t) {__noswap_vgetq_lane_bf16(__rev2_876, __p3_876), __noswap_vgetq_lane_bf16(__rev2_876, __p3_876), __noswap_vgetq_lane_bf16(__rev2_876, __p3_876), __noswap_vgetq_lane_bf16(__rev2_876, __p3_876), __noswap_vgetq_lane_bf16(__rev2_876, __p3_876), __noswap_vgetq_lane_bf16(__rev2_876, __p3_876), __noswap_vgetq_lane_bf16(__rev2_876, __p3_876), __noswap_vgetq_lane_bf16(__rev2_876, __p3_876)}); \
- __ret_876 = __builtin_shufflevector(__ret_876, __ret_876, 3, 2, 1, 0); \
- __ret_876; \
+#define vfmlal_lane_high_f16(__p0_888, __p1_888, __p2_888, __p3_888) __extension__ ({ \
+ float32x2_t __ret_888; \
+ float32x2_t __s0_888 = __p0_888; \
+ float16x4_t __s1_888 = __p1_888; \
+ float16x4_t __s2_888 = __p2_888; \
+ float32x2_t __rev0_888; __rev0_888 = __builtin_shufflevector(__s0_888, __s0_888, 1, 0); \
+ float16x4_t __rev1_888; __rev1_888 = __builtin_shufflevector(__s1_888, __s1_888, 3, 2, 1, 0); \
+ float16x4_t __rev2_888; __rev2_888 = __builtin_shufflevector(__s2_888, __s2_888, 3, 2, 1, 0); \
+ __ret_888 = __noswap_vfmlal_high_f16(__rev0_888, __rev1_888, (float16x4_t) {__noswap_vget_lane_f16(__rev2_888, __p3_888), __noswap_vget_lane_f16(__rev2_888, __p3_888), __noswap_vget_lane_f16(__rev2_888, __p3_888), __noswap_vget_lane_f16(__rev2_888, __p3_888)}); \
+ __ret_888 = __builtin_shufflevector(__ret_888, __ret_888, 1, 0); \
+ __ret_888; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vbfmlaltq_lane_f32(__p0_877, __p1_877, __p2_877, __p3_877) __extension__ ({ \
- float32x4_t __ret_877; \
- float32x4_t __s0_877 = __p0_877; \
- bfloat16x8_t __s1_877 = __p1_877; \
- bfloat16x4_t __s2_877 = __p2_877; \
- __ret_877 = vbfmlaltq_f32(__s0_877, __s1_877, (bfloat16x8_t) {vget_lane_bf16(__s2_877, __p3_877), vget_lane_bf16(__s2_877, __p3_877), vget_lane_bf16(__s2_877, __p3_877), vget_lane_bf16(__s2_877, __p3_877), vget_lane_bf16(__s2_877, __p3_877), vget_lane_bf16(__s2_877, __p3_877), vget_lane_bf16(__s2_877, __p3_877), vget_lane_bf16(__s2_877, __p3_877)}); \
- __ret_877; \
+#define vfmlalq_lane_low_f16(__p0_889, __p1_889, __p2_889, __p3_889) __extension__ ({ \
+ float32x4_t __ret_889; \
+ float32x4_t __s0_889 = __p0_889; \
+ float16x8_t __s1_889 = __p1_889; \
+ float16x4_t __s2_889 = __p2_889; \
+ __ret_889 = vfmlalq_low_f16(__s0_889, __s1_889, (float16x8_t) {vget_lane_f16(__s2_889, __p3_889), vget_lane_f16(__s2_889, __p3_889), vget_lane_f16(__s2_889, __p3_889), vget_lane_f16(__s2_889, __p3_889), vget_lane_f16(__s2_889, __p3_889), vget_lane_f16(__s2_889, __p3_889), vget_lane_f16(__s2_889, __p3_889), vget_lane_f16(__s2_889, __p3_889)}); \
+ __ret_889; \
})
#else
-#define vbfmlaltq_lane_f32(__p0_878, __p1_878, __p2_878, __p3_878) __extension__ ({ \
- float32x4_t __ret_878; \
- float32x4_t __s0_878 = __p0_878; \
- bfloat16x8_t __s1_878 = __p1_878; \
- bfloat16x4_t __s2_878 = __p2_878; \
- float32x4_t __rev0_878; __rev0_878 = __builtin_shufflevector(__s0_878, __s0_878, 3, 2, 1, 0); \
- bfloat16x8_t __rev1_878; __rev1_878 = __builtin_shufflevector(__s1_878, __s1_878, 7, 6, 5, 4, 3, 2, 1, 0); \
- bfloat16x4_t __rev2_878; __rev2_878 = __builtin_shufflevector(__s2_878, __s2_878, 3, 2, 1, 0); \
- __ret_878 = __noswap_vbfmlaltq_f32(__rev0_878, __rev1_878, (bfloat16x8_t) {__noswap_vget_lane_bf16(__rev2_878, __p3_878), __noswap_vget_lane_bf16(__rev2_878, __p3_878), __noswap_vget_lane_bf16(__rev2_878, __p3_878), __noswap_vget_lane_bf16(__rev2_878, __p3_878), __noswap_vget_lane_bf16(__rev2_878, __p3_878), __noswap_vget_lane_bf16(__rev2_878, __p3_878), __noswap_vget_lane_bf16(__rev2_878, __p3_878), __noswap_vget_lane_bf16(__rev2_878, __p3_878)}); \
- __ret_878 = __builtin_shufflevector(__ret_878, __ret_878, 3, 2, 1, 0); \
- __ret_878; \
+#define vfmlalq_lane_low_f16(__p0_890, __p1_890, __p2_890, __p3_890) __extension__ ({ \
+ float32x4_t __ret_890; \
+ float32x4_t __s0_890 = __p0_890; \
+ float16x8_t __s1_890 = __p1_890; \
+ float16x4_t __s2_890 = __p2_890; \
+ float32x4_t __rev0_890; __rev0_890 = __builtin_shufflevector(__s0_890, __s0_890, 3, 2, 1, 0); \
+ float16x8_t __rev1_890; __rev1_890 = __builtin_shufflevector(__s1_890, __s1_890, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x4_t __rev2_890; __rev2_890 = __builtin_shufflevector(__s2_890, __s2_890, 3, 2, 1, 0); \
+ __ret_890 = __noswap_vfmlalq_low_f16(__rev0_890, __rev1_890, (float16x8_t) {__noswap_vget_lane_f16(__rev2_890, __p3_890), __noswap_vget_lane_f16(__rev2_890, __p3_890), __noswap_vget_lane_f16(__rev2_890, __p3_890), __noswap_vget_lane_f16(__rev2_890, __p3_890), __noswap_vget_lane_f16(__rev2_890, __p3_890), __noswap_vget_lane_f16(__rev2_890, __p3_890), __noswap_vget_lane_f16(__rev2_890, __p3_890), __noswap_vget_lane_f16(__rev2_890, __p3_890)}); \
+ __ret_890 = __builtin_shufflevector(__ret_890, __ret_890, 3, 2, 1, 0); \
+ __ret_890; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vbfmlaltq_laneq_f32(__p0_879, __p1_879, __p2_879, __p3_879) __extension__ ({ \
- float32x4_t __ret_879; \
- float32x4_t __s0_879 = __p0_879; \
- bfloat16x8_t __s1_879 = __p1_879; \
- bfloat16x8_t __s2_879 = __p2_879; \
- __ret_879 = vbfmlaltq_f32(__s0_879, __s1_879, (bfloat16x8_t) {vgetq_lane_bf16(__s2_879, __p3_879), vgetq_lane_bf16(__s2_879, __p3_879), vgetq_lane_bf16(__s2_879, __p3_879), vgetq_lane_bf16(__s2_879, __p3_879), vgetq_lane_bf16(__s2_879, __p3_879), vgetq_lane_bf16(__s2_879, __p3_879), vgetq_lane_bf16(__s2_879, __p3_879), vgetq_lane_bf16(__s2_879, __p3_879)}); \
- __ret_879; \
+#define vfmlal_lane_low_f16(__p0_891, __p1_891, __p2_891, __p3_891) __extension__ ({ \
+ float32x2_t __ret_891; \
+ float32x2_t __s0_891 = __p0_891; \
+ float16x4_t __s1_891 = __p1_891; \
+ float16x4_t __s2_891 = __p2_891; \
+ __ret_891 = vfmlal_low_f16(__s0_891, __s1_891, (float16x4_t) {vget_lane_f16(__s2_891, __p3_891), vget_lane_f16(__s2_891, __p3_891), vget_lane_f16(__s2_891, __p3_891), vget_lane_f16(__s2_891, __p3_891)}); \
+ __ret_891; \
})
#else
-#define vbfmlaltq_laneq_f32(__p0_880, __p1_880, __p2_880, __p3_880) __extension__ ({ \
- float32x4_t __ret_880; \
- float32x4_t __s0_880 = __p0_880; \
- bfloat16x8_t __s1_880 = __p1_880; \
- bfloat16x8_t __s2_880 = __p2_880; \
- float32x4_t __rev0_880; __rev0_880 = __builtin_shufflevector(__s0_880, __s0_880, 3, 2, 1, 0); \
- bfloat16x8_t __rev1_880; __rev1_880 = __builtin_shufflevector(__s1_880, __s1_880, 7, 6, 5, 4, 3, 2, 1, 0); \
- bfloat16x8_t __rev2_880; __rev2_880 = __builtin_shufflevector(__s2_880, __s2_880, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_880 = __noswap_vbfmlaltq_f32(__rev0_880, __rev1_880, (bfloat16x8_t) {__noswap_vgetq_lane_bf16(__rev2_880, __p3_880), __noswap_vgetq_lane_bf16(__rev2_880, __p3_880), __noswap_vgetq_lane_bf16(__rev2_880, __p3_880), __noswap_vgetq_lane_bf16(__rev2_880, __p3_880), __noswap_vgetq_lane_bf16(__rev2_880, __p3_880), __noswap_vgetq_lane_bf16(__rev2_880, __p3_880), __noswap_vgetq_lane_bf16(__rev2_880, __p3_880), __noswap_vgetq_lane_bf16(__rev2_880, __p3_880)}); \
- __ret_880 = __builtin_shufflevector(__ret_880, __ret_880, 3, 2, 1, 0); \
- __ret_880; \
+#define vfmlal_lane_low_f16(__p0_892, __p1_892, __p2_892, __p3_892) __extension__ ({ \
+ float32x2_t __ret_892; \
+ float32x2_t __s0_892 = __p0_892; \
+ float16x4_t __s1_892 = __p1_892; \
+ float16x4_t __s2_892 = __p2_892; \
+ float32x2_t __rev0_892; __rev0_892 = __builtin_shufflevector(__s0_892, __s0_892, 1, 0); \
+ float16x4_t __rev1_892; __rev1_892 = __builtin_shufflevector(__s1_892, __s1_892, 3, 2, 1, 0); \
+ float16x4_t __rev2_892; __rev2_892 = __builtin_shufflevector(__s2_892, __s2_892, 3, 2, 1, 0); \
+ __ret_892 = __noswap_vfmlal_low_f16(__rev0_892, __rev1_892, (float16x4_t) {__noswap_vget_lane_f16(__rev2_892, __p3_892), __noswap_vget_lane_f16(__rev2_892, __p3_892), __noswap_vget_lane_f16(__rev2_892, __p3_892), __noswap_vget_lane_f16(__rev2_892, __p3_892)}); \
+ __ret_892 = __builtin_shufflevector(__ret_892, __ret_892, 1, 0); \
+ __ret_892; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) float32x4_t vcvtq_high_f32_bf16(bfloat16x8_t __p0) {
- float32x4_t __ret;
- __ret = vcvt_f32_bf16(vget_high_bf16(__p0));
- return __ret;
-}
+#define vfmlalq_laneq_high_f16(__p0_893, __p1_893, __p2_893, __p3_893) __extension__ ({ \
+ float32x4_t __ret_893; \
+ float32x4_t __s0_893 = __p0_893; \
+ float16x8_t __s1_893 = __p1_893; \
+ float16x8_t __s2_893 = __p2_893; \
+ __ret_893 = vfmlalq_high_f16(__s0_893, __s1_893, (float16x8_t) {vgetq_lane_f16(__s2_893, __p3_893), vgetq_lane_f16(__s2_893, __p3_893), vgetq_lane_f16(__s2_893, __p3_893), vgetq_lane_f16(__s2_893, __p3_893), vgetq_lane_f16(__s2_893, __p3_893), vgetq_lane_f16(__s2_893, __p3_893), vgetq_lane_f16(__s2_893, __p3_893), vgetq_lane_f16(__s2_893, __p3_893)}); \
+ __ret_893; \
+})
#else
-__ai __attribute__((target("bf16"))) float32x4_t vcvtq_high_f32_bf16(bfloat16x8_t __p0) {
- float32x4_t __ret;
- bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vcvt_f32_bf16(__noswap_vget_high_bf16(__rev0));
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vfmlalq_laneq_high_f16(__p0_894, __p1_894, __p2_894, __p3_894) __extension__ ({ \
+ float32x4_t __ret_894; \
+ float32x4_t __s0_894 = __p0_894; \
+ float16x8_t __s1_894 = __p1_894; \
+ float16x8_t __s2_894 = __p2_894; \
+ float32x4_t __rev0_894; __rev0_894 = __builtin_shufflevector(__s0_894, __s0_894, 3, 2, 1, 0); \
+ float16x8_t __rev1_894; __rev1_894 = __builtin_shufflevector(__s1_894, __s1_894, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev2_894; __rev2_894 = __builtin_shufflevector(__s2_894, __s2_894, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_894 = __noswap_vfmlalq_high_f16(__rev0_894, __rev1_894, (float16x8_t) {__noswap_vgetq_lane_f16(__rev2_894, __p3_894), __noswap_vgetq_lane_f16(__rev2_894, __p3_894), __noswap_vgetq_lane_f16(__rev2_894, __p3_894), __noswap_vgetq_lane_f16(__rev2_894, __p3_894), __noswap_vgetq_lane_f16(__rev2_894, __p3_894), __noswap_vgetq_lane_f16(__rev2_894, __p3_894), __noswap_vgetq_lane_f16(__rev2_894, __p3_894), __noswap_vgetq_lane_f16(__rev2_894, __p3_894)}); \
+ __ret_894 = __builtin_shufflevector(__ret_894, __ret_894, 3, 2, 1, 0); \
+ __ret_894; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai __attribute__((target("bf16"))) float32x4_t vcvtq_low_f32_bf16(bfloat16x8_t __p0) {
- float32x4_t __ret;
- __ret = vcvt_f32_bf16(vget_low_bf16(__p0));
- return __ret;
-}
+#define vfmlal_laneq_high_f16(__p0_895, __p1_895, __p2_895, __p3_895) __extension__ ({ \
+ float32x2_t __ret_895; \
+ float32x2_t __s0_895 = __p0_895; \
+ float16x4_t __s1_895 = __p1_895; \
+ float16x8_t __s2_895 = __p2_895; \
+ __ret_895 = vfmlal_high_f16(__s0_895, __s1_895, (float16x4_t) {vgetq_lane_f16(__s2_895, __p3_895), vgetq_lane_f16(__s2_895, __p3_895), vgetq_lane_f16(__s2_895, __p3_895), vgetq_lane_f16(__s2_895, __p3_895)}); \
+ __ret_895; \
+})
#else
-__ai __attribute__((target("bf16"))) float32x4_t vcvtq_low_f32_bf16(bfloat16x8_t __p0) {
- float32x4_t __ret;
- bfloat16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
- __ret = __noswap_vcvt_f32_bf16(__noswap_vget_low_bf16(__rev0));
- __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
- return __ret;
-}
+#define vfmlal_laneq_high_f16(__p0_896, __p1_896, __p2_896, __p3_896) __extension__ ({ \
+ float32x2_t __ret_896; \
+ float32x2_t __s0_896 = __p0_896; \
+ float16x4_t __s1_896 = __p1_896; \
+ float16x8_t __s2_896 = __p2_896; \
+ float32x2_t __rev0_896; __rev0_896 = __builtin_shufflevector(__s0_896, __s0_896, 1, 0); \
+ float16x4_t __rev1_896; __rev1_896 = __builtin_shufflevector(__s1_896, __s1_896, 3, 2, 1, 0); \
+ float16x8_t __rev2_896; __rev2_896 = __builtin_shufflevector(__s2_896, __s2_896, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_896 = __noswap_vfmlal_high_f16(__rev0_896, __rev1_896, (float16x4_t) {__noswap_vgetq_lane_f16(__rev2_896, __p3_896), __noswap_vgetq_lane_f16(__rev2_896, __p3_896), __noswap_vgetq_lane_f16(__rev2_896, __p3_896), __noswap_vgetq_lane_f16(__rev2_896, __p3_896)}); \
+ __ret_896 = __builtin_shufflevector(__ret_896, __ret_896, 1, 0); \
+ __ret_896; \
+})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsudotq_lane_s32(__p0_881, __p1_881, __p2_881, __p3_881) __extension__ ({ \
- int32x4_t __ret_881; \
- int32x4_t __s0_881 = __p0_881; \
- int8x16_t __s1_881 = __p1_881; \
- uint8x8_t __s2_881 = __p2_881; \
-uint8x8_t __reint_881 = __s2_881; \
- __ret_881 = vusdotq_s32(__s0_881, (uint8x16_t)(splatq_lane_s32(*(int32x2_t *) &__reint_881, __p3_881)), __s1_881); \
- __ret_881; \
+#define vfmlalq_laneq_low_f16(__p0_897, __p1_897, __p2_897, __p3_897) __extension__ ({ \
+ float32x4_t __ret_897; \
+ float32x4_t __s0_897 = __p0_897; \
+ float16x8_t __s1_897 = __p1_897; \
+ float16x8_t __s2_897 = __p2_897; \
+ __ret_897 = vfmlalq_low_f16(__s0_897, __s1_897, (float16x8_t) {vgetq_lane_f16(__s2_897, __p3_897), vgetq_lane_f16(__s2_897, __p3_897), vgetq_lane_f16(__s2_897, __p3_897), vgetq_lane_f16(__s2_897, __p3_897), vgetq_lane_f16(__s2_897, __p3_897), vgetq_lane_f16(__s2_897, __p3_897), vgetq_lane_f16(__s2_897, __p3_897), vgetq_lane_f16(__s2_897, __p3_897)}); \
+ __ret_897; \
})
#else
-#define vsudotq_lane_s32(__p0_882, __p1_882, __p2_882, __p3_882) __extension__ ({ \
- int32x4_t __ret_882; \
- int32x4_t __s0_882 = __p0_882; \
- int8x16_t __s1_882 = __p1_882; \
- uint8x8_t __s2_882 = __p2_882; \
- int32x4_t __rev0_882; __rev0_882 = __builtin_shufflevector(__s0_882, __s0_882, 3, 2, 1, 0); \
- int8x16_t __rev1_882; __rev1_882 = __builtin_shufflevector(__s1_882, __s1_882, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint8x8_t __rev2_882; __rev2_882 = __builtin_shufflevector(__s2_882, __s2_882, 7, 6, 5, 4, 3, 2, 1, 0); \
-uint8x8_t __reint_882 = __rev2_882; \
- __ret_882 = __noswap_vusdotq_s32(__rev0_882, (uint8x16_t)(__noswap_splatq_lane_s32(*(int32x2_t *) &__reint_882, __p3_882)), __rev1_882); \
- __ret_882 = __builtin_shufflevector(__ret_882, __ret_882, 3, 2, 1, 0); \
- __ret_882; \
+#define vfmlalq_laneq_low_f16(__p0_898, __p1_898, __p2_898, __p3_898) __extension__ ({ \
+ float32x4_t __ret_898; \
+ float32x4_t __s0_898 = __p0_898; \
+ float16x8_t __s1_898 = __p1_898; \
+ float16x8_t __s2_898 = __p2_898; \
+ float32x4_t __rev0_898; __rev0_898 = __builtin_shufflevector(__s0_898, __s0_898, 3, 2, 1, 0); \
+ float16x8_t __rev1_898; __rev1_898 = __builtin_shufflevector(__s1_898, __s1_898, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev2_898; __rev2_898 = __builtin_shufflevector(__s2_898, __s2_898, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_898 = __noswap_vfmlalq_low_f16(__rev0_898, __rev1_898, (float16x8_t) {__noswap_vgetq_lane_f16(__rev2_898, __p3_898), __noswap_vgetq_lane_f16(__rev2_898, __p3_898), __noswap_vgetq_lane_f16(__rev2_898, __p3_898), __noswap_vgetq_lane_f16(__rev2_898, __p3_898), __noswap_vgetq_lane_f16(__rev2_898, __p3_898), __noswap_vgetq_lane_f16(__rev2_898, __p3_898), __noswap_vgetq_lane_f16(__rev2_898, __p3_898), __noswap_vgetq_lane_f16(__rev2_898, __p3_898)}); \
+ __ret_898 = __builtin_shufflevector(__ret_898, __ret_898, 3, 2, 1, 0); \
+ __ret_898; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vsudot_lane_s32(__p0_883, __p1_883, __p2_883, __p3_883) __extension__ ({ \
- int32x2_t __ret_883; \
- int32x2_t __s0_883 = __p0_883; \
- int8x8_t __s1_883 = __p1_883; \
- uint8x8_t __s2_883 = __p2_883; \
-uint8x8_t __reint_883 = __s2_883; \
- __ret_883 = vusdot_s32(__s0_883, (uint8x8_t)(splat_lane_s32(*(int32x2_t *) &__reint_883, __p3_883)), __s1_883); \
- __ret_883; \
+#define vfmlal_laneq_low_f16(__p0_899, __p1_899, __p2_899, __p3_899) __extension__ ({ \
+ float32x2_t __ret_899; \
+ float32x2_t __s0_899 = __p0_899; \
+ float16x4_t __s1_899 = __p1_899; \
+ float16x8_t __s2_899 = __p2_899; \
+ __ret_899 = vfmlal_low_f16(__s0_899, __s1_899, (float16x4_t) {vgetq_lane_f16(__s2_899, __p3_899), vgetq_lane_f16(__s2_899, __p3_899), vgetq_lane_f16(__s2_899, __p3_899), vgetq_lane_f16(__s2_899, __p3_899)}); \
+ __ret_899; \
})
#else
-#define vsudot_lane_s32(__p0_884, __p1_884, __p2_884, __p3_884) __extension__ ({ \
- int32x2_t __ret_884; \
- int32x2_t __s0_884 = __p0_884; \
- int8x8_t __s1_884 = __p1_884; \
- uint8x8_t __s2_884 = __p2_884; \
- int32x2_t __rev0_884; __rev0_884 = __builtin_shufflevector(__s0_884, __s0_884, 1, 0); \
- int8x8_t __rev1_884; __rev1_884 = __builtin_shufflevector(__s1_884, __s1_884, 7, 6, 5, 4, 3, 2, 1, 0); \
- uint8x8_t __rev2_884; __rev2_884 = __builtin_shufflevector(__s2_884, __s2_884, 7, 6, 5, 4, 3, 2, 1, 0); \
-uint8x8_t __reint_884 = __rev2_884; \
- __ret_884 = __noswap_vusdot_s32(__rev0_884, (uint8x8_t)(__noswap_splat_lane_s32(*(int32x2_t *) &__reint_884, __p3_884)), __rev1_884); \
- __ret_884 = __builtin_shufflevector(__ret_884, __ret_884, 1, 0); \
- __ret_884; \
+#define vfmlal_laneq_low_f16(__p0_900, __p1_900, __p2_900, __p3_900) __extension__ ({ \
+ float32x2_t __ret_900; \
+ float32x2_t __s0_900 = __p0_900; \
+ float16x4_t __s1_900 = __p1_900; \
+ float16x8_t __s2_900 = __p2_900; \
+ float32x2_t __rev0_900; __rev0_900 = __builtin_shufflevector(__s0_900, __s0_900, 1, 0); \
+ float16x4_t __rev1_900; __rev1_900 = __builtin_shufflevector(__s1_900, __s1_900, 3, 2, 1, 0); \
+ float16x8_t __rev2_900; __rev2_900 = __builtin_shufflevector(__s2_900, __s2_900, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_900 = __noswap_vfmlal_low_f16(__rev0_900, __rev1_900, (float16x4_t) {__noswap_vgetq_lane_f16(__rev2_900, __p3_900), __noswap_vgetq_lane_f16(__rev2_900, __p3_900), __noswap_vgetq_lane_f16(__rev2_900, __p3_900), __noswap_vgetq_lane_f16(__rev2_900, __p3_900)}); \
+ __ret_900 = __builtin_shufflevector(__ret_900, __ret_900, 1, 0); \
+ __ret_900; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlslq_lane_high_f16(__p0_901, __p1_901, __p2_901, __p3_901) __extension__ ({ \
+ float32x4_t __ret_901; \
+ float32x4_t __s0_901 = __p0_901; \
+ float16x8_t __s1_901 = __p1_901; \
+ float16x4_t __s2_901 = __p2_901; \
+ __ret_901 = vfmlslq_high_f16(__s0_901, __s1_901, (float16x8_t) {vget_lane_f16(__s2_901, __p3_901), vget_lane_f16(__s2_901, __p3_901), vget_lane_f16(__s2_901, __p3_901), vget_lane_f16(__s2_901, __p3_901), vget_lane_f16(__s2_901, __p3_901), vget_lane_f16(__s2_901, __p3_901), vget_lane_f16(__s2_901, __p3_901), vget_lane_f16(__s2_901, __p3_901)}); \
+ __ret_901; \
+})
+#else
+#define vfmlslq_lane_high_f16(__p0_902, __p1_902, __p2_902, __p3_902) __extension__ ({ \
+ float32x4_t __ret_902; \
+ float32x4_t __s0_902 = __p0_902; \
+ float16x8_t __s1_902 = __p1_902; \
+ float16x4_t __s2_902 = __p2_902; \
+ float32x4_t __rev0_902; __rev0_902 = __builtin_shufflevector(__s0_902, __s0_902, 3, 2, 1, 0); \
+ float16x8_t __rev1_902; __rev1_902 = __builtin_shufflevector(__s1_902, __s1_902, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x4_t __rev2_902; __rev2_902 = __builtin_shufflevector(__s2_902, __s2_902, 3, 2, 1, 0); \
+ __ret_902 = __noswap_vfmlslq_high_f16(__rev0_902, __rev1_902, (float16x8_t) {__noswap_vget_lane_f16(__rev2_902, __p3_902), __noswap_vget_lane_f16(__rev2_902, __p3_902), __noswap_vget_lane_f16(__rev2_902, __p3_902), __noswap_vget_lane_f16(__rev2_902, __p3_902), __noswap_vget_lane_f16(__rev2_902, __p3_902), __noswap_vget_lane_f16(__rev2_902, __p3_902), __noswap_vget_lane_f16(__rev2_902, __p3_902), __noswap_vget_lane_f16(__rev2_902, __p3_902)}); \
+ __ret_902 = __builtin_shufflevector(__ret_902, __ret_902, 3, 2, 1, 0); \
+ __ret_902; \
})
#endif
-#if defined(__aarch64__)
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vabdl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
+#define vfmlsl_lane_high_f16(__p0_903, __p1_903, __p2_903, __p3_903) __extension__ ({ \
+ float32x2_t __ret_903; \
+ float32x2_t __s0_903 = __p0_903; \
+ float16x4_t __s1_903 = __p1_903; \
+ float16x4_t __s2_903 = __p2_903; \
+ __ret_903 = vfmlsl_high_f16(__s0_903, __s1_903, (float16x4_t) {vget_lane_f16(__s2_903, __p3_903), vget_lane_f16(__s2_903, __p3_903), vget_lane_f16(__s2_903, __p3_903), vget_lane_f16(__s2_903, __p3_903)}); \
+ __ret_903; \
+})
+#else
+#define vfmlsl_lane_high_f16(__p0_904, __p1_904, __p2_904, __p3_904) __extension__ ({ \
+ float32x2_t __ret_904; \
+ float32x2_t __s0_904 = __p0_904; \
+ float16x4_t __s1_904 = __p1_904; \
+ float16x4_t __s2_904 = __p2_904; \
+ float32x2_t __rev0_904; __rev0_904 = __builtin_shufflevector(__s0_904, __s0_904, 1, 0); \
+ float16x4_t __rev1_904; __rev1_904 = __builtin_shufflevector(__s1_904, __s1_904, 3, 2, 1, 0); \
+ float16x4_t __rev2_904; __rev2_904 = __builtin_shufflevector(__s2_904, __s2_904, 3, 2, 1, 0); \
+ __ret_904 = __noswap_vfmlsl_high_f16(__rev0_904, __rev1_904, (float16x4_t) {__noswap_vget_lane_f16(__rev2_904, __p3_904), __noswap_vget_lane_f16(__rev2_904, __p3_904), __noswap_vget_lane_f16(__rev2_904, __p3_904), __noswap_vget_lane_f16(__rev2_904, __p3_904)}); \
+ __ret_904 = __builtin_shufflevector(__ret_904, __ret_904, 1, 0); \
+ __ret_904; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlslq_lane_low_f16(__p0_905, __p1_905, __p2_905, __p3_905) __extension__ ({ \
+ float32x4_t __ret_905; \
+ float32x4_t __s0_905 = __p0_905; \
+ float16x8_t __s1_905 = __p1_905; \
+ float16x4_t __s2_905 = __p2_905; \
+ __ret_905 = vfmlslq_low_f16(__s0_905, __s1_905, (float16x8_t) {vget_lane_f16(__s2_905, __p3_905), vget_lane_f16(__s2_905, __p3_905), vget_lane_f16(__s2_905, __p3_905), vget_lane_f16(__s2_905, __p3_905), vget_lane_f16(__s2_905, __p3_905), vget_lane_f16(__s2_905, __p3_905), vget_lane_f16(__s2_905, __p3_905), vget_lane_f16(__s2_905, __p3_905)}); \
+ __ret_905; \
+})
+#else
+#define vfmlslq_lane_low_f16(__p0_906, __p1_906, __p2_906, __p3_906) __extension__ ({ \
+ float32x4_t __ret_906; \
+ float32x4_t __s0_906 = __p0_906; \
+ float16x8_t __s1_906 = __p1_906; \
+ float16x4_t __s2_906 = __p2_906; \
+ float32x4_t __rev0_906; __rev0_906 = __builtin_shufflevector(__s0_906, __s0_906, 3, 2, 1, 0); \
+ float16x8_t __rev1_906; __rev1_906 = __builtin_shufflevector(__s1_906, __s1_906, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x4_t __rev2_906; __rev2_906 = __builtin_shufflevector(__s2_906, __s2_906, 3, 2, 1, 0); \
+ __ret_906 = __noswap_vfmlslq_low_f16(__rev0_906, __rev1_906, (float16x8_t) {__noswap_vget_lane_f16(__rev2_906, __p3_906), __noswap_vget_lane_f16(__rev2_906, __p3_906), __noswap_vget_lane_f16(__rev2_906, __p3_906), __noswap_vget_lane_f16(__rev2_906, __p3_906), __noswap_vget_lane_f16(__rev2_906, __p3_906), __noswap_vget_lane_f16(__rev2_906, __p3_906), __noswap_vget_lane_f16(__rev2_906, __p3_906), __noswap_vget_lane_f16(__rev2_906, __p3_906)}); \
+ __ret_906 = __builtin_shufflevector(__ret_906, __ret_906, 3, 2, 1, 0); \
+ __ret_906; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlsl_lane_low_f16(__p0_907, __p1_907, __p2_907, __p3_907) __extension__ ({ \
+ float32x2_t __ret_907; \
+ float32x2_t __s0_907 = __p0_907; \
+ float16x4_t __s1_907 = __p1_907; \
+ float16x4_t __s2_907 = __p2_907; \
+ __ret_907 = vfmlsl_low_f16(__s0_907, __s1_907, (float16x4_t) {vget_lane_f16(__s2_907, __p3_907), vget_lane_f16(__s2_907, __p3_907), vget_lane_f16(__s2_907, __p3_907), vget_lane_f16(__s2_907, __p3_907)}); \
+ __ret_907; \
+})
+#else
+#define vfmlsl_lane_low_f16(__p0_908, __p1_908, __p2_908, __p3_908) __extension__ ({ \
+ float32x2_t __ret_908; \
+ float32x2_t __s0_908 = __p0_908; \
+ float16x4_t __s1_908 = __p1_908; \
+ float16x4_t __s2_908 = __p2_908; \
+ float32x2_t __rev0_908; __rev0_908 = __builtin_shufflevector(__s0_908, __s0_908, 1, 0); \
+ float16x4_t __rev1_908; __rev1_908 = __builtin_shufflevector(__s1_908, __s1_908, 3, 2, 1, 0); \
+ float16x4_t __rev2_908; __rev2_908 = __builtin_shufflevector(__s2_908, __s2_908, 3, 2, 1, 0); \
+ __ret_908 = __noswap_vfmlsl_low_f16(__rev0_908, __rev1_908, (float16x4_t) {__noswap_vget_lane_f16(__rev2_908, __p3_908), __noswap_vget_lane_f16(__rev2_908, __p3_908), __noswap_vget_lane_f16(__rev2_908, __p3_908), __noswap_vget_lane_f16(__rev2_908, __p3_908)}); \
+ __ret_908 = __builtin_shufflevector(__ret_908, __ret_908, 1, 0); \
+ __ret_908; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlslq_laneq_high_f16(__p0_909, __p1_909, __p2_909, __p3_909) __extension__ ({ \
+ float32x4_t __ret_909; \
+ float32x4_t __s0_909 = __p0_909; \
+ float16x8_t __s1_909 = __p1_909; \
+ float16x8_t __s2_909 = __p2_909; \
+ __ret_909 = vfmlslq_high_f16(__s0_909, __s1_909, (float16x8_t) {vgetq_lane_f16(__s2_909, __p3_909), vgetq_lane_f16(__s2_909, __p3_909), vgetq_lane_f16(__s2_909, __p3_909), vgetq_lane_f16(__s2_909, __p3_909), vgetq_lane_f16(__s2_909, __p3_909), vgetq_lane_f16(__s2_909, __p3_909), vgetq_lane_f16(__s2_909, __p3_909), vgetq_lane_f16(__s2_909, __p3_909)}); \
+ __ret_909; \
+})
+#else
+#define vfmlslq_laneq_high_f16(__p0_910, __p1_910, __p2_910, __p3_910) __extension__ ({ \
+ float32x4_t __ret_910; \
+ float32x4_t __s0_910 = __p0_910; \
+ float16x8_t __s1_910 = __p1_910; \
+ float16x8_t __s2_910 = __p2_910; \
+ float32x4_t __rev0_910; __rev0_910 = __builtin_shufflevector(__s0_910, __s0_910, 3, 2, 1, 0); \
+ float16x8_t __rev1_910; __rev1_910 = __builtin_shufflevector(__s1_910, __s1_910, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev2_910; __rev2_910 = __builtin_shufflevector(__s2_910, __s2_910, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_910 = __noswap_vfmlslq_high_f16(__rev0_910, __rev1_910, (float16x8_t) {__noswap_vgetq_lane_f16(__rev2_910, __p3_910), __noswap_vgetq_lane_f16(__rev2_910, __p3_910), __noswap_vgetq_lane_f16(__rev2_910, __p3_910), __noswap_vgetq_lane_f16(__rev2_910, __p3_910), __noswap_vgetq_lane_f16(__rev2_910, __p3_910), __noswap_vgetq_lane_f16(__rev2_910, __p3_910), __noswap_vgetq_lane_f16(__rev2_910, __p3_910), __noswap_vgetq_lane_f16(__rev2_910, __p3_910)}); \
+ __ret_910 = __builtin_shufflevector(__ret_910, __ret_910, 3, 2, 1, 0); \
+ __ret_910; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlsl_laneq_high_f16(__p0_911, __p1_911, __p2_911, __p3_911) __extension__ ({ \
+ float32x2_t __ret_911; \
+ float32x2_t __s0_911 = __p0_911; \
+ float16x4_t __s1_911 = __p1_911; \
+ float16x8_t __s2_911 = __p2_911; \
+ __ret_911 = vfmlsl_high_f16(__s0_911, __s1_911, (float16x4_t) {vgetq_lane_f16(__s2_911, __p3_911), vgetq_lane_f16(__s2_911, __p3_911), vgetq_lane_f16(__s2_911, __p3_911), vgetq_lane_f16(__s2_911, __p3_911)}); \
+ __ret_911; \
+})
+#else
+#define vfmlsl_laneq_high_f16(__p0_912, __p1_912, __p2_912, __p3_912) __extension__ ({ \
+ float32x2_t __ret_912; \
+ float32x2_t __s0_912 = __p0_912; \
+ float16x4_t __s1_912 = __p1_912; \
+ float16x8_t __s2_912 = __p2_912; \
+ float32x2_t __rev0_912; __rev0_912 = __builtin_shufflevector(__s0_912, __s0_912, 1, 0); \
+ float16x4_t __rev1_912; __rev1_912 = __builtin_shufflevector(__s1_912, __s1_912, 3, 2, 1, 0); \
+ float16x8_t __rev2_912; __rev2_912 = __builtin_shufflevector(__s2_912, __s2_912, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_912 = __noswap_vfmlsl_high_f16(__rev0_912, __rev1_912, (float16x4_t) {__noswap_vgetq_lane_f16(__rev2_912, __p3_912), __noswap_vgetq_lane_f16(__rev2_912, __p3_912), __noswap_vgetq_lane_f16(__rev2_912, __p3_912), __noswap_vgetq_lane_f16(__rev2_912, __p3_912)}); \
+ __ret_912 = __builtin_shufflevector(__ret_912, __ret_912, 1, 0); \
+ __ret_912; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlslq_laneq_low_f16(__p0_913, __p1_913, __p2_913, __p3_913) __extension__ ({ \
+ float32x4_t __ret_913; \
+ float32x4_t __s0_913 = __p0_913; \
+ float16x8_t __s1_913 = __p1_913; \
+ float16x8_t __s2_913 = __p2_913; \
+ __ret_913 = vfmlslq_low_f16(__s0_913, __s1_913, (float16x8_t) {vgetq_lane_f16(__s2_913, __p3_913), vgetq_lane_f16(__s2_913, __p3_913), vgetq_lane_f16(__s2_913, __p3_913), vgetq_lane_f16(__s2_913, __p3_913), vgetq_lane_f16(__s2_913, __p3_913), vgetq_lane_f16(__s2_913, __p3_913), vgetq_lane_f16(__s2_913, __p3_913), vgetq_lane_f16(__s2_913, __p3_913)}); \
+ __ret_913; \
+})
+#else
+#define vfmlslq_laneq_low_f16(__p0_914, __p1_914, __p2_914, __p3_914) __extension__ ({ \
+ float32x4_t __ret_914; \
+ float32x4_t __s0_914 = __p0_914; \
+ float16x8_t __s1_914 = __p1_914; \
+ float16x8_t __s2_914 = __p2_914; \
+ float32x4_t __rev0_914; __rev0_914 = __builtin_shufflevector(__s0_914, __s0_914, 3, 2, 1, 0); \
+ float16x8_t __rev1_914; __rev1_914 = __builtin_shufflevector(__s1_914, __s1_914, 7, 6, 5, 4, 3, 2, 1, 0); \
+ float16x8_t __rev2_914; __rev2_914 = __builtin_shufflevector(__s2_914, __s2_914, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_914 = __noswap_vfmlslq_low_f16(__rev0_914, __rev1_914, (float16x8_t) {__noswap_vgetq_lane_f16(__rev2_914, __p3_914), __noswap_vgetq_lane_f16(__rev2_914, __p3_914), __noswap_vgetq_lane_f16(__rev2_914, __p3_914), __noswap_vgetq_lane_f16(__rev2_914, __p3_914), __noswap_vgetq_lane_f16(__rev2_914, __p3_914), __noswap_vgetq_lane_f16(__rev2_914, __p3_914), __noswap_vgetq_lane_f16(__rev2_914, __p3_914), __noswap_vgetq_lane_f16(__rev2_914, __p3_914)}); \
+ __ret_914 = __builtin_shufflevector(__ret_914, __ret_914, 3, 2, 1, 0); \
+ __ret_914; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlsl_laneq_low_f16(__p0_915, __p1_915, __p2_915, __p3_915) __extension__ ({ \
+ float32x2_t __ret_915; \
+ float32x2_t __s0_915 = __p0_915; \
+ float16x4_t __s1_915 = __p1_915; \
+ float16x8_t __s2_915 = __p2_915; \
+ __ret_915 = vfmlsl_low_f16(__s0_915, __s1_915, (float16x4_t) {vgetq_lane_f16(__s2_915, __p3_915), vgetq_lane_f16(__s2_915, __p3_915), vgetq_lane_f16(__s2_915, __p3_915), vgetq_lane_f16(__s2_915, __p3_915)}); \
+ __ret_915; \
+})
+#else
+#define vfmlsl_laneq_low_f16(__p0_916, __p1_916, __p2_916, __p3_916) __extension__ ({ \
+ float32x2_t __ret_916; \
+ float32x2_t __s0_916 = __p0_916; \
+ float16x4_t __s1_916 = __p1_916; \
+ float16x8_t __s2_916 = __p2_916; \
+ float32x2_t __rev0_916; __rev0_916 = __builtin_shufflevector(__s0_916, __s0_916, 1, 0); \
+ float16x4_t __rev1_916; __rev1_916 = __builtin_shufflevector(__s1_916, __s1_916, 3, 2, 1, 0); \
+ float16x8_t __rev2_916; __rev2_916 = __builtin_shufflevector(__s2_916, __s2_916, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_916 = __noswap_vfmlsl_low_f16(__rev0_916, __rev1_916, (float16x4_t) {__noswap_vgetq_lane_f16(__rev2_916, __p3_916), __noswap_vgetq_lane_f16(__rev2_916, __p3_916), __noswap_vgetq_lane_f16(__rev2_916, __p3_916), __noswap_vgetq_lane_f16(__rev2_916, __p3_916)}); \
+ __ret_916 = __builtin_shufflevector(__ret_916, __ret_916, 1, 0); \
+ __ret_916; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulh_lane_f16(__p0_917, __p1_917, __p2_917) __extension__ ({ \
+ float16_t __ret_917; \
+ float16_t __s0_917 = __p0_917; \
+ float16x4_t __s1_917 = __p1_917; \
+ __ret_917 = __s0_917 * vget_lane_f16(__s1_917, __p2_917); \
+ __ret_917; \
+})
+#else
+#define vmulh_lane_f16(__p0_918, __p1_918, __p2_918) __extension__ ({ \
+ float16_t __ret_918; \
+ float16_t __s0_918 = __p0_918; \
+ float16x4_t __s1_918 = __p1_918; \
+ float16x4_t __rev1_918; __rev1_918 = __builtin_shufflevector(__s1_918, __s1_918, 3, 2, 1, 0); \
+ __ret_918 = __s0_918 * __noswap_vget_lane_f16(__rev1_918, __p2_918); \
+ __ret_918; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulh_laneq_f16(__p0_919, __p1_919, __p2_919) __extension__ ({ \
+ float16_t __ret_919; \
+ float16_t __s0_919 = __p0_919; \
+ float16x8_t __s1_919 = __p1_919; \
+ __ret_919 = __s0_919 * vgetq_lane_f16(__s1_919, __p2_919); \
+ __ret_919; \
+})
+#else
+#define vmulh_laneq_f16(__p0_920, __p1_920, __p2_920) __extension__ ({ \
+ float16_t __ret_920; \
+ float16_t __s0_920 = __p0_920; \
+ float16x8_t __s1_920 = __p1_920; \
+ float16x8_t __rev1_920; __rev1_920 = __builtin_shufflevector(__s1_920, __s1_920, 7, 6, 5, 4, 3, 2, 1, 0); \
+ __ret_920 = __s0_920 * __noswap_vgetq_lane_f16(__rev1_920, __p2_920); \
+ __ret_920; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vabdl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
uint16x8_t __ret;
__ret = vabdl_u8(vget_high_u8(__p0), vget_high_u8(__p1));
return __ret;
}
#else
-__ai uint16x8_t vabdl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vabdl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
uint16x8_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68155,13 +68573,13 @@ __ai uint16x8_t vabdl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vabdl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vabdl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint64x2_t __ret;
__ret = vabdl_u32(vget_high_u32(__p0), vget_high_u32(__p1));
return __ret;
}
#else
-__ai uint64x2_t vabdl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vabdl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint64x2_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -68172,13 +68590,13 @@ __ai uint64x2_t vabdl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vabdl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vabdl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint32x4_t __ret;
__ret = vabdl_u16(vget_high_u16(__p0), vget_high_u16(__p1));
return __ret;
}
#else
-__ai uint32x4_t vabdl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vabdl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint32x4_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68189,13 +68607,13 @@ __ai uint32x4_t vabdl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vabdl_high_s8(int8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vabdl_high_s8(int8x16_t __p0, int8x16_t __p1) {
int16x8_t __ret;
__ret = vabdl_s8(vget_high_s8(__p0), vget_high_s8(__p1));
return __ret;
}
#else
-__ai int16x8_t vabdl_high_s8(int8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vabdl_high_s8(int8x16_t __p0, int8x16_t __p1) {
int16x8_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68206,13 +68624,13 @@ __ai int16x8_t vabdl_high_s8(int8x16_t __p0, int8x16_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vabdl_high_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vabdl_high_s32(int32x4_t __p0, int32x4_t __p1) {
int64x2_t __ret;
__ret = vabdl_s32(vget_high_s32(__p0), vget_high_s32(__p1));
return __ret;
}
#else
-__ai int64x2_t vabdl_high_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vabdl_high_s32(int32x4_t __p0, int32x4_t __p1) {
int64x2_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -68223,13 +68641,13 @@ __ai int64x2_t vabdl_high_s32(int32x4_t __p0, int32x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vabdl_high_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vabdl_high_s16(int16x8_t __p0, int16x8_t __p1) {
int32x4_t __ret;
__ret = vabdl_s16(vget_high_s16(__p0), vget_high_s16(__p1));
return __ret;
}
#else
-__ai int32x4_t vabdl_high_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vabdl_high_s16(int16x8_t __p0, int16x8_t __p1) {
int32x4_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68240,13 +68658,13 @@ __ai int32x4_t vabdl_high_s16(int16x8_t __p0, int16x8_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vaddl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vaddl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
uint16x8_t __ret;
__ret = vmovl_high_u8(__p0) + vmovl_high_u8(__p1);
return __ret;
}
#else
-__ai uint16x8_t vaddl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vaddl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
uint16x8_t __ret;
uint8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68257,13 +68675,13 @@ __ai uint16x8_t vaddl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vaddl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vaddl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint64x2_t __ret;
__ret = vmovl_high_u32(__p0) + vmovl_high_u32(__p1);
return __ret;
}
#else
-__ai uint64x2_t vaddl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vaddl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
uint64x2_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -68274,13 +68692,13 @@ __ai uint64x2_t vaddl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vaddl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vaddl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint32x4_t __ret;
__ret = vmovl_high_u16(__p0) + vmovl_high_u16(__p1);
return __ret;
}
#else
-__ai uint32x4_t vaddl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vaddl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
uint32x4_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68291,13 +68709,13 @@ __ai uint32x4_t vaddl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vaddl_high_s8(int8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vaddl_high_s8(int8x16_t __p0, int8x16_t __p1) {
int16x8_t __ret;
__ret = vmovl_high_s8(__p0) + vmovl_high_s8(__p1);
return __ret;
}
#else
-__ai int16x8_t vaddl_high_s8(int8x16_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vaddl_high_s8(int8x16_t __p0, int8x16_t __p1) {
int16x8_t __ret;
int8x16_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68308,13 +68726,13 @@ __ai int16x8_t vaddl_high_s8(int8x16_t __p0, int8x16_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vaddl_high_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vaddl_high_s32(int32x4_t __p0, int32x4_t __p1) {
int64x2_t __ret;
__ret = vmovl_high_s32(__p0) + vmovl_high_s32(__p1);
return __ret;
}
#else
-__ai int64x2_t vaddl_high_s32(int32x4_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vaddl_high_s32(int32x4_t __p0, int32x4_t __p1) {
int64x2_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -68325,13 +68743,13 @@ __ai int64x2_t vaddl_high_s32(int32x4_t __p0, int32x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vaddl_high_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vaddl_high_s16(int16x8_t __p0, int16x8_t __p1) {
int32x4_t __ret;
__ret = vmovl_high_s16(__p0) + vmovl_high_s16(__p1);
return __ret;
}
#else
-__ai int32x4_t vaddl_high_s16(int16x8_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vaddl_high_s16(int16x8_t __p0, int16x8_t __p1) {
int32x4_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68342,13 +68760,13 @@ __ai int32x4_t vaddl_high_s16(int16x8_t __p0, int16x8_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vaddw_high_u8(uint16x8_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vaddw_high_u8(uint16x8_t __p0, uint8x16_t __p1) {
uint16x8_t __ret;
__ret = __p0 + vmovl_high_u8(__p1);
return __ret;
}
#else
-__ai uint16x8_t vaddw_high_u8(uint16x8_t __p0, uint8x16_t __p1) {
+__ai __attribute__((target("neon"))) uint16x8_t vaddw_high_u8(uint16x8_t __p0, uint8x16_t __p1) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68359,13 +68777,13 @@ __ai uint16x8_t vaddw_high_u8(uint16x8_t __p0, uint8x16_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vaddw_high_u32(uint64x2_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vaddw_high_u32(uint64x2_t __p0, uint32x4_t __p1) {
uint64x2_t __ret;
__ret = __p0 + vmovl_high_u32(__p1);
return __ret;
}
#else
-__ai uint64x2_t vaddw_high_u32(uint64x2_t __p0, uint32x4_t __p1) {
+__ai __attribute__((target("neon"))) uint64x2_t vaddw_high_u32(uint64x2_t __p0, uint32x4_t __p1) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -68376,13 +68794,13 @@ __ai uint64x2_t vaddw_high_u32(uint64x2_t __p0, uint32x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vaddw_high_u16(uint32x4_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vaddw_high_u16(uint32x4_t __p0, uint16x8_t __p1) {
uint32x4_t __ret;
__ret = __p0 + vmovl_high_u16(__p1);
return __ret;
}
#else
-__ai uint32x4_t vaddw_high_u16(uint32x4_t __p0, uint16x8_t __p1) {
+__ai __attribute__((target("neon"))) uint32x4_t vaddw_high_u16(uint32x4_t __p0, uint16x8_t __p1) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68393,13 +68811,13 @@ __ai uint32x4_t vaddw_high_u16(uint32x4_t __p0, uint16x8_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vaddw_high_s8(int16x8_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vaddw_high_s8(int16x8_t __p0, int8x16_t __p1) {
int16x8_t __ret;
__ret = __p0 + vmovl_high_s8(__p1);
return __ret;
}
#else
-__ai int16x8_t vaddw_high_s8(int16x8_t __p0, int8x16_t __p1) {
+__ai __attribute__((target("neon"))) int16x8_t vaddw_high_s8(int16x8_t __p0, int8x16_t __p1) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68410,13 +68828,13 @@ __ai int16x8_t vaddw_high_s8(int16x8_t __p0, int8x16_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vaddw_high_s32(int64x2_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vaddw_high_s32(int64x2_t __p0, int32x4_t __p1) {
int64x2_t __ret;
__ret = __p0 + vmovl_high_s32(__p1);
return __ret;
}
#else
-__ai int64x2_t vaddw_high_s32(int64x2_t __p0, int32x4_t __p1) {
+__ai __attribute__((target("neon"))) int64x2_t vaddw_high_s32(int64x2_t __p0, int32x4_t __p1) {
int64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -68427,13 +68845,13 @@ __ai int64x2_t vaddw_high_s32(int64x2_t __p0, int32x4_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vaddw_high_s16(int32x4_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vaddw_high_s16(int32x4_t __p0, int16x8_t __p1) {
int32x4_t __ret;
__ret = __p0 + vmovl_high_s16(__p1);
return __ret;
}
#else
-__ai int32x4_t vaddw_high_s16(int32x4_t __p0, int16x8_t __p1) {
+__ai __attribute__((target("neon"))) int32x4_t vaddw_high_s16(int32x4_t __p0, int16x8_t __p1) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68444,147 +68862,147 @@ __ai int32x4_t vaddw_high_s16(int32x4_t __p0, int16x8_t __p1) {
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_lane_p64(__p0_885, __p1_885, __p2_885, __p3_885) __extension__ ({ \
- poly64x2_t __ret_885; \
- poly64x2_t __s0_885 = __p0_885; \
- poly64x1_t __s2_885 = __p2_885; \
- __ret_885 = vsetq_lane_p64(vget_lane_p64(__s2_885, __p3_885), __s0_885, __p1_885); \
- __ret_885; \
+#define vcopyq_lane_p64(__p0_921, __p1_921, __p2_921, __p3_921) __extension__ ({ \
+ poly64x2_t __ret_921; \
+ poly64x2_t __s0_921 = __p0_921; \
+ poly64x1_t __s2_921 = __p2_921; \
+ __ret_921 = vsetq_lane_p64(vget_lane_p64(__s2_921, __p3_921), __s0_921, __p1_921); \
+ __ret_921; \
})
#else
-#define vcopyq_lane_p64(__p0_886, __p1_886, __p2_886, __p3_886) __extension__ ({ \
- poly64x2_t __ret_886; \
- poly64x2_t __s0_886 = __p0_886; \
- poly64x1_t __s2_886 = __p2_886; \
- poly64x2_t __rev0_886; __rev0_886 = __builtin_shufflevector(__s0_886, __s0_886, 1, 0); \
- __ret_886 = __noswap_vsetq_lane_p64(vget_lane_p64(__s2_886, __p3_886), __rev0_886, __p1_886); \
- __ret_886 = __builtin_shufflevector(__ret_886, __ret_886, 1, 0); \
- __ret_886; \
+#define vcopyq_lane_p64(__p0_922, __p1_922, __p2_922, __p3_922) __extension__ ({ \
+ poly64x2_t __ret_922; \
+ poly64x2_t __s0_922 = __p0_922; \
+ poly64x1_t __s2_922 = __p2_922; \
+ poly64x2_t __rev0_922; __rev0_922 = __builtin_shufflevector(__s0_922, __s0_922, 1, 0); \
+ __ret_922 = __noswap_vsetq_lane_p64(vget_lane_p64(__s2_922, __p3_922), __rev0_922, __p1_922); \
+ __ret_922 = __builtin_shufflevector(__ret_922, __ret_922, 1, 0); \
+ __ret_922; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_lane_f64(__p0_887, __p1_887, __p2_887, __p3_887) __extension__ ({ \
- float64x2_t __ret_887; \
- float64x2_t __s0_887 = __p0_887; \
- float64x1_t __s2_887 = __p2_887; \
- __ret_887 = vsetq_lane_f64(vget_lane_f64(__s2_887, __p3_887), __s0_887, __p1_887); \
- __ret_887; \
+#define vcopyq_lane_f64(__p0_923, __p1_923, __p2_923, __p3_923) __extension__ ({ \
+ float64x2_t __ret_923; \
+ float64x2_t __s0_923 = __p0_923; \
+ float64x1_t __s2_923 = __p2_923; \
+ __ret_923 = vsetq_lane_f64(vget_lane_f64(__s2_923, __p3_923), __s0_923, __p1_923); \
+ __ret_923; \
})
#else
-#define vcopyq_lane_f64(__p0_888, __p1_888, __p2_888, __p3_888) __extension__ ({ \
- float64x2_t __ret_888; \
- float64x2_t __s0_888 = __p0_888; \
- float64x1_t __s2_888 = __p2_888; \
- float64x2_t __rev0_888; __rev0_888 = __builtin_shufflevector(__s0_888, __s0_888, 1, 0); \
- __ret_888 = __noswap_vsetq_lane_f64(vget_lane_f64(__s2_888, __p3_888), __rev0_888, __p1_888); \
- __ret_888 = __builtin_shufflevector(__ret_888, __ret_888, 1, 0); \
- __ret_888; \
+#define vcopyq_lane_f64(__p0_924, __p1_924, __p2_924, __p3_924) __extension__ ({ \
+ float64x2_t __ret_924; \
+ float64x2_t __s0_924 = __p0_924; \
+ float64x1_t __s2_924 = __p2_924; \
+ float64x2_t __rev0_924; __rev0_924 = __builtin_shufflevector(__s0_924, __s0_924, 1, 0); \
+ __ret_924 = __noswap_vsetq_lane_f64(vget_lane_f64(__s2_924, __p3_924), __rev0_924, __p1_924); \
+ __ret_924 = __builtin_shufflevector(__ret_924, __ret_924, 1, 0); \
+ __ret_924; \
})
#endif
-#define vcopy_lane_p64(__p0_889, __p1_889, __p2_889, __p3_889) __extension__ ({ \
- poly64x1_t __ret_889; \
- poly64x1_t __s0_889 = __p0_889; \
- poly64x1_t __s2_889 = __p2_889; \
- __ret_889 = vset_lane_p64(vget_lane_p64(__s2_889, __p3_889), __s0_889, __p1_889); \
- __ret_889; \
+#define vcopy_lane_p64(__p0_925, __p1_925, __p2_925, __p3_925) __extension__ ({ \
+ poly64x1_t __ret_925; \
+ poly64x1_t __s0_925 = __p0_925; \
+ poly64x1_t __s2_925 = __p2_925; \
+ __ret_925 = vset_lane_p64(vget_lane_p64(__s2_925, __p3_925), __s0_925, __p1_925); \
+ __ret_925; \
})
-#define vcopy_lane_f64(__p0_890, __p1_890, __p2_890, __p3_890) __extension__ ({ \
- float64x1_t __ret_890; \
- float64x1_t __s0_890 = __p0_890; \
- float64x1_t __s2_890 = __p2_890; \
- __ret_890 = vset_lane_f64(vget_lane_f64(__s2_890, __p3_890), __s0_890, __p1_890); \
- __ret_890; \
+#define vcopy_lane_f64(__p0_926, __p1_926, __p2_926, __p3_926) __extension__ ({ \
+ float64x1_t __ret_926; \
+ float64x1_t __s0_926 = __p0_926; \
+ float64x1_t __s2_926 = __p2_926; \
+ __ret_926 = vset_lane_f64(vget_lane_f64(__s2_926, __p3_926), __s0_926, __p1_926); \
+ __ret_926; \
})
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_laneq_p64(__p0_891, __p1_891, __p2_891, __p3_891) __extension__ ({ \
- poly64x2_t __ret_891; \
- poly64x2_t __s0_891 = __p0_891; \
- poly64x2_t __s2_891 = __p2_891; \
- __ret_891 = vsetq_lane_p64(vgetq_lane_p64(__s2_891, __p3_891), __s0_891, __p1_891); \
- __ret_891; \
+#define vcopyq_laneq_p64(__p0_927, __p1_927, __p2_927, __p3_927) __extension__ ({ \
+ poly64x2_t __ret_927; \
+ poly64x2_t __s0_927 = __p0_927; \
+ poly64x2_t __s2_927 = __p2_927; \
+ __ret_927 = vsetq_lane_p64(vgetq_lane_p64(__s2_927, __p3_927), __s0_927, __p1_927); \
+ __ret_927; \
})
#else
-#define vcopyq_laneq_p64(__p0_892, __p1_892, __p2_892, __p3_892) __extension__ ({ \
- poly64x2_t __ret_892; \
- poly64x2_t __s0_892 = __p0_892; \
- poly64x2_t __s2_892 = __p2_892; \
- poly64x2_t __rev0_892; __rev0_892 = __builtin_shufflevector(__s0_892, __s0_892, 1, 0); \
- poly64x2_t __rev2_892; __rev2_892 = __builtin_shufflevector(__s2_892, __s2_892, 1, 0); \
- __ret_892 = __noswap_vsetq_lane_p64(__noswap_vgetq_lane_p64(__rev2_892, __p3_892), __rev0_892, __p1_892); \
- __ret_892 = __builtin_shufflevector(__ret_892, __ret_892, 1, 0); \
- __ret_892; \
+#define vcopyq_laneq_p64(__p0_928, __p1_928, __p2_928, __p3_928) __extension__ ({ \
+ poly64x2_t __ret_928; \
+ poly64x2_t __s0_928 = __p0_928; \
+ poly64x2_t __s2_928 = __p2_928; \
+ poly64x2_t __rev0_928; __rev0_928 = __builtin_shufflevector(__s0_928, __s0_928, 1, 0); \
+ poly64x2_t __rev2_928; __rev2_928 = __builtin_shufflevector(__s2_928, __s2_928, 1, 0); \
+ __ret_928 = __noswap_vsetq_lane_p64(__noswap_vgetq_lane_p64(__rev2_928, __p3_928), __rev0_928, __p1_928); \
+ __ret_928 = __builtin_shufflevector(__ret_928, __ret_928, 1, 0); \
+ __ret_928; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopyq_laneq_f64(__p0_893, __p1_893, __p2_893, __p3_893) __extension__ ({ \
- float64x2_t __ret_893; \
- float64x2_t __s0_893 = __p0_893; \
- float64x2_t __s2_893 = __p2_893; \
- __ret_893 = vsetq_lane_f64(vgetq_lane_f64(__s2_893, __p3_893), __s0_893, __p1_893); \
- __ret_893; \
+#define vcopyq_laneq_f64(__p0_929, __p1_929, __p2_929, __p3_929) __extension__ ({ \
+ float64x2_t __ret_929; \
+ float64x2_t __s0_929 = __p0_929; \
+ float64x2_t __s2_929 = __p2_929; \
+ __ret_929 = vsetq_lane_f64(vgetq_lane_f64(__s2_929, __p3_929), __s0_929, __p1_929); \
+ __ret_929; \
})
#else
-#define vcopyq_laneq_f64(__p0_894, __p1_894, __p2_894, __p3_894) __extension__ ({ \
- float64x2_t __ret_894; \
- float64x2_t __s0_894 = __p0_894; \
- float64x2_t __s2_894 = __p2_894; \
- float64x2_t __rev0_894; __rev0_894 = __builtin_shufflevector(__s0_894, __s0_894, 1, 0); \
- float64x2_t __rev2_894; __rev2_894 = __builtin_shufflevector(__s2_894, __s2_894, 1, 0); \
- __ret_894 = __noswap_vsetq_lane_f64(__noswap_vgetq_lane_f64(__rev2_894, __p3_894), __rev0_894, __p1_894); \
- __ret_894 = __builtin_shufflevector(__ret_894, __ret_894, 1, 0); \
- __ret_894; \
+#define vcopyq_laneq_f64(__p0_930, __p1_930, __p2_930, __p3_930) __extension__ ({ \
+ float64x2_t __ret_930; \
+ float64x2_t __s0_930 = __p0_930; \
+ float64x2_t __s2_930 = __p2_930; \
+ float64x2_t __rev0_930; __rev0_930 = __builtin_shufflevector(__s0_930, __s0_930, 1, 0); \
+ float64x2_t __rev2_930; __rev2_930 = __builtin_shufflevector(__s2_930, __s2_930, 1, 0); \
+ __ret_930 = __noswap_vsetq_lane_f64(__noswap_vgetq_lane_f64(__rev2_930, __p3_930), __rev0_930, __p1_930); \
+ __ret_930 = __builtin_shufflevector(__ret_930, __ret_930, 1, 0); \
+ __ret_930; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopy_laneq_p64(__p0_895, __p1_895, __p2_895, __p3_895) __extension__ ({ \
- poly64x1_t __ret_895; \
- poly64x1_t __s0_895 = __p0_895; \
- poly64x2_t __s2_895 = __p2_895; \
- __ret_895 = vset_lane_p64(vgetq_lane_p64(__s2_895, __p3_895), __s0_895, __p1_895); \
- __ret_895; \
+#define vcopy_laneq_p64(__p0_931, __p1_931, __p2_931, __p3_931) __extension__ ({ \
+ poly64x1_t __ret_931; \
+ poly64x1_t __s0_931 = __p0_931; \
+ poly64x2_t __s2_931 = __p2_931; \
+ __ret_931 = vset_lane_p64(vgetq_lane_p64(__s2_931, __p3_931), __s0_931, __p1_931); \
+ __ret_931; \
})
#else
-#define vcopy_laneq_p64(__p0_896, __p1_896, __p2_896, __p3_896) __extension__ ({ \
- poly64x1_t __ret_896; \
- poly64x1_t __s0_896 = __p0_896; \
- poly64x2_t __s2_896 = __p2_896; \
- poly64x2_t __rev2_896; __rev2_896 = __builtin_shufflevector(__s2_896, __s2_896, 1, 0); \
- __ret_896 = vset_lane_p64(__noswap_vgetq_lane_p64(__rev2_896, __p3_896), __s0_896, __p1_896); \
- __ret_896; \
+#define vcopy_laneq_p64(__p0_932, __p1_932, __p2_932, __p3_932) __extension__ ({ \
+ poly64x1_t __ret_932; \
+ poly64x1_t __s0_932 = __p0_932; \
+ poly64x2_t __s2_932 = __p2_932; \
+ poly64x2_t __rev2_932; __rev2_932 = __builtin_shufflevector(__s2_932, __s2_932, 1, 0); \
+ __ret_932 = vset_lane_p64(__noswap_vgetq_lane_p64(__rev2_932, __p3_932), __s0_932, __p1_932); \
+ __ret_932; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-#define vcopy_laneq_f64(__p0_897, __p1_897, __p2_897, __p3_897) __extension__ ({ \
- float64x1_t __ret_897; \
- float64x1_t __s0_897 = __p0_897; \
- float64x2_t __s2_897 = __p2_897; \
- __ret_897 = vset_lane_f64(vgetq_lane_f64(__s2_897, __p3_897), __s0_897, __p1_897); \
- __ret_897; \
+#define vcopy_laneq_f64(__p0_933, __p1_933, __p2_933, __p3_933) __extension__ ({ \
+ float64x1_t __ret_933; \
+ float64x1_t __s0_933 = __p0_933; \
+ float64x2_t __s2_933 = __p2_933; \
+ __ret_933 = vset_lane_f64(vgetq_lane_f64(__s2_933, __p3_933), __s0_933, __p1_933); \
+ __ret_933; \
})
#else
-#define vcopy_laneq_f64(__p0_898, __p1_898, __p2_898, __p3_898) __extension__ ({ \
- float64x1_t __ret_898; \
- float64x1_t __s0_898 = __p0_898; \
- float64x2_t __s2_898 = __p2_898; \
- float64x2_t __rev2_898; __rev2_898 = __builtin_shufflevector(__s2_898, __s2_898, 1, 0); \
- __ret_898 = vset_lane_f64(__noswap_vgetq_lane_f64(__rev2_898, __p3_898), __s0_898, __p1_898); \
- __ret_898; \
+#define vcopy_laneq_f64(__p0_934, __p1_934, __p2_934, __p3_934) __extension__ ({ \
+ float64x1_t __ret_934; \
+ float64x1_t __s0_934 = __p0_934; \
+ float64x2_t __s2_934 = __p2_934; \
+ float64x2_t __rev2_934; __rev2_934 = __builtin_shufflevector(__s2_934, __s2_934, 1, 0); \
+ __ret_934 = vset_lane_f64(__noswap_vgetq_lane_f64(__rev2_934, __p3_934), __s0_934, __p1_934); \
+ __ret_934; \
})
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vmlal_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+__ai __attribute__((target("neon"))) uint16x8_t vmlal_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint16x8_t __ret;
__ret = vmlal_u8(__p0, vget_high_u8(__p1), vget_high_u8(__p2));
return __ret;
}
#else
-__ai uint16x8_t vmlal_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+__ai __attribute__((target("neon"))) uint16x8_t vmlal_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68596,13 +69014,13 @@ __ai uint16x8_t vmlal_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2)
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vmlal_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vmlal_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint64x2_t __ret;
__ret = vmlal_u32(__p0, vget_high_u32(__p1), vget_high_u32(__p2));
return __ret;
}
#else
-__ai uint64x2_t vmlal_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vmlal_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -68614,13 +69032,13 @@ __ai uint64x2_t vmlal_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmlal_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlal_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
uint32x4_t __ret;
__ret = vmlal_u16(__p0, vget_high_u16(__p1), vget_high_u16(__p2));
return __ret;
}
#else
-__ai uint32x4_t vmlal_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlal_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68632,13 +69050,13 @@ __ai uint32x4_t vmlal_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vmlal_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
+__ai __attribute__((target("neon"))) int16x8_t vmlal_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
int16x8_t __ret;
__ret = vmlal_s8(__p0, vget_high_s8(__p1), vget_high_s8(__p2));
return __ret;
}
#else
-__ai int16x8_t vmlal_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
+__ai __attribute__((target("neon"))) int16x8_t vmlal_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68650,13 +69068,13 @@ __ai int16x8_t vmlal_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vmlal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmlal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
int64x2_t __ret;
__ret = vmlal_s32(__p0, vget_high_s32(__p1), vget_high_s32(__p2));
return __ret;
}
#else
-__ai int64x2_t vmlal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmlal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
int64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -68668,13 +69086,13 @@ __ai int64x2_t vmlal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmlal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmlal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
int32x4_t __ret;
__ret = vmlal_s16(__p0, vget_high_s16(__p1), vget_high_s16(__p2));
return __ret;
}
#else
-__ai int32x4_t vmlal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmlal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68686,13 +69104,13 @@ __ai int32x4_t vmlal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vmlal_high_n_u32(uint64x2_t __p0, uint32x4_t __p1, uint32_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vmlal_high_n_u32(uint64x2_t __p0, uint32x4_t __p1, uint32_t __p2) {
uint64x2_t __ret;
__ret = vmlal_n_u32(__p0, vget_high_u32(__p1), __p2);
return __ret;
}
#else
-__ai uint64x2_t vmlal_high_n_u32(uint64x2_t __p0, uint32x4_t __p1, uint32_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vmlal_high_n_u32(uint64x2_t __p0, uint32x4_t __p1, uint32_t __p2) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -68703,13 +69121,13 @@ __ai uint64x2_t vmlal_high_n_u32(uint64x2_t __p0, uint32x4_t __p1, uint32_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmlal_high_n_u16(uint32x4_t __p0, uint16x8_t __p1, uint16_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlal_high_n_u16(uint32x4_t __p0, uint16x8_t __p1, uint16_t __p2) {
uint32x4_t __ret;
__ret = vmlal_n_u16(__p0, vget_high_u16(__p1), __p2);
return __ret;
}
#else
-__ai uint32x4_t vmlal_high_n_u16(uint32x4_t __p0, uint16x8_t __p1, uint16_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlal_high_n_u16(uint32x4_t __p0, uint16x8_t __p1, uint16_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68720,13 +69138,13 @@ __ai uint32x4_t vmlal_high_n_u16(uint32x4_t __p0, uint16x8_t __p1, uint16_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vmlal_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmlal_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
int64x2_t __ret;
__ret = vmlal_n_s32(__p0, vget_high_s32(__p1), __p2);
return __ret;
}
#else
-__ai int64x2_t vmlal_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmlal_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
int64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -68737,13 +69155,13 @@ __ai int64x2_t vmlal_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmlal_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmlal_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
int32x4_t __ret;
__ret = vmlal_n_s16(__p0, vget_high_s16(__p1), __p2);
return __ret;
}
#else
-__ai int32x4_t vmlal_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmlal_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68754,13 +69172,13 @@ __ai int32x4_t vmlal_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vmlsl_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+__ai __attribute__((target("neon"))) uint16x8_t vmlsl_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint16x8_t __ret;
__ret = vmlsl_u8(__p0, vget_high_u8(__p1), vget_high_u8(__p2));
return __ret;
}
#else
-__ai uint16x8_t vmlsl_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+__ai __attribute__((target("neon"))) uint16x8_t vmlsl_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68772,13 +69190,13 @@ __ai uint16x8_t vmlsl_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2)
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vmlsl_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vmlsl_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint64x2_t __ret;
__ret = vmlsl_u32(__p0, vget_high_u32(__p1), vget_high_u32(__p2));
return __ret;
}
#else
-__ai uint64x2_t vmlsl_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vmlsl_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -68790,13 +69208,13 @@ __ai uint64x2_t vmlsl_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmlsl_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlsl_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
uint32x4_t __ret;
__ret = vmlsl_u16(__p0, vget_high_u16(__p1), vget_high_u16(__p2));
return __ret;
}
#else
-__ai uint32x4_t vmlsl_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlsl_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68808,13 +69226,13 @@ __ai uint32x4_t vmlsl_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vmlsl_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
+__ai __attribute__((target("neon"))) int16x8_t vmlsl_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
int16x8_t __ret;
__ret = vmlsl_s8(__p0, vget_high_s8(__p1), vget_high_s8(__p2));
return __ret;
}
#else
-__ai int16x8_t vmlsl_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
+__ai __attribute__((target("neon"))) int16x8_t vmlsl_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68826,13 +69244,13 @@ __ai int16x8_t vmlsl_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vmlsl_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmlsl_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
int64x2_t __ret;
__ret = vmlsl_s32(__p0, vget_high_s32(__p1), vget_high_s32(__p2));
return __ret;
}
#else
-__ai int64x2_t vmlsl_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmlsl_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
int64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -68844,13 +69262,13 @@ __ai int64x2_t vmlsl_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmlsl_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmlsl_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
int32x4_t __ret;
__ret = vmlsl_s16(__p0, vget_high_s16(__p1), vget_high_s16(__p2));
return __ret;
}
#else
-__ai int32x4_t vmlsl_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmlsl_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68862,13 +69280,13 @@ __ai int32x4_t vmlsl_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vmlsl_high_n_u32(uint64x2_t __p0, uint32x4_t __p1, uint32_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vmlsl_high_n_u32(uint64x2_t __p0, uint32x4_t __p1, uint32_t __p2) {
uint64x2_t __ret;
__ret = vmlsl_n_u32(__p0, vget_high_u32(__p1), __p2);
return __ret;
}
#else
-__ai uint64x2_t vmlsl_high_n_u32(uint64x2_t __p0, uint32x4_t __p1, uint32_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vmlsl_high_n_u32(uint64x2_t __p0, uint32x4_t __p1, uint32_t __p2) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -68879,13 +69297,13 @@ __ai uint64x2_t vmlsl_high_n_u32(uint64x2_t __p0, uint32x4_t __p1, uint32_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vmlsl_high_n_u16(uint32x4_t __p0, uint16x8_t __p1, uint16_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlsl_high_n_u16(uint32x4_t __p0, uint16x8_t __p1, uint16_t __p2) {
uint32x4_t __ret;
__ret = vmlsl_n_u16(__p0, vget_high_u16(__p1), __p2);
return __ret;
}
#else
-__ai uint32x4_t vmlsl_high_n_u16(uint32x4_t __p0, uint16x8_t __p1, uint16_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vmlsl_high_n_u16(uint32x4_t __p0, uint16x8_t __p1, uint16_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68896,13 +69314,13 @@ __ai uint32x4_t vmlsl_high_n_u16(uint32x4_t __p0, uint16x8_t __p1, uint16_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vmlsl_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmlsl_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
int64x2_t __ret;
__ret = vmlsl_n_s32(__p0, vget_high_s32(__p1), __p2);
return __ret;
}
#else
-__ai int64x2_t vmlsl_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vmlsl_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
int64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -68913,13 +69331,13 @@ __ai int64x2_t vmlsl_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vmlsl_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmlsl_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
int32x4_t __ret;
__ret = vmlsl_n_s16(__p0, vget_high_s16(__p1), __p2);
return __ret;
}
#else
-__ai int32x4_t vmlsl_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vmlsl_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -68929,472 +69347,50 @@ __ai int32x4_t vmlsl_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
}
#endif
-#define vmulx_lane_f64(__p0_899, __p1_899, __p2_899) __extension__ ({ \
- float64x1_t __ret_899; \
- float64x1_t __s0_899 = __p0_899; \
- float64x1_t __s1_899 = __p1_899; \
- float64_t __x_899 = vget_lane_f64(__s0_899, 0); \
- float64_t __y_899 = vget_lane_f64(__s1_899, __p2_899); \
- float64_t __z_899 = vmulxd_f64(__x_899, __y_899); \
- __ret_899 = vset_lane_f64(__z_899, __s0_899, __p2_899); \
- __ret_899; \
-})
-#ifdef __LITTLE_ENDIAN__
-#define vmulx_laneq_f64(__p0_900, __p1_900, __p2_900) __extension__ ({ \
- float64x1_t __ret_900; \
- float64x1_t __s0_900 = __p0_900; \
- float64x2_t __s1_900 = __p1_900; \
- float64_t __x_900 = vget_lane_f64(__s0_900, 0); \
- float64_t __y_900 = vgetq_lane_f64(__s1_900, __p2_900); \
- float64_t __z_900 = vmulxd_f64(__x_900, __y_900); \
- __ret_900 = vset_lane_f64(__z_900, __s0_900, 0); \
- __ret_900; \
-})
-#else
-#define vmulx_laneq_f64(__p0_901, __p1_901, __p2_901) __extension__ ({ \
- float64x1_t __ret_901; \
- float64x1_t __s0_901 = __p0_901; \
- float64x2_t __s1_901 = __p1_901; \
- float64x2_t __rev1_901; __rev1_901 = __builtin_shufflevector(__s1_901, __s1_901, 1, 0); \
- float64_t __x_901 = vget_lane_f64(__s0_901, 0); \
- float64_t __y_901 = __noswap_vgetq_lane_f64(__rev1_901, __p2_901); \
- float64_t __z_901 = vmulxd_f64(__x_901, __y_901); \
- __ret_901 = vset_lane_f64(__z_901, __s0_901, 0); \
- __ret_901; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vfmlalq_lane_high_f16(__p0_902, __p1_902, __p2_902, __p3_902) __extension__ ({ \
- float32x4_t __ret_902; \
- float32x4_t __s0_902 = __p0_902; \
- float16x8_t __s1_902 = __p1_902; \
- float16x4_t __s2_902 = __p2_902; \
- __ret_902 = vfmlalq_high_f16(__s0_902, __s1_902, (float16x8_t) {vget_lane_f16(__s2_902, __p3_902), vget_lane_f16(__s2_902, __p3_902), vget_lane_f16(__s2_902, __p3_902), vget_lane_f16(__s2_902, __p3_902), vget_lane_f16(__s2_902, __p3_902), vget_lane_f16(__s2_902, __p3_902), vget_lane_f16(__s2_902, __p3_902), vget_lane_f16(__s2_902, __p3_902)}); \
- __ret_902; \
-})
-#else
-#define vfmlalq_lane_high_f16(__p0_903, __p1_903, __p2_903, __p3_903) __extension__ ({ \
- float32x4_t __ret_903; \
- float32x4_t __s0_903 = __p0_903; \
- float16x8_t __s1_903 = __p1_903; \
- float16x4_t __s2_903 = __p2_903; \
- float32x4_t __rev0_903; __rev0_903 = __builtin_shufflevector(__s0_903, __s0_903, 3, 2, 1, 0); \
- float16x8_t __rev1_903; __rev1_903 = __builtin_shufflevector(__s1_903, __s1_903, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x4_t __rev2_903; __rev2_903 = __builtin_shufflevector(__s2_903, __s2_903, 3, 2, 1, 0); \
- __ret_903 = __noswap_vfmlalq_high_f16(__rev0_903, __rev1_903, (float16x8_t) {__noswap_vget_lane_f16(__rev2_903, __p3_903), __noswap_vget_lane_f16(__rev2_903, __p3_903), __noswap_vget_lane_f16(__rev2_903, __p3_903), __noswap_vget_lane_f16(__rev2_903, __p3_903), __noswap_vget_lane_f16(__rev2_903, __p3_903), __noswap_vget_lane_f16(__rev2_903, __p3_903), __noswap_vget_lane_f16(__rev2_903, __p3_903), __noswap_vget_lane_f16(__rev2_903, __p3_903)}); \
- __ret_903 = __builtin_shufflevector(__ret_903, __ret_903, 3, 2, 1, 0); \
- __ret_903; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vfmlal_lane_high_f16(__p0_904, __p1_904, __p2_904, __p3_904) __extension__ ({ \
- float32x2_t __ret_904; \
- float32x2_t __s0_904 = __p0_904; \
- float16x4_t __s1_904 = __p1_904; \
- float16x4_t __s2_904 = __p2_904; \
- __ret_904 = vfmlal_high_f16(__s0_904, __s1_904, (float16x4_t) {vget_lane_f16(__s2_904, __p3_904), vget_lane_f16(__s2_904, __p3_904), vget_lane_f16(__s2_904, __p3_904), vget_lane_f16(__s2_904, __p3_904)}); \
- __ret_904; \
-})
-#else
-#define vfmlal_lane_high_f16(__p0_905, __p1_905, __p2_905, __p3_905) __extension__ ({ \
- float32x2_t __ret_905; \
- float32x2_t __s0_905 = __p0_905; \
- float16x4_t __s1_905 = __p1_905; \
- float16x4_t __s2_905 = __p2_905; \
- float32x2_t __rev0_905; __rev0_905 = __builtin_shufflevector(__s0_905, __s0_905, 1, 0); \
- float16x4_t __rev1_905; __rev1_905 = __builtin_shufflevector(__s1_905, __s1_905, 3, 2, 1, 0); \
- float16x4_t __rev2_905; __rev2_905 = __builtin_shufflevector(__s2_905, __s2_905, 3, 2, 1, 0); \
- __ret_905 = __noswap_vfmlal_high_f16(__rev0_905, __rev1_905, (float16x4_t) {__noswap_vget_lane_f16(__rev2_905, __p3_905), __noswap_vget_lane_f16(__rev2_905, __p3_905), __noswap_vget_lane_f16(__rev2_905, __p3_905), __noswap_vget_lane_f16(__rev2_905, __p3_905)}); \
- __ret_905 = __builtin_shufflevector(__ret_905, __ret_905, 1, 0); \
- __ret_905; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vfmlalq_lane_low_f16(__p0_906, __p1_906, __p2_906, __p3_906) __extension__ ({ \
- float32x4_t __ret_906; \
- float32x4_t __s0_906 = __p0_906; \
- float16x8_t __s1_906 = __p1_906; \
- float16x4_t __s2_906 = __p2_906; \
- __ret_906 = vfmlalq_low_f16(__s0_906, __s1_906, (float16x8_t) {vget_lane_f16(__s2_906, __p3_906), vget_lane_f16(__s2_906, __p3_906), vget_lane_f16(__s2_906, __p3_906), vget_lane_f16(__s2_906, __p3_906), vget_lane_f16(__s2_906, __p3_906), vget_lane_f16(__s2_906, __p3_906), vget_lane_f16(__s2_906, __p3_906), vget_lane_f16(__s2_906, __p3_906)}); \
- __ret_906; \
-})
-#else
-#define vfmlalq_lane_low_f16(__p0_907, __p1_907, __p2_907, __p3_907) __extension__ ({ \
- float32x4_t __ret_907; \
- float32x4_t __s0_907 = __p0_907; \
- float16x8_t __s1_907 = __p1_907; \
- float16x4_t __s2_907 = __p2_907; \
- float32x4_t __rev0_907; __rev0_907 = __builtin_shufflevector(__s0_907, __s0_907, 3, 2, 1, 0); \
- float16x8_t __rev1_907; __rev1_907 = __builtin_shufflevector(__s1_907, __s1_907, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x4_t __rev2_907; __rev2_907 = __builtin_shufflevector(__s2_907, __s2_907, 3, 2, 1, 0); \
- __ret_907 = __noswap_vfmlalq_low_f16(__rev0_907, __rev1_907, (float16x8_t) {__noswap_vget_lane_f16(__rev2_907, __p3_907), __noswap_vget_lane_f16(__rev2_907, __p3_907), __noswap_vget_lane_f16(__rev2_907, __p3_907), __noswap_vget_lane_f16(__rev2_907, __p3_907), __noswap_vget_lane_f16(__rev2_907, __p3_907), __noswap_vget_lane_f16(__rev2_907, __p3_907), __noswap_vget_lane_f16(__rev2_907, __p3_907), __noswap_vget_lane_f16(__rev2_907, __p3_907)}); \
- __ret_907 = __builtin_shufflevector(__ret_907, __ret_907, 3, 2, 1, 0); \
- __ret_907; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vfmlal_lane_low_f16(__p0_908, __p1_908, __p2_908, __p3_908) __extension__ ({ \
- float32x2_t __ret_908; \
- float32x2_t __s0_908 = __p0_908; \
- float16x4_t __s1_908 = __p1_908; \
- float16x4_t __s2_908 = __p2_908; \
- __ret_908 = vfmlal_low_f16(__s0_908, __s1_908, (float16x4_t) {vget_lane_f16(__s2_908, __p3_908), vget_lane_f16(__s2_908, __p3_908), vget_lane_f16(__s2_908, __p3_908), vget_lane_f16(__s2_908, __p3_908)}); \
- __ret_908; \
-})
-#else
-#define vfmlal_lane_low_f16(__p0_909, __p1_909, __p2_909, __p3_909) __extension__ ({ \
- float32x2_t __ret_909; \
- float32x2_t __s0_909 = __p0_909; \
- float16x4_t __s1_909 = __p1_909; \
- float16x4_t __s2_909 = __p2_909; \
- float32x2_t __rev0_909; __rev0_909 = __builtin_shufflevector(__s0_909, __s0_909, 1, 0); \
- float16x4_t __rev1_909; __rev1_909 = __builtin_shufflevector(__s1_909, __s1_909, 3, 2, 1, 0); \
- float16x4_t __rev2_909; __rev2_909 = __builtin_shufflevector(__s2_909, __s2_909, 3, 2, 1, 0); \
- __ret_909 = __noswap_vfmlal_low_f16(__rev0_909, __rev1_909, (float16x4_t) {__noswap_vget_lane_f16(__rev2_909, __p3_909), __noswap_vget_lane_f16(__rev2_909, __p3_909), __noswap_vget_lane_f16(__rev2_909, __p3_909), __noswap_vget_lane_f16(__rev2_909, __p3_909)}); \
- __ret_909 = __builtin_shufflevector(__ret_909, __ret_909, 1, 0); \
- __ret_909; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vfmlalq_laneq_high_f16(__p0_910, __p1_910, __p2_910, __p3_910) __extension__ ({ \
- float32x4_t __ret_910; \
- float32x4_t __s0_910 = __p0_910; \
- float16x8_t __s1_910 = __p1_910; \
- float16x8_t __s2_910 = __p2_910; \
- __ret_910 = vfmlalq_high_f16(__s0_910, __s1_910, (float16x8_t) {vgetq_lane_f16(__s2_910, __p3_910), vgetq_lane_f16(__s2_910, __p3_910), vgetq_lane_f16(__s2_910, __p3_910), vgetq_lane_f16(__s2_910, __p3_910), vgetq_lane_f16(__s2_910, __p3_910), vgetq_lane_f16(__s2_910, __p3_910), vgetq_lane_f16(__s2_910, __p3_910), vgetq_lane_f16(__s2_910, __p3_910)}); \
- __ret_910; \
-})
-#else
-#define vfmlalq_laneq_high_f16(__p0_911, __p1_911, __p2_911, __p3_911) __extension__ ({ \
- float32x4_t __ret_911; \
- float32x4_t __s0_911 = __p0_911; \
- float16x8_t __s1_911 = __p1_911; \
- float16x8_t __s2_911 = __p2_911; \
- float32x4_t __rev0_911; __rev0_911 = __builtin_shufflevector(__s0_911, __s0_911, 3, 2, 1, 0); \
- float16x8_t __rev1_911; __rev1_911 = __builtin_shufflevector(__s1_911, __s1_911, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev2_911; __rev2_911 = __builtin_shufflevector(__s2_911, __s2_911, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_911 = __noswap_vfmlalq_high_f16(__rev0_911, __rev1_911, (float16x8_t) {__noswap_vgetq_lane_f16(__rev2_911, __p3_911), __noswap_vgetq_lane_f16(__rev2_911, __p3_911), __noswap_vgetq_lane_f16(__rev2_911, __p3_911), __noswap_vgetq_lane_f16(__rev2_911, __p3_911), __noswap_vgetq_lane_f16(__rev2_911, __p3_911), __noswap_vgetq_lane_f16(__rev2_911, __p3_911), __noswap_vgetq_lane_f16(__rev2_911, __p3_911), __noswap_vgetq_lane_f16(__rev2_911, __p3_911)}); \
- __ret_911 = __builtin_shufflevector(__ret_911, __ret_911, 3, 2, 1, 0); \
- __ret_911; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vfmlal_laneq_high_f16(__p0_912, __p1_912, __p2_912, __p3_912) __extension__ ({ \
- float32x2_t __ret_912; \
- float32x2_t __s0_912 = __p0_912; \
- float16x4_t __s1_912 = __p1_912; \
- float16x8_t __s2_912 = __p2_912; \
- __ret_912 = vfmlal_high_f16(__s0_912, __s1_912, (float16x4_t) {vgetq_lane_f16(__s2_912, __p3_912), vgetq_lane_f16(__s2_912, __p3_912), vgetq_lane_f16(__s2_912, __p3_912), vgetq_lane_f16(__s2_912, __p3_912)}); \
- __ret_912; \
-})
-#else
-#define vfmlal_laneq_high_f16(__p0_913, __p1_913, __p2_913, __p3_913) __extension__ ({ \
- float32x2_t __ret_913; \
- float32x2_t __s0_913 = __p0_913; \
- float16x4_t __s1_913 = __p1_913; \
- float16x8_t __s2_913 = __p2_913; \
- float32x2_t __rev0_913; __rev0_913 = __builtin_shufflevector(__s0_913, __s0_913, 1, 0); \
- float16x4_t __rev1_913; __rev1_913 = __builtin_shufflevector(__s1_913, __s1_913, 3, 2, 1, 0); \
- float16x8_t __rev2_913; __rev2_913 = __builtin_shufflevector(__s2_913, __s2_913, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_913 = __noswap_vfmlal_high_f16(__rev0_913, __rev1_913, (float16x4_t) {__noswap_vgetq_lane_f16(__rev2_913, __p3_913), __noswap_vgetq_lane_f16(__rev2_913, __p3_913), __noswap_vgetq_lane_f16(__rev2_913, __p3_913), __noswap_vgetq_lane_f16(__rev2_913, __p3_913)}); \
- __ret_913 = __builtin_shufflevector(__ret_913, __ret_913, 1, 0); \
- __ret_913; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vfmlalq_laneq_low_f16(__p0_914, __p1_914, __p2_914, __p3_914) __extension__ ({ \
- float32x4_t __ret_914; \
- float32x4_t __s0_914 = __p0_914; \
- float16x8_t __s1_914 = __p1_914; \
- float16x8_t __s2_914 = __p2_914; \
- __ret_914 = vfmlalq_low_f16(__s0_914, __s1_914, (float16x8_t) {vgetq_lane_f16(__s2_914, __p3_914), vgetq_lane_f16(__s2_914, __p3_914), vgetq_lane_f16(__s2_914, __p3_914), vgetq_lane_f16(__s2_914, __p3_914), vgetq_lane_f16(__s2_914, __p3_914), vgetq_lane_f16(__s2_914, __p3_914), vgetq_lane_f16(__s2_914, __p3_914), vgetq_lane_f16(__s2_914, __p3_914)}); \
- __ret_914; \
-})
-#else
-#define vfmlalq_laneq_low_f16(__p0_915, __p1_915, __p2_915, __p3_915) __extension__ ({ \
- float32x4_t __ret_915; \
- float32x4_t __s0_915 = __p0_915; \
- float16x8_t __s1_915 = __p1_915; \
- float16x8_t __s2_915 = __p2_915; \
- float32x4_t __rev0_915; __rev0_915 = __builtin_shufflevector(__s0_915, __s0_915, 3, 2, 1, 0); \
- float16x8_t __rev1_915; __rev1_915 = __builtin_shufflevector(__s1_915, __s1_915, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev2_915; __rev2_915 = __builtin_shufflevector(__s2_915, __s2_915, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_915 = __noswap_vfmlalq_low_f16(__rev0_915, __rev1_915, (float16x8_t) {__noswap_vgetq_lane_f16(__rev2_915, __p3_915), __noswap_vgetq_lane_f16(__rev2_915, __p3_915), __noswap_vgetq_lane_f16(__rev2_915, __p3_915), __noswap_vgetq_lane_f16(__rev2_915, __p3_915), __noswap_vgetq_lane_f16(__rev2_915, __p3_915), __noswap_vgetq_lane_f16(__rev2_915, __p3_915), __noswap_vgetq_lane_f16(__rev2_915, __p3_915), __noswap_vgetq_lane_f16(__rev2_915, __p3_915)}); \
- __ret_915 = __builtin_shufflevector(__ret_915, __ret_915, 3, 2, 1, 0); \
- __ret_915; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vfmlal_laneq_low_f16(__p0_916, __p1_916, __p2_916, __p3_916) __extension__ ({ \
- float32x2_t __ret_916; \
- float32x2_t __s0_916 = __p0_916; \
- float16x4_t __s1_916 = __p1_916; \
- float16x8_t __s2_916 = __p2_916; \
- __ret_916 = vfmlal_low_f16(__s0_916, __s1_916, (float16x4_t) {vgetq_lane_f16(__s2_916, __p3_916), vgetq_lane_f16(__s2_916, __p3_916), vgetq_lane_f16(__s2_916, __p3_916), vgetq_lane_f16(__s2_916, __p3_916)}); \
- __ret_916; \
-})
-#else
-#define vfmlal_laneq_low_f16(__p0_917, __p1_917, __p2_917, __p3_917) __extension__ ({ \
- float32x2_t __ret_917; \
- float32x2_t __s0_917 = __p0_917; \
- float16x4_t __s1_917 = __p1_917; \
- float16x8_t __s2_917 = __p2_917; \
- float32x2_t __rev0_917; __rev0_917 = __builtin_shufflevector(__s0_917, __s0_917, 1, 0); \
- float16x4_t __rev1_917; __rev1_917 = __builtin_shufflevector(__s1_917, __s1_917, 3, 2, 1, 0); \
- float16x8_t __rev2_917; __rev2_917 = __builtin_shufflevector(__s2_917, __s2_917, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_917 = __noswap_vfmlal_low_f16(__rev0_917, __rev1_917, (float16x4_t) {__noswap_vgetq_lane_f16(__rev2_917, __p3_917), __noswap_vgetq_lane_f16(__rev2_917, __p3_917), __noswap_vgetq_lane_f16(__rev2_917, __p3_917), __noswap_vgetq_lane_f16(__rev2_917, __p3_917)}); \
- __ret_917 = __builtin_shufflevector(__ret_917, __ret_917, 1, 0); \
- __ret_917; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vfmlslq_lane_high_f16(__p0_918, __p1_918, __p2_918, __p3_918) __extension__ ({ \
- float32x4_t __ret_918; \
- float32x4_t __s0_918 = __p0_918; \
- float16x8_t __s1_918 = __p1_918; \
- float16x4_t __s2_918 = __p2_918; \
- __ret_918 = vfmlslq_high_f16(__s0_918, __s1_918, (float16x8_t) {vget_lane_f16(__s2_918, __p3_918), vget_lane_f16(__s2_918, __p3_918), vget_lane_f16(__s2_918, __p3_918), vget_lane_f16(__s2_918, __p3_918), vget_lane_f16(__s2_918, __p3_918), vget_lane_f16(__s2_918, __p3_918), vget_lane_f16(__s2_918, __p3_918), vget_lane_f16(__s2_918, __p3_918)}); \
- __ret_918; \
-})
-#else
-#define vfmlslq_lane_high_f16(__p0_919, __p1_919, __p2_919, __p3_919) __extension__ ({ \
- float32x4_t __ret_919; \
- float32x4_t __s0_919 = __p0_919; \
- float16x8_t __s1_919 = __p1_919; \
- float16x4_t __s2_919 = __p2_919; \
- float32x4_t __rev0_919; __rev0_919 = __builtin_shufflevector(__s0_919, __s0_919, 3, 2, 1, 0); \
- float16x8_t __rev1_919; __rev1_919 = __builtin_shufflevector(__s1_919, __s1_919, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x4_t __rev2_919; __rev2_919 = __builtin_shufflevector(__s2_919, __s2_919, 3, 2, 1, 0); \
- __ret_919 = __noswap_vfmlslq_high_f16(__rev0_919, __rev1_919, (float16x8_t) {__noswap_vget_lane_f16(__rev2_919, __p3_919), __noswap_vget_lane_f16(__rev2_919, __p3_919), __noswap_vget_lane_f16(__rev2_919, __p3_919), __noswap_vget_lane_f16(__rev2_919, __p3_919), __noswap_vget_lane_f16(__rev2_919, __p3_919), __noswap_vget_lane_f16(__rev2_919, __p3_919), __noswap_vget_lane_f16(__rev2_919, __p3_919), __noswap_vget_lane_f16(__rev2_919, __p3_919)}); \
- __ret_919 = __builtin_shufflevector(__ret_919, __ret_919, 3, 2, 1, 0); \
- __ret_919; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vfmlsl_lane_high_f16(__p0_920, __p1_920, __p2_920, __p3_920) __extension__ ({ \
- float32x2_t __ret_920; \
- float32x2_t __s0_920 = __p0_920; \
- float16x4_t __s1_920 = __p1_920; \
- float16x4_t __s2_920 = __p2_920; \
- __ret_920 = vfmlsl_high_f16(__s0_920, __s1_920, (float16x4_t) {vget_lane_f16(__s2_920, __p3_920), vget_lane_f16(__s2_920, __p3_920), vget_lane_f16(__s2_920, __p3_920), vget_lane_f16(__s2_920, __p3_920)}); \
- __ret_920; \
-})
-#else
-#define vfmlsl_lane_high_f16(__p0_921, __p1_921, __p2_921, __p3_921) __extension__ ({ \
- float32x2_t __ret_921; \
- float32x2_t __s0_921 = __p0_921; \
- float16x4_t __s1_921 = __p1_921; \
- float16x4_t __s2_921 = __p2_921; \
- float32x2_t __rev0_921; __rev0_921 = __builtin_shufflevector(__s0_921, __s0_921, 1, 0); \
- float16x4_t __rev1_921; __rev1_921 = __builtin_shufflevector(__s1_921, __s1_921, 3, 2, 1, 0); \
- float16x4_t __rev2_921; __rev2_921 = __builtin_shufflevector(__s2_921, __s2_921, 3, 2, 1, 0); \
- __ret_921 = __noswap_vfmlsl_high_f16(__rev0_921, __rev1_921, (float16x4_t) {__noswap_vget_lane_f16(__rev2_921, __p3_921), __noswap_vget_lane_f16(__rev2_921, __p3_921), __noswap_vget_lane_f16(__rev2_921, __p3_921), __noswap_vget_lane_f16(__rev2_921, __p3_921)}); \
- __ret_921 = __builtin_shufflevector(__ret_921, __ret_921, 1, 0); \
- __ret_921; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vfmlslq_lane_low_f16(__p0_922, __p1_922, __p2_922, __p3_922) __extension__ ({ \
- float32x4_t __ret_922; \
- float32x4_t __s0_922 = __p0_922; \
- float16x8_t __s1_922 = __p1_922; \
- float16x4_t __s2_922 = __p2_922; \
- __ret_922 = vfmlslq_low_f16(__s0_922, __s1_922, (float16x8_t) {vget_lane_f16(__s2_922, __p3_922), vget_lane_f16(__s2_922, __p3_922), vget_lane_f16(__s2_922, __p3_922), vget_lane_f16(__s2_922, __p3_922), vget_lane_f16(__s2_922, __p3_922), vget_lane_f16(__s2_922, __p3_922), vget_lane_f16(__s2_922, __p3_922), vget_lane_f16(__s2_922, __p3_922)}); \
- __ret_922; \
-})
-#else
-#define vfmlslq_lane_low_f16(__p0_923, __p1_923, __p2_923, __p3_923) __extension__ ({ \
- float32x4_t __ret_923; \
- float32x4_t __s0_923 = __p0_923; \
- float16x8_t __s1_923 = __p1_923; \
- float16x4_t __s2_923 = __p2_923; \
- float32x4_t __rev0_923; __rev0_923 = __builtin_shufflevector(__s0_923, __s0_923, 3, 2, 1, 0); \
- float16x8_t __rev1_923; __rev1_923 = __builtin_shufflevector(__s1_923, __s1_923, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x4_t __rev2_923; __rev2_923 = __builtin_shufflevector(__s2_923, __s2_923, 3, 2, 1, 0); \
- __ret_923 = __noswap_vfmlslq_low_f16(__rev0_923, __rev1_923, (float16x8_t) {__noswap_vget_lane_f16(__rev2_923, __p3_923), __noswap_vget_lane_f16(__rev2_923, __p3_923), __noswap_vget_lane_f16(__rev2_923, __p3_923), __noswap_vget_lane_f16(__rev2_923, __p3_923), __noswap_vget_lane_f16(__rev2_923, __p3_923), __noswap_vget_lane_f16(__rev2_923, __p3_923), __noswap_vget_lane_f16(__rev2_923, __p3_923), __noswap_vget_lane_f16(__rev2_923, __p3_923)}); \
- __ret_923 = __builtin_shufflevector(__ret_923, __ret_923, 3, 2, 1, 0); \
- __ret_923; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vfmlsl_lane_low_f16(__p0_924, __p1_924, __p2_924, __p3_924) __extension__ ({ \
- float32x2_t __ret_924; \
- float32x2_t __s0_924 = __p0_924; \
- float16x4_t __s1_924 = __p1_924; \
- float16x4_t __s2_924 = __p2_924; \
- __ret_924 = vfmlsl_low_f16(__s0_924, __s1_924, (float16x4_t) {vget_lane_f16(__s2_924, __p3_924), vget_lane_f16(__s2_924, __p3_924), vget_lane_f16(__s2_924, __p3_924), vget_lane_f16(__s2_924, __p3_924)}); \
- __ret_924; \
-})
-#else
-#define vfmlsl_lane_low_f16(__p0_925, __p1_925, __p2_925, __p3_925) __extension__ ({ \
- float32x2_t __ret_925; \
- float32x2_t __s0_925 = __p0_925; \
- float16x4_t __s1_925 = __p1_925; \
- float16x4_t __s2_925 = __p2_925; \
- float32x2_t __rev0_925; __rev0_925 = __builtin_shufflevector(__s0_925, __s0_925, 1, 0); \
- float16x4_t __rev1_925; __rev1_925 = __builtin_shufflevector(__s1_925, __s1_925, 3, 2, 1, 0); \
- float16x4_t __rev2_925; __rev2_925 = __builtin_shufflevector(__s2_925, __s2_925, 3, 2, 1, 0); \
- __ret_925 = __noswap_vfmlsl_low_f16(__rev0_925, __rev1_925, (float16x4_t) {__noswap_vget_lane_f16(__rev2_925, __p3_925), __noswap_vget_lane_f16(__rev2_925, __p3_925), __noswap_vget_lane_f16(__rev2_925, __p3_925), __noswap_vget_lane_f16(__rev2_925, __p3_925)}); \
- __ret_925 = __builtin_shufflevector(__ret_925, __ret_925, 1, 0); \
- __ret_925; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vfmlslq_laneq_high_f16(__p0_926, __p1_926, __p2_926, __p3_926) __extension__ ({ \
- float32x4_t __ret_926; \
- float32x4_t __s0_926 = __p0_926; \
- float16x8_t __s1_926 = __p1_926; \
- float16x8_t __s2_926 = __p2_926; \
- __ret_926 = vfmlslq_high_f16(__s0_926, __s1_926, (float16x8_t) {vgetq_lane_f16(__s2_926, __p3_926), vgetq_lane_f16(__s2_926, __p3_926), vgetq_lane_f16(__s2_926, __p3_926), vgetq_lane_f16(__s2_926, __p3_926), vgetq_lane_f16(__s2_926, __p3_926), vgetq_lane_f16(__s2_926, __p3_926), vgetq_lane_f16(__s2_926, __p3_926), vgetq_lane_f16(__s2_926, __p3_926)}); \
- __ret_926; \
-})
-#else
-#define vfmlslq_laneq_high_f16(__p0_927, __p1_927, __p2_927, __p3_927) __extension__ ({ \
- float32x4_t __ret_927; \
- float32x4_t __s0_927 = __p0_927; \
- float16x8_t __s1_927 = __p1_927; \
- float16x8_t __s2_927 = __p2_927; \
- float32x4_t __rev0_927; __rev0_927 = __builtin_shufflevector(__s0_927, __s0_927, 3, 2, 1, 0); \
- float16x8_t __rev1_927; __rev1_927 = __builtin_shufflevector(__s1_927, __s1_927, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev2_927; __rev2_927 = __builtin_shufflevector(__s2_927, __s2_927, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_927 = __noswap_vfmlslq_high_f16(__rev0_927, __rev1_927, (float16x8_t) {__noswap_vgetq_lane_f16(__rev2_927, __p3_927), __noswap_vgetq_lane_f16(__rev2_927, __p3_927), __noswap_vgetq_lane_f16(__rev2_927, __p3_927), __noswap_vgetq_lane_f16(__rev2_927, __p3_927), __noswap_vgetq_lane_f16(__rev2_927, __p3_927), __noswap_vgetq_lane_f16(__rev2_927, __p3_927), __noswap_vgetq_lane_f16(__rev2_927, __p3_927), __noswap_vgetq_lane_f16(__rev2_927, __p3_927)}); \
- __ret_927 = __builtin_shufflevector(__ret_927, __ret_927, 3, 2, 1, 0); \
- __ret_927; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vfmlsl_laneq_high_f16(__p0_928, __p1_928, __p2_928, __p3_928) __extension__ ({ \
- float32x2_t __ret_928; \
- float32x2_t __s0_928 = __p0_928; \
- float16x4_t __s1_928 = __p1_928; \
- float16x8_t __s2_928 = __p2_928; \
- __ret_928 = vfmlsl_high_f16(__s0_928, __s1_928, (float16x4_t) {vgetq_lane_f16(__s2_928, __p3_928), vgetq_lane_f16(__s2_928, __p3_928), vgetq_lane_f16(__s2_928, __p3_928), vgetq_lane_f16(__s2_928, __p3_928)}); \
- __ret_928; \
-})
-#else
-#define vfmlsl_laneq_high_f16(__p0_929, __p1_929, __p2_929, __p3_929) __extension__ ({ \
- float32x2_t __ret_929; \
- float32x2_t __s0_929 = __p0_929; \
- float16x4_t __s1_929 = __p1_929; \
- float16x8_t __s2_929 = __p2_929; \
- float32x2_t __rev0_929; __rev0_929 = __builtin_shufflevector(__s0_929, __s0_929, 1, 0); \
- float16x4_t __rev1_929; __rev1_929 = __builtin_shufflevector(__s1_929, __s1_929, 3, 2, 1, 0); \
- float16x8_t __rev2_929; __rev2_929 = __builtin_shufflevector(__s2_929, __s2_929, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_929 = __noswap_vfmlsl_high_f16(__rev0_929, __rev1_929, (float16x4_t) {__noswap_vgetq_lane_f16(__rev2_929, __p3_929), __noswap_vgetq_lane_f16(__rev2_929, __p3_929), __noswap_vgetq_lane_f16(__rev2_929, __p3_929), __noswap_vgetq_lane_f16(__rev2_929, __p3_929)}); \
- __ret_929 = __builtin_shufflevector(__ret_929, __ret_929, 1, 0); \
- __ret_929; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vfmlslq_laneq_low_f16(__p0_930, __p1_930, __p2_930, __p3_930) __extension__ ({ \
- float32x4_t __ret_930; \
- float32x4_t __s0_930 = __p0_930; \
- float16x8_t __s1_930 = __p1_930; \
- float16x8_t __s2_930 = __p2_930; \
- __ret_930 = vfmlslq_low_f16(__s0_930, __s1_930, (float16x8_t) {vgetq_lane_f16(__s2_930, __p3_930), vgetq_lane_f16(__s2_930, __p3_930), vgetq_lane_f16(__s2_930, __p3_930), vgetq_lane_f16(__s2_930, __p3_930), vgetq_lane_f16(__s2_930, __p3_930), vgetq_lane_f16(__s2_930, __p3_930), vgetq_lane_f16(__s2_930, __p3_930), vgetq_lane_f16(__s2_930, __p3_930)}); \
- __ret_930; \
-})
-#else
-#define vfmlslq_laneq_low_f16(__p0_931, __p1_931, __p2_931, __p3_931) __extension__ ({ \
- float32x4_t __ret_931; \
- float32x4_t __s0_931 = __p0_931; \
- float16x8_t __s1_931 = __p1_931; \
- float16x8_t __s2_931 = __p2_931; \
- float32x4_t __rev0_931; __rev0_931 = __builtin_shufflevector(__s0_931, __s0_931, 3, 2, 1, 0); \
- float16x8_t __rev1_931; __rev1_931 = __builtin_shufflevector(__s1_931, __s1_931, 7, 6, 5, 4, 3, 2, 1, 0); \
- float16x8_t __rev2_931; __rev2_931 = __builtin_shufflevector(__s2_931, __s2_931, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_931 = __noswap_vfmlslq_low_f16(__rev0_931, __rev1_931, (float16x8_t) {__noswap_vgetq_lane_f16(__rev2_931, __p3_931), __noswap_vgetq_lane_f16(__rev2_931, __p3_931), __noswap_vgetq_lane_f16(__rev2_931, __p3_931), __noswap_vgetq_lane_f16(__rev2_931, __p3_931), __noswap_vgetq_lane_f16(__rev2_931, __p3_931), __noswap_vgetq_lane_f16(__rev2_931, __p3_931), __noswap_vgetq_lane_f16(__rev2_931, __p3_931), __noswap_vgetq_lane_f16(__rev2_931, __p3_931)}); \
- __ret_931 = __builtin_shufflevector(__ret_931, __ret_931, 3, 2, 1, 0); \
- __ret_931; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vfmlsl_laneq_low_f16(__p0_932, __p1_932, __p2_932, __p3_932) __extension__ ({ \
- float32x2_t __ret_932; \
- float32x2_t __s0_932 = __p0_932; \
- float16x4_t __s1_932 = __p1_932; \
- float16x8_t __s2_932 = __p2_932; \
- __ret_932 = vfmlsl_low_f16(__s0_932, __s1_932, (float16x4_t) {vgetq_lane_f16(__s2_932, __p3_932), vgetq_lane_f16(__s2_932, __p3_932), vgetq_lane_f16(__s2_932, __p3_932), vgetq_lane_f16(__s2_932, __p3_932)}); \
- __ret_932; \
-})
-#else
-#define vfmlsl_laneq_low_f16(__p0_933, __p1_933, __p2_933, __p3_933) __extension__ ({ \
- float32x2_t __ret_933; \
- float32x2_t __s0_933 = __p0_933; \
- float16x4_t __s1_933 = __p1_933; \
- float16x8_t __s2_933 = __p2_933; \
- float32x2_t __rev0_933; __rev0_933 = __builtin_shufflevector(__s0_933, __s0_933, 1, 0); \
- float16x4_t __rev1_933; __rev1_933 = __builtin_shufflevector(__s1_933, __s1_933, 3, 2, 1, 0); \
- float16x8_t __rev2_933; __rev2_933 = __builtin_shufflevector(__s2_933, __s2_933, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_933 = __noswap_vfmlsl_low_f16(__rev0_933, __rev1_933, (float16x4_t) {__noswap_vgetq_lane_f16(__rev2_933, __p3_933), __noswap_vgetq_lane_f16(__rev2_933, __p3_933), __noswap_vgetq_lane_f16(__rev2_933, __p3_933), __noswap_vgetq_lane_f16(__rev2_933, __p3_933)}); \
- __ret_933 = __builtin_shufflevector(__ret_933, __ret_933, 1, 0); \
- __ret_933; \
-})
-#endif
-
-#ifdef __LITTLE_ENDIAN__
-#define vmulh_lane_f16(__p0_934, __p1_934, __p2_934) __extension__ ({ \
- float16_t __ret_934; \
- float16_t __s0_934 = __p0_934; \
- float16x4_t __s1_934 = __p1_934; \
- __ret_934 = __s0_934 * vget_lane_f16(__s1_934, __p2_934); \
- __ret_934; \
-})
-#else
-#define vmulh_lane_f16(__p0_935, __p1_935, __p2_935) __extension__ ({ \
- float16_t __ret_935; \
- float16_t __s0_935 = __p0_935; \
- float16x4_t __s1_935 = __p1_935; \
- float16x4_t __rev1_935; __rev1_935 = __builtin_shufflevector(__s1_935, __s1_935, 3, 2, 1, 0); \
- __ret_935 = __s0_935 * __noswap_vget_lane_f16(__rev1_935, __p2_935); \
+#define vmulx_lane_f64(__p0_935, __p1_935, __p2_935) __extension__ ({ \
+ float64x1_t __ret_935; \
+ float64x1_t __s0_935 = __p0_935; \
+ float64x1_t __s1_935 = __p1_935; \
+ float64_t __x_935 = vget_lane_f64(__s0_935, 0); \
+ float64_t __y_935 = vget_lane_f64(__s1_935, __p2_935); \
+ float64_t __z_935 = vmulxd_f64(__x_935, __y_935); \
+ __ret_935 = vset_lane_f64(__z_935, __s0_935, __p2_935); \
__ret_935; \
})
-#endif
-
#ifdef __LITTLE_ENDIAN__
-#define vmulh_laneq_f16(__p0_936, __p1_936, __p2_936) __extension__ ({ \
- float16_t __ret_936; \
- float16_t __s0_936 = __p0_936; \
- float16x8_t __s1_936 = __p1_936; \
- __ret_936 = __s0_936 * vgetq_lane_f16(__s1_936, __p2_936); \
+#define vmulx_laneq_f64(__p0_936, __p1_936, __p2_936) __extension__ ({ \
+ float64x1_t __ret_936; \
+ float64x1_t __s0_936 = __p0_936; \
+ float64x2_t __s1_936 = __p1_936; \
+ float64_t __x_936 = vget_lane_f64(__s0_936, 0); \
+ float64_t __y_936 = vgetq_lane_f64(__s1_936, __p2_936); \
+ float64_t __z_936 = vmulxd_f64(__x_936, __y_936); \
+ __ret_936 = vset_lane_f64(__z_936, __s0_936, 0); \
__ret_936; \
})
#else
-#define vmulh_laneq_f16(__p0_937, __p1_937, __p2_937) __extension__ ({ \
- float16_t __ret_937; \
- float16_t __s0_937 = __p0_937; \
- float16x8_t __s1_937 = __p1_937; \
- float16x8_t __rev1_937; __rev1_937 = __builtin_shufflevector(__s1_937, __s1_937, 7, 6, 5, 4, 3, 2, 1, 0); \
- __ret_937 = __s0_937 * __noswap_vgetq_lane_f16(__rev1_937, __p2_937); \
+#define vmulx_laneq_f64(__p0_937, __p1_937, __p2_937) __extension__ ({ \
+ float64x1_t __ret_937; \
+ float64x1_t __s0_937 = __p0_937; \
+ float64x2_t __s1_937 = __p1_937; \
+ float64x2_t __rev1_937; __rev1_937 = __builtin_shufflevector(__s1_937, __s1_937, 1, 0); \
+ float64_t __x_937 = vget_lane_f64(__s0_937, 0); \
+ float64_t __y_937 = __noswap_vgetq_lane_f64(__rev1_937, __p2_937); \
+ float64_t __z_937 = vmulxd_f64(__x_937, __y_937); \
+ __ret_937 = vset_lane_f64(__z_937, __s0_937, 0); \
__ret_937; \
})
#endif
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vabal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+__ai __attribute__((target("neon"))) uint16x8_t vabal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint16x8_t __ret;
__ret = __p0 + vabdl_u8(__p1, __p2);
return __ret;
}
#else
-__ai uint16x8_t vabal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+__ai __attribute__((target("neon"))) uint16x8_t vabal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -69403,7 +69399,7 @@ __ai uint16x8_t vabal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai uint16x8_t __noswap_vabal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+__ai __attribute__((target("neon"))) uint16x8_t __noswap_vabal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
uint16x8_t __ret;
__ret = __p0 + __noswap_vabdl_u8(__p1, __p2);
return __ret;
@@ -69411,13 +69407,13 @@ __ai uint16x8_t __noswap_vabal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vabal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vabal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
uint64x2_t __ret;
__ret = __p0 + vabdl_u32(__p1, __p2);
return __ret;
}
#else
-__ai uint64x2_t vabal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vabal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -69426,7 +69422,7 @@ __ai uint64x2_t vabal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai uint64x2_t __noswap_vabal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vabal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
uint64x2_t __ret;
__ret = __p0 + __noswap_vabdl_u32(__p1, __p2);
return __ret;
@@ -69434,13 +69430,13 @@ __ai uint64x2_t __noswap_vabal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vabal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vabal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
uint32x4_t __ret;
__ret = __p0 + vabdl_u16(__p1, __p2);
return __ret;
}
#else
-__ai uint32x4_t vabal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vabal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -69449,7 +69445,7 @@ __ai uint32x4_t vabal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai uint32x4_t __noswap_vabal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vabal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
uint32x4_t __ret;
__ret = __p0 + __noswap_vabdl_u16(__p1, __p2);
return __ret;
@@ -69457,13 +69453,13 @@ __ai uint32x4_t __noswap_vabal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vabal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+__ai __attribute__((target("neon"))) int16x8_t vabal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
int16x8_t __ret;
__ret = __p0 + vabdl_s8(__p1, __p2);
return __ret;
}
#else
-__ai int16x8_t vabal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+__ai __attribute__((target("neon"))) int16x8_t vabal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -69472,7 +69468,7 @@ __ai int16x8_t vabal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
return __ret;
}
-__ai int16x8_t __noswap_vabal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vabal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
int16x8_t __ret;
__ret = __p0 + __noswap_vabdl_s8(__p1, __p2);
return __ret;
@@ -69480,13 +69476,13 @@ __ai int16x8_t __noswap_vabal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vabal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vabal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int64x2_t __ret;
__ret = __p0 + vabdl_s32(__p1, __p2);
return __ret;
}
#else
-__ai int64x2_t vabal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vabal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x2_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
@@ -69495,7 +69491,7 @@ __ai int64x2_t vabal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 1, 0);
return __ret;
}
-__ai int64x2_t __noswap_vabal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vabal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
int64x2_t __ret;
__ret = __p0 + __noswap_vabdl_s32(__p1, __p2);
return __ret;
@@ -69503,13 +69499,13 @@ __ai int64x2_t __noswap_vabal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vabal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vabal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
int32x4_t __ret;
__ret = __p0 + vabdl_s16(__p1, __p2);
return __ret;
}
#else
-__ai int32x4_t vabal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vabal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -69518,22 +69514,22 @@ __ai int32x4_t vabal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
__ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
return __ret;
}
-__ai int32x4_t __noswap_vabal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vabal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
int32x4_t __ret;
__ret = __p0 + __noswap_vabdl_s16(__p1, __p2);
return __ret;
}
#endif
-#if defined(__aarch64__)
+#if defined(__aarch64__) || defined(__arm64ec__)
#ifdef __LITTLE_ENDIAN__
-__ai uint16x8_t vabal_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+__ai __attribute__((target("neon"))) uint16x8_t vabal_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint16x8_t __ret;
__ret = vabal_u8(__p0, vget_high_u8(__p1), vget_high_u8(__p2));
return __ret;
}
#else
-__ai uint16x8_t vabal_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+__ai __attribute__((target("neon"))) uint16x8_t vabal_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
uint16x8_t __ret;
uint16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
uint8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -69545,13 +69541,13 @@ __ai uint16x8_t vabal_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2)
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint64x2_t vabal_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vabal_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint64x2_t __ret;
__ret = vabal_u32(__p0, vget_high_u32(__p1), vget_high_u32(__p2));
return __ret;
}
#else
-__ai uint64x2_t vabal_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+__ai __attribute__((target("neon"))) uint64x2_t vabal_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
uint64x2_t __ret;
uint64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
uint32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -69563,13 +69559,13 @@ __ai uint64x2_t vabal_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-__ai uint32x4_t vabal_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vabal_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
uint32x4_t __ret;
__ret = vabal_u16(__p0, vget_high_u16(__p1), vget_high_u16(__p2));
return __ret;
}
#else
-__ai uint32x4_t vabal_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+__ai __attribute__((target("neon"))) uint32x4_t vabal_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
uint32x4_t __ret;
uint32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
uint16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -69581,13 +69577,13 @@ __ai uint32x4_t vabal_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int16x8_t vabal_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
+__ai __attribute__((target("neon"))) int16x8_t vabal_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
int16x8_t __ret;
__ret = vabal_s8(__p0, vget_high_s8(__p1), vget_high_s8(__p2));
return __ret;
}
#else
-__ai int16x8_t vabal_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
+__ai __attribute__((target("neon"))) int16x8_t vabal_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
int16x8_t __ret;
int16x8_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
int8x16_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -69599,13 +69595,13 @@ __ai int16x8_t vabal_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int64x2_t vabal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vabal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
int64x2_t __ret;
__ret = vabal_s32(__p0, vget_high_s32(__p1), vget_high_s32(__p2));
return __ret;
}
#else
-__ai int64x2_t vabal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+__ai __attribute__((target("neon"))) int64x2_t vabal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
int64x2_t __ret;
int64x2_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
int32x4_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
@@ -69617,13 +69613,13 @@ __ai int64x2_t vabal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
#endif
#ifdef __LITTLE_ENDIAN__
-__ai int32x4_t vabal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vabal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
int32x4_t __ret;
__ret = vabal_s16(__p0, vget_high_s16(__p1), vget_high_s16(__p2));
return __ret;
}
#else
-__ai int32x4_t vabal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+__ai __attribute__((target("neon"))) int32x4_t vabal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
int32x4_t __ret;
int32x4_t __rev0; __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
int16x8_t __rev1; __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
@@ -69640,4 +69636,3 @@ __ai int32x4_t vabal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
#endif /* if !defined(__ARM_NEON) */
#endif /* ifndef __ARM_FP */
-#endif /* __ARM_NEON_H */
diff --git a/lib/include/arm_sme.h b/lib/include/arm_sme.h
index 2ed316f26070..cbfea38fe457 100644
--- a/lib/include/arm_sme.h
+++ b/lib/include/arm_sme.h
@@ -16,6 +16,8 @@
#endif
#include
+#include
+
/* Function attributes */
#define __ai static __inline__ __attribute__((__always_inline__, __nodebug__))
@@ -39,6 +41,11 @@ __ai bool __arm_in_streaming_mode(void) __arm_streaming_compatible {
return x0 & 1;
}
+void *__arm_sc_memcpy(void *dest, const void *src, size_t n) __arm_streaming_compatible;
+void *__arm_sc_memmove(void *dest, const void *src, size_t n) __arm_streaming_compatible;
+void *__arm_sc_memset(void *s, int c, size_t n) __arm_streaming_compatible;
+void *__arm_sc_memchr(void *s, int c, size_t n) __arm_streaming_compatible;
+
__ai __attribute__((target("sme"))) void svundef_za(void) __arm_streaming_compatible __arm_out("za") { }
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddha_za32_u32_m)))
@@ -368,7 +375,7 @@ void svwrite_ver_za8_s8_m(uint64_t, uint32_t, svbool_t, svint8_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_mask_za)))
void svzero_mask_za(uint64_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_za)))
-void svzero_za();
+void svzero_za(void);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddha_za32_u32_m)))
void svaddha_za32_m(uint64_t, svbool_t, svbool_t, svuint32_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddha_za32_s32_m)))
@@ -597,6 +604,78 @@ __aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za8_u8_
void svwrite_ver_za8_m(uint64_t, uint32_t, svbool_t, svuint8_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za8_s8_m)))
void svwrite_ver_za8_m(uint64_t, uint32_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za16_f16_vg1x2)))
+void svmla_single_za16_f16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za16_f16_vg1x4)))
+void svmla_single_za16_f16_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za16_f16_vg1x2)))
+void svmla_lane_za16_f16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za16_f16_vg1x4)))
+void svmla_lane_za16_f16_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za16_f16_vg1x2)))
+void svmla_za16_f16_vg1x2(uint32_t, svfloat16x2_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za16_f16_vg1x4)))
+void svmla_za16_f16_vg1x4(uint32_t, svfloat16x4_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za16_f16_vg1x2)))
+void svmls_single_za16_f16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za16_f16_vg1x4)))
+void svmls_single_za16_f16_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za16_f16_vg1x2)))
+void svmls_lane_za16_f16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za16_f16_vg1x4)))
+void svmls_lane_za16_f16_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za16_f16_vg1x2)))
+void svmls_za16_f16_vg1x2(uint32_t, svfloat16x2_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za16_f16_vg1x4)))
+void svmls_za16_f16_vg1x4(uint32_t, svfloat16x4_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za16_f16_m)))
+void svmopa_za16_f16_m(uint64_t, svbool_t, svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za16_f16_m)))
+void svmops_za16_f16_m(uint64_t, svbool_t, svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za16_f16_vg1x2)))
+void svmla_za16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za16_f16_vg1x4)))
+void svmla_za16_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za16_f16_vg1x2)))
+void svmla_lane_za16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za16_f16_vg1x4)))
+void svmla_lane_za16_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za16_f16_vg1x2)))
+void svmla_za16_vg1x2(uint32_t, svfloat16x2_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za16_f16_vg1x4)))
+void svmla_za16_vg1x4(uint32_t, svfloat16x4_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za16_f16_vg1x2)))
+void svmls_za16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za16_f16_vg1x4)))
+void svmls_za16_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za16_f16_vg1x2)))
+void svmls_lane_za16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za16_f16_vg1x4)))
+void svmls_lane_za16_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za16_f16_vg1x2)))
+void svmls_za16_vg1x2(uint32_t, svfloat16x2_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za16_f16_vg1x4)))
+void svmls_za16_vg1x4(uint32_t, svfloat16x4_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za16_f16_m)))
+void svmopa_za16_m(uint64_t, svbool_t, svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za16_f16_m)))
+void svmops_za16_m(uint64_t, svbool_t, svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za16_f16_vg1x2)))
+void svadd_za16_f16_vg1x2(uint32_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za16_f16_vg1x4)))
+void svadd_za16_f16_vg1x4(uint32_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za16_f16_vg1x2)))
+void svsub_za16_f16_vg1x2(uint32_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za16_f16_vg1x4)))
+void svsub_za16_f16_vg1x4(uint32_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za16_f16_vg1x2)))
+void svadd_za16_vg1x2(uint32_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za16_f16_vg1x4)))
+void svadd_za16_vg1x4(uint32_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za16_f16_vg1x2)))
+void svsub_za16_vg1x2(uint32_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za16_f16_vg1x4)))
+void svsub_za16_vg1x4(uint32_t, svfloat16x4_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za64_f64_m)))
void svmopa_za64_f64_m(uint64_t, svbool_t, svbool_t, svfloat64_t, svfloat64_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za64_f64_m)))
@@ -2059,6 +2138,78 @@ __aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za8_u8_vg1x
void svwrite_za8_vg1x4(uint32_t, svuint8x4_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za8_s8_vg1x4)))
void svwrite_za8_vg1x4(uint32_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za16_bf16_vg1x2)))
+void svadd_za16_bf16_vg1x2(uint32_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za16_bf16_vg1x4)))
+void svadd_za16_bf16_vg1x4(uint32_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za16_bf16_vg1x2)))
+void svmla_single_za16_bf16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za16_bf16_vg1x4)))
+void svmla_single_za16_bf16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za16_bf16_vg1x2)))
+void svmla_lane_za16_bf16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za16_bf16_vg1x4)))
+void svmla_lane_za16_bf16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za16_bf16_vg1x2)))
+void svmla_za16_bf16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za16_bf16_vg1x4)))
+void svmla_za16_bf16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za16_bf16_vg1x2)))
+void svmls_single_za16_bf16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za16_bf16_vg1x4)))
+void svmls_single_za16_bf16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za16_bf16_vg1x2)))
+void svmls_lane_za16_bf16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za16_bf16_vg1x4)))
+void svmls_lane_za16_bf16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za16_bf16_vg1x2)))
+void svmls_za16_bf16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za16_bf16_vg1x4)))
+void svmls_za16_bf16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za16_bf16_m)))
+void svmopa_za16_bf16_m(uint64_t, svbool_t, svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za16_bf16_m)))
+void svmops_za16_bf16_m(uint64_t, svbool_t, svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za16_bf16_vg1x2)))
+void svsub_za16_bf16_vg1x2(uint32_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za16_bf16_vg1x4)))
+void svsub_za16_bf16_vg1x4(uint32_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za16_bf16_vg1x2)))
+void svadd_za16_vg1x2(uint32_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za16_bf16_vg1x4)))
+void svadd_za16_vg1x4(uint32_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za16_bf16_vg1x2)))
+void svmla_za16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za16_bf16_vg1x4)))
+void svmla_za16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za16_bf16_vg1x2)))
+void svmla_lane_za16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za16_bf16_vg1x4)))
+void svmla_lane_za16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za16_bf16_vg1x2)))
+void svmla_za16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za16_bf16_vg1x4)))
+void svmla_za16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za16_bf16_vg1x2)))
+void svmls_za16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za16_bf16_vg1x4)))
+void svmls_za16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za16_bf16_vg1x2)))
+void svmls_lane_za16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za16_bf16_vg1x4)))
+void svmls_lane_za16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za16_bf16_vg1x2)))
+void svmls_za16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za16_bf16_vg1x4)))
+void svmls_za16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za16_bf16_m)))
+void svmopa_za16_m(uint64_t, svbool_t, svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za16_bf16_m)))
+void svmops_za16_m(uint64_t, svbool_t, svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za16_bf16_vg1x2)))
+void svsub_za16_vg1x2(uint32_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za16_bf16_vg1x4)))
+void svsub_za16_vg1x4(uint32_t, svbfloat16x4_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za64_f64_vg1x2)))
void svadd_za64_f64_vg1x2(uint32_t, svfloat64x2_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za64_f64_vg1x4)))
@@ -2403,6 +2554,262 @@ __aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svvdot_lane_za64_s1
void svvdot_lane_za64_vg1x4(uint32_t, svint16x4_t, svint16_t, uint64_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svvdot_lane_za64_u16_vg1x4)))
void svvdot_lane_za64_vg1x4(uint32_t, svuint16x4_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_u8)))
+svuint8_t svreadz_hor_za128_u8(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_u32)))
+svuint32_t svreadz_hor_za128_u32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_u64)))
+svuint64_t svreadz_hor_za128_u64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_u16)))
+svuint16_t svreadz_hor_za128_u16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_bf16)))
+svbfloat16_t svreadz_hor_za128_bf16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_s8)))
+svint8_t svreadz_hor_za128_s8(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_f64)))
+svfloat64_t svreadz_hor_za128_f64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_f32)))
+svfloat32_t svreadz_hor_za128_f32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_f16)))
+svfloat16_t svreadz_hor_za128_f16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_s32)))
+svint32_t svreadz_hor_za128_s32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_s64)))
+svint64_t svreadz_hor_za128_s64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_s16)))
+svint16_t svreadz_hor_za128_s16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_u16)))
+svuint16_t svreadz_hor_za16_u16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_bf16)))
+svbfloat16_t svreadz_hor_za16_bf16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_f16)))
+svfloat16_t svreadz_hor_za16_f16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_s16)))
+svint16_t svreadz_hor_za16_s16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_u16_vg2)))
+svuint16x2_t svreadz_hor_za16_u16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_bf16_vg2)))
+svbfloat16x2_t svreadz_hor_za16_bf16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_f16_vg2)))
+svfloat16x2_t svreadz_hor_za16_f16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_s16_vg2)))
+svint16x2_t svreadz_hor_za16_s16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_u16_vg4)))
+svuint16x4_t svreadz_hor_za16_u16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_bf16_vg4)))
+svbfloat16x4_t svreadz_hor_za16_bf16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_f16_vg4)))
+svfloat16x4_t svreadz_hor_za16_f16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_s16_vg4)))
+svint16x4_t svreadz_hor_za16_s16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za32_u32)))
+svuint32_t svreadz_hor_za32_u32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za32_f32)))
+svfloat32_t svreadz_hor_za32_f32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za32_s32)))
+svint32_t svreadz_hor_za32_s32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za32_u32_vg2)))
+svuint32x2_t svreadz_hor_za32_u32_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za32_f32_vg2)))
+svfloat32x2_t svreadz_hor_za32_f32_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za32_s32_vg2)))
+svint32x2_t svreadz_hor_za32_s32_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za32_u32_vg4)))
+svuint32x4_t svreadz_hor_za32_u32_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za32_f32_vg4)))
+svfloat32x4_t svreadz_hor_za32_f32_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za32_s32_vg4)))
+svint32x4_t svreadz_hor_za32_s32_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za64_u64)))
+svuint64_t svreadz_hor_za64_u64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za64_f64)))
+svfloat64_t svreadz_hor_za64_f64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za64_s64)))
+svint64_t svreadz_hor_za64_s64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za64_u64_vg2)))
+svuint64x2_t svreadz_hor_za64_u64_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za64_f64_vg2)))
+svfloat64x2_t svreadz_hor_za64_f64_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za64_s64_vg2)))
+svint64x2_t svreadz_hor_za64_s64_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za64_u64_vg4)))
+svuint64x4_t svreadz_hor_za64_u64_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za64_f64_vg4)))
+svfloat64x4_t svreadz_hor_za64_f64_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za64_s64_vg4)))
+svint64x4_t svreadz_hor_za64_s64_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za8_u8)))
+svuint8_t svreadz_hor_za8_u8(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za8_s8)))
+svint8_t svreadz_hor_za8_s8(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za8_u8_vg2)))
+svuint8x2_t svreadz_hor_za8_u8_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za8_s8_vg2)))
+svint8x2_t svreadz_hor_za8_s8_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za8_u8_vg4)))
+svuint8x4_t svreadz_hor_za8_u8_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za8_s8_vg4)))
+svint8x4_t svreadz_hor_za8_s8_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_u8)))
+svuint8_t svreadz_ver_za128_u8(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_u32)))
+svuint32_t svreadz_ver_za128_u32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_u64)))
+svuint64_t svreadz_ver_za128_u64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_u16)))
+svuint16_t svreadz_ver_za128_u16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_bf16)))
+svbfloat16_t svreadz_ver_za128_bf16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_s8)))
+svint8_t svreadz_ver_za128_s8(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_f64)))
+svfloat64_t svreadz_ver_za128_f64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_f32)))
+svfloat32_t svreadz_ver_za128_f32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_f16)))
+svfloat16_t svreadz_ver_za128_f16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_s32)))
+svint32_t svreadz_ver_za128_s32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_s64)))
+svint64_t svreadz_ver_za128_s64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_s16)))
+svint16_t svreadz_ver_za128_s16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_u16)))
+svuint16_t svreadz_ver_za16_u16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_bf16)))
+svbfloat16_t svreadz_ver_za16_bf16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_f16)))
+svfloat16_t svreadz_ver_za16_f16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_s16)))
+svint16_t svreadz_ver_za16_s16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_u16_vg2)))
+svuint16x2_t svreadz_ver_za16_u16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_bf16_vg2)))
+svbfloat16x2_t svreadz_ver_za16_bf16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_f16_vg2)))
+svfloat16x2_t svreadz_ver_za16_f16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_s16_vg2)))
+svint16x2_t svreadz_ver_za16_s16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_u16_vg4)))
+svuint16x4_t svreadz_ver_za16_u16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_bf16_vg4)))
+svbfloat16x4_t svreadz_ver_za16_bf16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_f16_vg4)))
+svfloat16x4_t svreadz_ver_za16_f16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_s16_vg4)))
+svint16x4_t svreadz_ver_za16_s16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za32_u32)))
+svuint32_t svreadz_ver_za32_u32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za32_f32)))
+svfloat32_t svreadz_ver_za32_f32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za32_s32)))
+svint32_t svreadz_ver_za32_s32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za32_u32_vg2)))
+svuint32x2_t svreadz_ver_za32_u32_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za32_f32_vg2)))
+svfloat32x2_t svreadz_ver_za32_f32_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za32_s32_vg2)))
+svint32x2_t svreadz_ver_za32_s32_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za32_u32_vg4)))
+svuint32x4_t svreadz_ver_za32_u32_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za32_f32_vg4)))
+svfloat32x4_t svreadz_ver_za32_f32_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za32_s32_vg4)))
+svint32x4_t svreadz_ver_za32_s32_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za64_u64)))
+svuint64_t svreadz_ver_za64_u64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za64_f64)))
+svfloat64_t svreadz_ver_za64_f64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za64_s64)))
+svint64_t svreadz_ver_za64_s64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za64_u64_vg2)))
+svuint64x2_t svreadz_ver_za64_u64_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za64_f64_vg2)))
+svfloat64x2_t svreadz_ver_za64_f64_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za64_s64_vg2)))
+svint64x2_t svreadz_ver_za64_s64_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za64_u64_vg4)))
+svuint64x4_t svreadz_ver_za64_u64_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za64_f64_vg4)))
+svfloat64x4_t svreadz_ver_za64_f64_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za64_s64_vg4)))
+svint64x4_t svreadz_ver_za64_s64_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za8_u8)))
+svuint8_t svreadz_ver_za8_u8(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za8_s8)))
+svint8_t svreadz_ver_za8_s8(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za8_u8_vg2)))
+svuint8x2_t svreadz_ver_za8_u8_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za8_s8_vg2)))
+svint8x2_t svreadz_ver_za8_s8_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za8_u8_vg4)))
+svuint8x4_t svreadz_ver_za8_u8_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za8_s8_vg4)))
+svint8x4_t svreadz_ver_za8_s8_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za16_u16_vg1x2)))
+svuint16x2_t svreadz_za16_u16_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za16_bf16_vg1x2)))
+svbfloat16x2_t svreadz_za16_bf16_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za16_f16_vg1x2)))
+svfloat16x2_t svreadz_za16_f16_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za16_s16_vg1x2)))
+svint16x2_t svreadz_za16_s16_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za16_u16_vg1x4)))
+svuint16x4_t svreadz_za16_u16_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za16_bf16_vg1x4)))
+svbfloat16x4_t svreadz_za16_bf16_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za16_f16_vg1x4)))
+svfloat16x4_t svreadz_za16_f16_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za16_s16_vg1x4)))
+svint16x4_t svreadz_za16_s16_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za32_u32_vg1x2)))
+svuint32x2_t svreadz_za32_u32_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za32_f32_vg1x2)))
+svfloat32x2_t svreadz_za32_f32_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za32_s32_vg1x2)))
+svint32x2_t svreadz_za32_s32_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za32_u32_vg1x4)))
+svuint32x4_t svreadz_za32_u32_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za32_f32_vg1x4)))
+svfloat32x4_t svreadz_za32_f32_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za32_s32_vg1x4)))
+svint32x4_t svreadz_za32_s32_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za64_u64_vg1x2)))
+svuint64x2_t svreadz_za64_u64_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za64_f64_vg1x2)))
+svfloat64x2_t svreadz_za64_f64_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za64_s64_vg1x2)))
+svint64x2_t svreadz_za64_s64_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za64_u64_vg1x4)))
+svuint64x4_t svreadz_za64_u64_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za64_f64_vg1x4)))
+svfloat64x4_t svreadz_za64_f64_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za64_s64_vg1x4)))
+svint64x4_t svreadz_za64_s64_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za8_u8_vg1x2)))
+svuint8x2_t svreadz_za8_u8_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za8_s8_vg1x2)))
+svint8x2_t svreadz_za8_s8_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za8_u8_vg1x4)))
+svuint8x4_t svreadz_za8_u8_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za8_s8_vg1x4)))
+svint8x4_t svreadz_za8_s8_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_za64_vg1x2)))
+void svzero_za64_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_za64_vg1x4)))
+void svzero_za64_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_za64_vg2x1)))
+void svzero_za64_vg2x1(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_za64_vg2x2)))
+void svzero_za64_vg2x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_za64_vg2x4)))
+void svzero_za64_vg2x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_za64_vg4x1)))
+void svzero_za64_vg4x1(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_za64_vg4x2)))
+void svzero_za64_vg4x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_za64_vg4x4)))
+void svzero_za64_vg4x4(uint32_t);
#ifdef __cplusplus
} // extern "C"
#endif
diff --git a/lib/include/arm_sve.h b/lib/include/arm_sve.h
index 3990f803c5a4..87691e03cecb 100644
--- a/lib/include/arm_sve.h
+++ b/lib/include/arm_sve.h
@@ -124,27532 +124,8062 @@ enum svprfop
#define __aio static __inline__ __attribute__((__always_inline__, __nodebug__, __overloadable__))
-#define svreinterpret_s8_s8(...) __builtin_sve_reinterpret_s8_s8(__VA_ARGS__)
-#define svreinterpret_s8_u8(...) __builtin_sve_reinterpret_s8_u8(__VA_ARGS__)
-#define svreinterpret_s8_s16(...) __builtin_sve_reinterpret_s8_s16(__VA_ARGS__)
-#define svreinterpret_s8_u16(...) __builtin_sve_reinterpret_s8_u16(__VA_ARGS__)
-#define svreinterpret_s8_s32(...) __builtin_sve_reinterpret_s8_s32(__VA_ARGS__)
-#define svreinterpret_s8_u32(...) __builtin_sve_reinterpret_s8_u32(__VA_ARGS__)
-#define svreinterpret_s8_s64(...) __builtin_sve_reinterpret_s8_s64(__VA_ARGS__)
-#define svreinterpret_s8_u64(...) __builtin_sve_reinterpret_s8_u64(__VA_ARGS__)
-#define svreinterpret_s8_f16(...) __builtin_sve_reinterpret_s8_f16(__VA_ARGS__)
-#define svreinterpret_s8_bf16(...) __builtin_sve_reinterpret_s8_bf16(__VA_ARGS__)
-#define svreinterpret_s8_f32(...) __builtin_sve_reinterpret_s8_f32(__VA_ARGS__)
-#define svreinterpret_s8_f64(...) __builtin_sve_reinterpret_s8_f64(__VA_ARGS__)
-#define svreinterpret_u8_s8(...) __builtin_sve_reinterpret_u8_s8(__VA_ARGS__)
-#define svreinterpret_u8_u8(...) __builtin_sve_reinterpret_u8_u8(__VA_ARGS__)
-#define svreinterpret_u8_s16(...) __builtin_sve_reinterpret_u8_s16(__VA_ARGS__)
-#define svreinterpret_u8_u16(...) __builtin_sve_reinterpret_u8_u16(__VA_ARGS__)
-#define svreinterpret_u8_s32(...) __builtin_sve_reinterpret_u8_s32(__VA_ARGS__)
-#define svreinterpret_u8_u32(...) __builtin_sve_reinterpret_u8_u32(__VA_ARGS__)
-#define svreinterpret_u8_s64(...) __builtin_sve_reinterpret_u8_s64(__VA_ARGS__)
-#define svreinterpret_u8_u64(...) __builtin_sve_reinterpret_u8_u64(__VA_ARGS__)
-#define svreinterpret_u8_f16(...) __builtin_sve_reinterpret_u8_f16(__VA_ARGS__)
-#define svreinterpret_u8_bf16(...) __builtin_sve_reinterpret_u8_bf16(__VA_ARGS__)
-#define svreinterpret_u8_f32(...) __builtin_sve_reinterpret_u8_f32(__VA_ARGS__)
-#define svreinterpret_u8_f64(...) __builtin_sve_reinterpret_u8_f64(__VA_ARGS__)
-#define svreinterpret_s16_s8(...) __builtin_sve_reinterpret_s16_s8(__VA_ARGS__)
-#define svreinterpret_s16_u8(...) __builtin_sve_reinterpret_s16_u8(__VA_ARGS__)
-#define svreinterpret_s16_s16(...) __builtin_sve_reinterpret_s16_s16(__VA_ARGS__)
-#define svreinterpret_s16_u16(...) __builtin_sve_reinterpret_s16_u16(__VA_ARGS__)
-#define svreinterpret_s16_s32(...) __builtin_sve_reinterpret_s16_s32(__VA_ARGS__)
-#define svreinterpret_s16_u32(...) __builtin_sve_reinterpret_s16_u32(__VA_ARGS__)
-#define svreinterpret_s16_s64(...) __builtin_sve_reinterpret_s16_s64(__VA_ARGS__)
-#define svreinterpret_s16_u64(...) __builtin_sve_reinterpret_s16_u64(__VA_ARGS__)
-#define svreinterpret_s16_f16(...) __builtin_sve_reinterpret_s16_f16(__VA_ARGS__)
-#define svreinterpret_s16_bf16(...) __builtin_sve_reinterpret_s16_bf16(__VA_ARGS__)
-#define svreinterpret_s16_f32(...) __builtin_sve_reinterpret_s16_f32(__VA_ARGS__)
-#define svreinterpret_s16_f64(...) __builtin_sve_reinterpret_s16_f64(__VA_ARGS__)
-#define svreinterpret_u16_s8(...) __builtin_sve_reinterpret_u16_s8(__VA_ARGS__)
-#define svreinterpret_u16_u8(...) __builtin_sve_reinterpret_u16_u8(__VA_ARGS__)
-#define svreinterpret_u16_s16(...) __builtin_sve_reinterpret_u16_s16(__VA_ARGS__)
-#define svreinterpret_u16_u16(...) __builtin_sve_reinterpret_u16_u16(__VA_ARGS__)
-#define svreinterpret_u16_s32(...) __builtin_sve_reinterpret_u16_s32(__VA_ARGS__)
-#define svreinterpret_u16_u32(...) __builtin_sve_reinterpret_u16_u32(__VA_ARGS__)
-#define svreinterpret_u16_s64(...) __builtin_sve_reinterpret_u16_s64(__VA_ARGS__)
-#define svreinterpret_u16_u64(...) __builtin_sve_reinterpret_u16_u64(__VA_ARGS__)
-#define svreinterpret_u16_f16(...) __builtin_sve_reinterpret_u16_f16(__VA_ARGS__)
-#define svreinterpret_u16_bf16(...) __builtin_sve_reinterpret_u16_bf16(__VA_ARGS__)
-#define svreinterpret_u16_f32(...) __builtin_sve_reinterpret_u16_f32(__VA_ARGS__)
-#define svreinterpret_u16_f64(...) __builtin_sve_reinterpret_u16_f64(__VA_ARGS__)
-#define svreinterpret_s32_s8(...) __builtin_sve_reinterpret_s32_s8(__VA_ARGS__)
-#define svreinterpret_s32_u8(...) __builtin_sve_reinterpret_s32_u8(__VA_ARGS__)
-#define svreinterpret_s32_s16(...) __builtin_sve_reinterpret_s32_s16(__VA_ARGS__)
-#define svreinterpret_s32_u16(...) __builtin_sve_reinterpret_s32_u16(__VA_ARGS__)
-#define svreinterpret_s32_s32(...) __builtin_sve_reinterpret_s32_s32(__VA_ARGS__)
-#define svreinterpret_s32_u32(...) __builtin_sve_reinterpret_s32_u32(__VA_ARGS__)
-#define svreinterpret_s32_s64(...) __builtin_sve_reinterpret_s32_s64(__VA_ARGS__)
-#define svreinterpret_s32_u64(...) __builtin_sve_reinterpret_s32_u64(__VA_ARGS__)
-#define svreinterpret_s32_f16(...) __builtin_sve_reinterpret_s32_f16(__VA_ARGS__)
-#define svreinterpret_s32_bf16(...) __builtin_sve_reinterpret_s32_bf16(__VA_ARGS__)
-#define svreinterpret_s32_f32(...) __builtin_sve_reinterpret_s32_f32(__VA_ARGS__)
-#define svreinterpret_s32_f64(...) __builtin_sve_reinterpret_s32_f64(__VA_ARGS__)
-#define svreinterpret_u32_s8(...) __builtin_sve_reinterpret_u32_s8(__VA_ARGS__)
-#define svreinterpret_u32_u8(...) __builtin_sve_reinterpret_u32_u8(__VA_ARGS__)
-#define svreinterpret_u32_s16(...) __builtin_sve_reinterpret_u32_s16(__VA_ARGS__)
-#define svreinterpret_u32_u16(...) __builtin_sve_reinterpret_u32_u16(__VA_ARGS__)
-#define svreinterpret_u32_s32(...) __builtin_sve_reinterpret_u32_s32(__VA_ARGS__)
-#define svreinterpret_u32_u32(...) __builtin_sve_reinterpret_u32_u32(__VA_ARGS__)
-#define svreinterpret_u32_s64(...) __builtin_sve_reinterpret_u32_s64(__VA_ARGS__)
-#define svreinterpret_u32_u64(...) __builtin_sve_reinterpret_u32_u64(__VA_ARGS__)
-#define svreinterpret_u32_f16(...) __builtin_sve_reinterpret_u32_f16(__VA_ARGS__)
-#define svreinterpret_u32_bf16(...) __builtin_sve_reinterpret_u32_bf16(__VA_ARGS__)
-#define svreinterpret_u32_f32(...) __builtin_sve_reinterpret_u32_f32(__VA_ARGS__)
-#define svreinterpret_u32_f64(...) __builtin_sve_reinterpret_u32_f64(__VA_ARGS__)
-#define svreinterpret_s64_s8(...) __builtin_sve_reinterpret_s64_s8(__VA_ARGS__)
-#define svreinterpret_s64_u8(...) __builtin_sve_reinterpret_s64_u8(__VA_ARGS__)
-#define svreinterpret_s64_s16(...) __builtin_sve_reinterpret_s64_s16(__VA_ARGS__)
-#define svreinterpret_s64_u16(...) __builtin_sve_reinterpret_s64_u16(__VA_ARGS__)
-#define svreinterpret_s64_s32(...) __builtin_sve_reinterpret_s64_s32(__VA_ARGS__)
-#define svreinterpret_s64_u32(...) __builtin_sve_reinterpret_s64_u32(__VA_ARGS__)
-#define svreinterpret_s64_s64(...) __builtin_sve_reinterpret_s64_s64(__VA_ARGS__)
-#define svreinterpret_s64_u64(...) __builtin_sve_reinterpret_s64_u64(__VA_ARGS__)
-#define svreinterpret_s64_f16(...) __builtin_sve_reinterpret_s64_f16(__VA_ARGS__)
-#define svreinterpret_s64_bf16(...) __builtin_sve_reinterpret_s64_bf16(__VA_ARGS__)
-#define svreinterpret_s64_f32(...) __builtin_sve_reinterpret_s64_f32(__VA_ARGS__)
-#define svreinterpret_s64_f64(...) __builtin_sve_reinterpret_s64_f64(__VA_ARGS__)
-#define svreinterpret_u64_s8(...) __builtin_sve_reinterpret_u64_s8(__VA_ARGS__)
-#define svreinterpret_u64_u8(...) __builtin_sve_reinterpret_u64_u8(__VA_ARGS__)
-#define svreinterpret_u64_s16(...) __builtin_sve_reinterpret_u64_s16(__VA_ARGS__)
-#define svreinterpret_u64_u16(...) __builtin_sve_reinterpret_u64_u16(__VA_ARGS__)
-#define svreinterpret_u64_s32(...) __builtin_sve_reinterpret_u64_s32(__VA_ARGS__)
-#define svreinterpret_u64_u32(...) __builtin_sve_reinterpret_u64_u32(__VA_ARGS__)
-#define svreinterpret_u64_s64(...) __builtin_sve_reinterpret_u64_s64(__VA_ARGS__)
-#define svreinterpret_u64_u64(...) __builtin_sve_reinterpret_u64_u64(__VA_ARGS__)
-#define svreinterpret_u64_f16(...) __builtin_sve_reinterpret_u64_f16(__VA_ARGS__)
-#define svreinterpret_u64_bf16(...) __builtin_sve_reinterpret_u64_bf16(__VA_ARGS__)
-#define svreinterpret_u64_f32(...) __builtin_sve_reinterpret_u64_f32(__VA_ARGS__)
-#define svreinterpret_u64_f64(...) __builtin_sve_reinterpret_u64_f64(__VA_ARGS__)
-#define svreinterpret_f16_s8(...) __builtin_sve_reinterpret_f16_s8(__VA_ARGS__)
-#define svreinterpret_f16_u8(...) __builtin_sve_reinterpret_f16_u8(__VA_ARGS__)
-#define svreinterpret_f16_s16(...) __builtin_sve_reinterpret_f16_s16(__VA_ARGS__)
-#define svreinterpret_f16_u16(...) __builtin_sve_reinterpret_f16_u16(__VA_ARGS__)
-#define svreinterpret_f16_s32(...) __builtin_sve_reinterpret_f16_s32(__VA_ARGS__)
-#define svreinterpret_f16_u32(...) __builtin_sve_reinterpret_f16_u32(__VA_ARGS__)
-#define svreinterpret_f16_s64(...) __builtin_sve_reinterpret_f16_s64(__VA_ARGS__)
-#define svreinterpret_f16_u64(...) __builtin_sve_reinterpret_f16_u64(__VA_ARGS__)
-#define svreinterpret_f16_f16(...) __builtin_sve_reinterpret_f16_f16(__VA_ARGS__)
-#define svreinterpret_f16_bf16(...) __builtin_sve_reinterpret_f16_bf16(__VA_ARGS__)
-#define svreinterpret_f16_f32(...) __builtin_sve_reinterpret_f16_f32(__VA_ARGS__)
-#define svreinterpret_f16_f64(...) __builtin_sve_reinterpret_f16_f64(__VA_ARGS__)
-#define svreinterpret_bf16_s8(...) __builtin_sve_reinterpret_bf16_s8(__VA_ARGS__)
-#define svreinterpret_bf16_u8(...) __builtin_sve_reinterpret_bf16_u8(__VA_ARGS__)
-#define svreinterpret_bf16_s16(...) __builtin_sve_reinterpret_bf16_s16(__VA_ARGS__)
-#define svreinterpret_bf16_u16(...) __builtin_sve_reinterpret_bf16_u16(__VA_ARGS__)
-#define svreinterpret_bf16_s32(...) __builtin_sve_reinterpret_bf16_s32(__VA_ARGS__)
-#define svreinterpret_bf16_u32(...) __builtin_sve_reinterpret_bf16_u32(__VA_ARGS__)
-#define svreinterpret_bf16_s64(...) __builtin_sve_reinterpret_bf16_s64(__VA_ARGS__)
-#define svreinterpret_bf16_u64(...) __builtin_sve_reinterpret_bf16_u64(__VA_ARGS__)
-#define svreinterpret_bf16_f16(...) __builtin_sve_reinterpret_bf16_f16(__VA_ARGS__)
-#define svreinterpret_bf16_bf16(...) __builtin_sve_reinterpret_bf16_bf16(__VA_ARGS__)
-#define svreinterpret_bf16_f32(...) __builtin_sve_reinterpret_bf16_f32(__VA_ARGS__)
-#define svreinterpret_bf16_f64(...) __builtin_sve_reinterpret_bf16_f64(__VA_ARGS__)
-#define svreinterpret_f32_s8(...) __builtin_sve_reinterpret_f32_s8(__VA_ARGS__)
-#define svreinterpret_f32_u8(...) __builtin_sve_reinterpret_f32_u8(__VA_ARGS__)
-#define svreinterpret_f32_s16(...) __builtin_sve_reinterpret_f32_s16(__VA_ARGS__)
-#define svreinterpret_f32_u16(...) __builtin_sve_reinterpret_f32_u16(__VA_ARGS__)
-#define svreinterpret_f32_s32(...) __builtin_sve_reinterpret_f32_s32(__VA_ARGS__)
-#define svreinterpret_f32_u32(...) __builtin_sve_reinterpret_f32_u32(__VA_ARGS__)
-#define svreinterpret_f32_s64(...) __builtin_sve_reinterpret_f32_s64(__VA_ARGS__)
-#define svreinterpret_f32_u64(...) __builtin_sve_reinterpret_f32_u64(__VA_ARGS__)
-#define svreinterpret_f32_f16(...) __builtin_sve_reinterpret_f32_f16(__VA_ARGS__)
-#define svreinterpret_f32_bf16(...) __builtin_sve_reinterpret_f32_bf16(__VA_ARGS__)
-#define svreinterpret_f32_f32(...) __builtin_sve_reinterpret_f32_f32(__VA_ARGS__)
-#define svreinterpret_f32_f64(...) __builtin_sve_reinterpret_f32_f64(__VA_ARGS__)
-#define svreinterpret_f64_s8(...) __builtin_sve_reinterpret_f64_s8(__VA_ARGS__)
-#define svreinterpret_f64_u8(...) __builtin_sve_reinterpret_f64_u8(__VA_ARGS__)
-#define svreinterpret_f64_s16(...) __builtin_sve_reinterpret_f64_s16(__VA_ARGS__)
-#define svreinterpret_f64_u16(...) __builtin_sve_reinterpret_f64_u16(__VA_ARGS__)
-#define svreinterpret_f64_s32(...) __builtin_sve_reinterpret_f64_s32(__VA_ARGS__)
-#define svreinterpret_f64_u32(...) __builtin_sve_reinterpret_f64_u32(__VA_ARGS__)
-#define svreinterpret_f64_s64(...) __builtin_sve_reinterpret_f64_s64(__VA_ARGS__)
-#define svreinterpret_f64_u64(...) __builtin_sve_reinterpret_f64_u64(__VA_ARGS__)
-#define svreinterpret_f64_f16(...) __builtin_sve_reinterpret_f64_f16(__VA_ARGS__)
-#define svreinterpret_f64_bf16(...) __builtin_sve_reinterpret_f64_bf16(__VA_ARGS__)
-#define svreinterpret_f64_f32(...) __builtin_sve_reinterpret_f64_f32(__VA_ARGS__)
-#define svreinterpret_f64_f64(...) __builtin_sve_reinterpret_f64_f64(__VA_ARGS__)
-__aio __attribute__((target("sve"))) svint8_t svreinterpret_s8(svint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_s8(op);
-}
-
-__aio __attribute__((target("sve"))) svint8_t svreinterpret_s8(svuint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_u8(op);
-}
-
-__aio __attribute__((target("sve"))) svint8_t svreinterpret_s8(svint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_s16(op);
-}
-
-__aio __attribute__((target("sve"))) svint8_t svreinterpret_s8(svuint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_u16(op);
-}
-
-__aio __attribute__((target("sve"))) svint8_t svreinterpret_s8(svint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_s32(op);
-}
-
-__aio __attribute__((target("sve"))) svint8_t svreinterpret_s8(svuint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_u32(op);
-}
-
-__aio __attribute__((target("sve"))) svint8_t svreinterpret_s8(svint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_s64(op);
-}
-
-__aio __attribute__((target("sve"))) svint8_t svreinterpret_s8(svuint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_u64(op);
-}
-
-__aio __attribute__((target("sve"))) svint8_t svreinterpret_s8(svfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_f16(op);
-}
-
-__aio __attribute__((target("sve"))) svint8_t svreinterpret_s8(svbfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_bf16(op);
-}
-
-__aio __attribute__((target("sve"))) svint8_t svreinterpret_s8(svfloat32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_f32(op);
-}
-
-__aio __attribute__((target("sve"))) svint8_t svreinterpret_s8(svfloat64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_f64(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8_t svreinterpret_u8(svint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_s8(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8_t svreinterpret_u8(svuint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_u8(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8_t svreinterpret_u8(svint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_s16(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8_t svreinterpret_u8(svuint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_u16(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8_t svreinterpret_u8(svint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_s32(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8_t svreinterpret_u8(svuint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_u32(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8_t svreinterpret_u8(svint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_s64(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8_t svreinterpret_u8(svuint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_u64(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8_t svreinterpret_u8(svfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_f16(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8_t svreinterpret_u8(svbfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_bf16(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8_t svreinterpret_u8(svfloat32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_f32(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8_t svreinterpret_u8(svfloat64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_f64(op);
-}
-
-__aio __attribute__((target("sve"))) svint16_t svreinterpret_s16(svint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_s8(op);
-}
-
-__aio __attribute__((target("sve"))) svint16_t svreinterpret_s16(svuint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_u8(op);
-}
-
-__aio __attribute__((target("sve"))) svint16_t svreinterpret_s16(svint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_s16(op);
-}
-
-__aio __attribute__((target("sve"))) svint16_t svreinterpret_s16(svuint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_u16(op);
-}
-
-__aio __attribute__((target("sve"))) svint16_t svreinterpret_s16(svint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_s32(op);
-}
-
-__aio __attribute__((target("sve"))) svint16_t svreinterpret_s16(svuint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_u32(op);
-}
-
-__aio __attribute__((target("sve"))) svint16_t svreinterpret_s16(svint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_s64(op);
-}
-
-__aio __attribute__((target("sve"))) svint16_t svreinterpret_s16(svuint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_u64(op);
-}
-
-__aio __attribute__((target("sve"))) svint16_t svreinterpret_s16(svfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_f16(op);
-}
-
-__aio __attribute__((target("sve"))) svint16_t svreinterpret_s16(svbfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_bf16(op);
-}
-
-__aio __attribute__((target("sve"))) svint16_t svreinterpret_s16(svfloat32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_f32(op);
-}
-
-__aio __attribute__((target("sve"))) svint16_t svreinterpret_s16(svfloat64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_f64(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16_t svreinterpret_u16(svint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_s8(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16_t svreinterpret_u16(svuint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_u8(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16_t svreinterpret_u16(svint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_s16(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16_t svreinterpret_u16(svuint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_u16(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16_t svreinterpret_u16(svint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_s32(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16_t svreinterpret_u16(svuint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_u32(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16_t svreinterpret_u16(svint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_s64(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16_t svreinterpret_u16(svuint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_u64(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16_t svreinterpret_u16(svfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_f16(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16_t svreinterpret_u16(svbfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_bf16(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16_t svreinterpret_u16(svfloat32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_f32(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16_t svreinterpret_u16(svfloat64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_f64(op);
-}
-
-__aio __attribute__((target("sve"))) svint32_t svreinterpret_s32(svint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_s8(op);
-}
-
-__aio __attribute__((target("sve"))) svint32_t svreinterpret_s32(svuint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_u8(op);
-}
-
-__aio __attribute__((target("sve"))) svint32_t svreinterpret_s32(svint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_s16(op);
-}
-
-__aio __attribute__((target("sve"))) svint32_t svreinterpret_s32(svuint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_u16(op);
-}
-
-__aio __attribute__((target("sve"))) svint32_t svreinterpret_s32(svint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_s32(op);
-}
-
-__aio __attribute__((target("sve"))) svint32_t svreinterpret_s32(svuint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_u32(op);
-}
-
-__aio __attribute__((target("sve"))) svint32_t svreinterpret_s32(svint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_s64(op);
-}
-
-__aio __attribute__((target("sve"))) svint32_t svreinterpret_s32(svuint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_u64(op);
-}
-
-__aio __attribute__((target("sve"))) svint32_t svreinterpret_s32(svfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_f16(op);
-}
-
-__aio __attribute__((target("sve"))) svint32_t svreinterpret_s32(svbfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_bf16(op);
-}
-
-__aio __attribute__((target("sve"))) svint32_t svreinterpret_s32(svfloat32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_f32(op);
-}
-
-__aio __attribute__((target("sve"))) svint32_t svreinterpret_s32(svfloat64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_f64(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32_t svreinterpret_u32(svint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_s8(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32_t svreinterpret_u32(svuint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_u8(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32_t svreinterpret_u32(svint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_s16(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32_t svreinterpret_u32(svuint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_u16(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32_t svreinterpret_u32(svint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_s32(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32_t svreinterpret_u32(svuint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_u32(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32_t svreinterpret_u32(svint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_s64(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32_t svreinterpret_u32(svuint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_u64(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32_t svreinterpret_u32(svfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_f16(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32_t svreinterpret_u32(svbfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_bf16(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32_t svreinterpret_u32(svfloat32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_f32(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32_t svreinterpret_u32(svfloat64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_f64(op);
-}
-
-__aio __attribute__((target("sve"))) svint64_t svreinterpret_s64(svint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_s8(op);
-}
-
-__aio __attribute__((target("sve"))) svint64_t svreinterpret_s64(svuint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_u8(op);
-}
-
-__aio __attribute__((target("sve"))) svint64_t svreinterpret_s64(svint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_s16(op);
-}
-
-__aio __attribute__((target("sve"))) svint64_t svreinterpret_s64(svuint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_u16(op);
-}
-
-__aio __attribute__((target("sve"))) svint64_t svreinterpret_s64(svint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_s32(op);
-}
-
-__aio __attribute__((target("sve"))) svint64_t svreinterpret_s64(svuint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_u32(op);
-}
-
-__aio __attribute__((target("sve"))) svint64_t svreinterpret_s64(svint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_s64(op);
-}
-
-__aio __attribute__((target("sve"))) svint64_t svreinterpret_s64(svuint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_u64(op);
-}
-
-__aio __attribute__((target("sve"))) svint64_t svreinterpret_s64(svfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_f16(op);
-}
-
-__aio __attribute__((target("sve"))) svint64_t svreinterpret_s64(svbfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_bf16(op);
-}
-
-__aio __attribute__((target("sve"))) svint64_t svreinterpret_s64(svfloat32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_f32(op);
-}
-
-__aio __attribute__((target("sve"))) svint64_t svreinterpret_s64(svfloat64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_f64(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64_t svreinterpret_u64(svint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_s8(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64_t svreinterpret_u64(svuint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_u8(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64_t svreinterpret_u64(svint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_s16(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64_t svreinterpret_u64(svuint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_u16(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64_t svreinterpret_u64(svint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_s32(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64_t svreinterpret_u64(svuint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_u32(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64_t svreinterpret_u64(svint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_s64(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64_t svreinterpret_u64(svuint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_u64(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64_t svreinterpret_u64(svfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_f16(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64_t svreinterpret_u64(svbfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_bf16(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64_t svreinterpret_u64(svfloat32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_f32(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64_t svreinterpret_u64(svfloat64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_f64(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16_t svreinterpret_f16(svint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_s8(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16_t svreinterpret_f16(svuint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_u8(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16_t svreinterpret_f16(svint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_s16(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16_t svreinterpret_f16(svuint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_u16(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16_t svreinterpret_f16(svint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_s32(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16_t svreinterpret_f16(svuint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_u32(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16_t svreinterpret_f16(svint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_s64(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16_t svreinterpret_f16(svuint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_u64(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16_t svreinterpret_f16(svfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_f16(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16_t svreinterpret_f16(svbfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_bf16(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16_t svreinterpret_f16(svfloat32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_f32(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16_t svreinterpret_f16(svfloat64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_f64(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16_t svreinterpret_bf16(svint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_s8(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16_t svreinterpret_bf16(svuint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_u8(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16_t svreinterpret_bf16(svint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_s16(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16_t svreinterpret_bf16(svuint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_u16(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16_t svreinterpret_bf16(svint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_s32(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16_t svreinterpret_bf16(svuint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_u32(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16_t svreinterpret_bf16(svint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_s64(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16_t svreinterpret_bf16(svuint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_u64(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16_t svreinterpret_bf16(svfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_f16(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16_t svreinterpret_bf16(svbfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_bf16(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16_t svreinterpret_bf16(svfloat32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_f32(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16_t svreinterpret_bf16(svfloat64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_f64(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32_t svreinterpret_f32(svint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_s8(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32_t svreinterpret_f32(svuint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_u8(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32_t svreinterpret_f32(svint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_s16(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32_t svreinterpret_f32(svuint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_u16(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32_t svreinterpret_f32(svint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_s32(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32_t svreinterpret_f32(svuint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_u32(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32_t svreinterpret_f32(svint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_s64(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32_t svreinterpret_f32(svuint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_u64(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32_t svreinterpret_f32(svfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_f16(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32_t svreinterpret_f32(svbfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_bf16(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32_t svreinterpret_f32(svfloat32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_f32(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32_t svreinterpret_f32(svfloat64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_f64(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64_t svreinterpret_f64(svint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_s8(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64_t svreinterpret_f64(svuint8_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_u8(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64_t svreinterpret_f64(svint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_s16(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64_t svreinterpret_f64(svuint16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_u16(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64_t svreinterpret_f64(svint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_s32(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64_t svreinterpret_f64(svuint32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_u32(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64_t svreinterpret_f64(svint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_s64(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64_t svreinterpret_f64(svuint64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_u64(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64_t svreinterpret_f64(svfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_f16(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64_t svreinterpret_f64(svbfloat16_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_bf16(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64_t svreinterpret_f64(svfloat32_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_f32(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64_t svreinterpret_f64(svfloat64_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_f64(op);
-}
-
-#define svreinterpret_s8_s8_x2(...) __builtin_sve_reinterpret_s8_s8_x2(__VA_ARGS__)
-#define svreinterpret_s8_u8_x2(...) __builtin_sve_reinterpret_s8_u8_x2(__VA_ARGS__)
-#define svreinterpret_s8_s16_x2(...) __builtin_sve_reinterpret_s8_s16_x2(__VA_ARGS__)
-#define svreinterpret_s8_u16_x2(...) __builtin_sve_reinterpret_s8_u16_x2(__VA_ARGS__)
-#define svreinterpret_s8_s32_x2(...) __builtin_sve_reinterpret_s8_s32_x2(__VA_ARGS__)
-#define svreinterpret_s8_u32_x2(...) __builtin_sve_reinterpret_s8_u32_x2(__VA_ARGS__)
-#define svreinterpret_s8_s64_x2(...) __builtin_sve_reinterpret_s8_s64_x2(__VA_ARGS__)
-#define svreinterpret_s8_u64_x2(...) __builtin_sve_reinterpret_s8_u64_x2(__VA_ARGS__)
-#define svreinterpret_s8_f16_x2(...) __builtin_sve_reinterpret_s8_f16_x2(__VA_ARGS__)
-#define svreinterpret_s8_bf16_x2(...) __builtin_sve_reinterpret_s8_bf16_x2(__VA_ARGS__)
-#define svreinterpret_s8_f32_x2(...) __builtin_sve_reinterpret_s8_f32_x2(__VA_ARGS__)
-#define svreinterpret_s8_f64_x2(...) __builtin_sve_reinterpret_s8_f64_x2(__VA_ARGS__)
-#define svreinterpret_u8_s8_x2(...) __builtin_sve_reinterpret_u8_s8_x2(__VA_ARGS__)
-#define svreinterpret_u8_u8_x2(...) __builtin_sve_reinterpret_u8_u8_x2(__VA_ARGS__)
-#define svreinterpret_u8_s16_x2(...) __builtin_sve_reinterpret_u8_s16_x2(__VA_ARGS__)
-#define svreinterpret_u8_u16_x2(...) __builtin_sve_reinterpret_u8_u16_x2(__VA_ARGS__)
-#define svreinterpret_u8_s32_x2(...) __builtin_sve_reinterpret_u8_s32_x2(__VA_ARGS__)
-#define svreinterpret_u8_u32_x2(...) __builtin_sve_reinterpret_u8_u32_x2(__VA_ARGS__)
-#define svreinterpret_u8_s64_x2(...) __builtin_sve_reinterpret_u8_s64_x2(__VA_ARGS__)
-#define svreinterpret_u8_u64_x2(...) __builtin_sve_reinterpret_u8_u64_x2(__VA_ARGS__)
-#define svreinterpret_u8_f16_x2(...) __builtin_sve_reinterpret_u8_f16_x2(__VA_ARGS__)
-#define svreinterpret_u8_bf16_x2(...) __builtin_sve_reinterpret_u8_bf16_x2(__VA_ARGS__)
-#define svreinterpret_u8_f32_x2(...) __builtin_sve_reinterpret_u8_f32_x2(__VA_ARGS__)
-#define svreinterpret_u8_f64_x2(...) __builtin_sve_reinterpret_u8_f64_x2(__VA_ARGS__)
-#define svreinterpret_s16_s8_x2(...) __builtin_sve_reinterpret_s16_s8_x2(__VA_ARGS__)
-#define svreinterpret_s16_u8_x2(...) __builtin_sve_reinterpret_s16_u8_x2(__VA_ARGS__)
-#define svreinterpret_s16_s16_x2(...) __builtin_sve_reinterpret_s16_s16_x2(__VA_ARGS__)
-#define svreinterpret_s16_u16_x2(...) __builtin_sve_reinterpret_s16_u16_x2(__VA_ARGS__)
-#define svreinterpret_s16_s32_x2(...) __builtin_sve_reinterpret_s16_s32_x2(__VA_ARGS__)
-#define svreinterpret_s16_u32_x2(...) __builtin_sve_reinterpret_s16_u32_x2(__VA_ARGS__)
-#define svreinterpret_s16_s64_x2(...) __builtin_sve_reinterpret_s16_s64_x2(__VA_ARGS__)
-#define svreinterpret_s16_u64_x2(...) __builtin_sve_reinterpret_s16_u64_x2(__VA_ARGS__)
-#define svreinterpret_s16_f16_x2(...) __builtin_sve_reinterpret_s16_f16_x2(__VA_ARGS__)
-#define svreinterpret_s16_bf16_x2(...) __builtin_sve_reinterpret_s16_bf16_x2(__VA_ARGS__)
-#define svreinterpret_s16_f32_x2(...) __builtin_sve_reinterpret_s16_f32_x2(__VA_ARGS__)
-#define svreinterpret_s16_f64_x2(...) __builtin_sve_reinterpret_s16_f64_x2(__VA_ARGS__)
-#define svreinterpret_u16_s8_x2(...) __builtin_sve_reinterpret_u16_s8_x2(__VA_ARGS__)
-#define svreinterpret_u16_u8_x2(...) __builtin_sve_reinterpret_u16_u8_x2(__VA_ARGS__)
-#define svreinterpret_u16_s16_x2(...) __builtin_sve_reinterpret_u16_s16_x2(__VA_ARGS__)
-#define svreinterpret_u16_u16_x2(...) __builtin_sve_reinterpret_u16_u16_x2(__VA_ARGS__)
-#define svreinterpret_u16_s32_x2(...) __builtin_sve_reinterpret_u16_s32_x2(__VA_ARGS__)
-#define svreinterpret_u16_u32_x2(...) __builtin_sve_reinterpret_u16_u32_x2(__VA_ARGS__)
-#define svreinterpret_u16_s64_x2(...) __builtin_sve_reinterpret_u16_s64_x2(__VA_ARGS__)
-#define svreinterpret_u16_u64_x2(...) __builtin_sve_reinterpret_u16_u64_x2(__VA_ARGS__)
-#define svreinterpret_u16_f16_x2(...) __builtin_sve_reinterpret_u16_f16_x2(__VA_ARGS__)
-#define svreinterpret_u16_bf16_x2(...) __builtin_sve_reinterpret_u16_bf16_x2(__VA_ARGS__)
-#define svreinterpret_u16_f32_x2(...) __builtin_sve_reinterpret_u16_f32_x2(__VA_ARGS__)
-#define svreinterpret_u16_f64_x2(...) __builtin_sve_reinterpret_u16_f64_x2(__VA_ARGS__)
-#define svreinterpret_s32_s8_x2(...) __builtin_sve_reinterpret_s32_s8_x2(__VA_ARGS__)
-#define svreinterpret_s32_u8_x2(...) __builtin_sve_reinterpret_s32_u8_x2(__VA_ARGS__)
-#define svreinterpret_s32_s16_x2(...) __builtin_sve_reinterpret_s32_s16_x2(__VA_ARGS__)
-#define svreinterpret_s32_u16_x2(...) __builtin_sve_reinterpret_s32_u16_x2(__VA_ARGS__)
-#define svreinterpret_s32_s32_x2(...) __builtin_sve_reinterpret_s32_s32_x2(__VA_ARGS__)
-#define svreinterpret_s32_u32_x2(...) __builtin_sve_reinterpret_s32_u32_x2(__VA_ARGS__)
-#define svreinterpret_s32_s64_x2(...) __builtin_sve_reinterpret_s32_s64_x2(__VA_ARGS__)
-#define svreinterpret_s32_u64_x2(...) __builtin_sve_reinterpret_s32_u64_x2(__VA_ARGS__)
-#define svreinterpret_s32_f16_x2(...) __builtin_sve_reinterpret_s32_f16_x2(__VA_ARGS__)
-#define svreinterpret_s32_bf16_x2(...) __builtin_sve_reinterpret_s32_bf16_x2(__VA_ARGS__)
-#define svreinterpret_s32_f32_x2(...) __builtin_sve_reinterpret_s32_f32_x2(__VA_ARGS__)
-#define svreinterpret_s32_f64_x2(...) __builtin_sve_reinterpret_s32_f64_x2(__VA_ARGS__)
-#define svreinterpret_u32_s8_x2(...) __builtin_sve_reinterpret_u32_s8_x2(__VA_ARGS__)
-#define svreinterpret_u32_u8_x2(...) __builtin_sve_reinterpret_u32_u8_x2(__VA_ARGS__)
-#define svreinterpret_u32_s16_x2(...) __builtin_sve_reinterpret_u32_s16_x2(__VA_ARGS__)
-#define svreinterpret_u32_u16_x2(...) __builtin_sve_reinterpret_u32_u16_x2(__VA_ARGS__)
-#define svreinterpret_u32_s32_x2(...) __builtin_sve_reinterpret_u32_s32_x2(__VA_ARGS__)
-#define svreinterpret_u32_u32_x2(...) __builtin_sve_reinterpret_u32_u32_x2(__VA_ARGS__)
-#define svreinterpret_u32_s64_x2(...) __builtin_sve_reinterpret_u32_s64_x2(__VA_ARGS__)
-#define svreinterpret_u32_u64_x2(...) __builtin_sve_reinterpret_u32_u64_x2(__VA_ARGS__)
-#define svreinterpret_u32_f16_x2(...) __builtin_sve_reinterpret_u32_f16_x2(__VA_ARGS__)
-#define svreinterpret_u32_bf16_x2(...) __builtin_sve_reinterpret_u32_bf16_x2(__VA_ARGS__)
-#define svreinterpret_u32_f32_x2(...) __builtin_sve_reinterpret_u32_f32_x2(__VA_ARGS__)
-#define svreinterpret_u32_f64_x2(...) __builtin_sve_reinterpret_u32_f64_x2(__VA_ARGS__)
-#define svreinterpret_s64_s8_x2(...) __builtin_sve_reinterpret_s64_s8_x2(__VA_ARGS__)
-#define svreinterpret_s64_u8_x2(...) __builtin_sve_reinterpret_s64_u8_x2(__VA_ARGS__)
-#define svreinterpret_s64_s16_x2(...) __builtin_sve_reinterpret_s64_s16_x2(__VA_ARGS__)
-#define svreinterpret_s64_u16_x2(...) __builtin_sve_reinterpret_s64_u16_x2(__VA_ARGS__)
-#define svreinterpret_s64_s32_x2(...) __builtin_sve_reinterpret_s64_s32_x2(__VA_ARGS__)
-#define svreinterpret_s64_u32_x2(...) __builtin_sve_reinterpret_s64_u32_x2(__VA_ARGS__)
-#define svreinterpret_s64_s64_x2(...) __builtin_sve_reinterpret_s64_s64_x2(__VA_ARGS__)
-#define svreinterpret_s64_u64_x2(...) __builtin_sve_reinterpret_s64_u64_x2(__VA_ARGS__)
-#define svreinterpret_s64_f16_x2(...) __builtin_sve_reinterpret_s64_f16_x2(__VA_ARGS__)
-#define svreinterpret_s64_bf16_x2(...) __builtin_sve_reinterpret_s64_bf16_x2(__VA_ARGS__)
-#define svreinterpret_s64_f32_x2(...) __builtin_sve_reinterpret_s64_f32_x2(__VA_ARGS__)
-#define svreinterpret_s64_f64_x2(...) __builtin_sve_reinterpret_s64_f64_x2(__VA_ARGS__)
-#define svreinterpret_u64_s8_x2(...) __builtin_sve_reinterpret_u64_s8_x2(__VA_ARGS__)
-#define svreinterpret_u64_u8_x2(...) __builtin_sve_reinterpret_u64_u8_x2(__VA_ARGS__)
-#define svreinterpret_u64_s16_x2(...) __builtin_sve_reinterpret_u64_s16_x2(__VA_ARGS__)
-#define svreinterpret_u64_u16_x2(...) __builtin_sve_reinterpret_u64_u16_x2(__VA_ARGS__)
-#define svreinterpret_u64_s32_x2(...) __builtin_sve_reinterpret_u64_s32_x2(__VA_ARGS__)
-#define svreinterpret_u64_u32_x2(...) __builtin_sve_reinterpret_u64_u32_x2(__VA_ARGS__)
-#define svreinterpret_u64_s64_x2(...) __builtin_sve_reinterpret_u64_s64_x2(__VA_ARGS__)
-#define svreinterpret_u64_u64_x2(...) __builtin_sve_reinterpret_u64_u64_x2(__VA_ARGS__)
-#define svreinterpret_u64_f16_x2(...) __builtin_sve_reinterpret_u64_f16_x2(__VA_ARGS__)
-#define svreinterpret_u64_bf16_x2(...) __builtin_sve_reinterpret_u64_bf16_x2(__VA_ARGS__)
-#define svreinterpret_u64_f32_x2(...) __builtin_sve_reinterpret_u64_f32_x2(__VA_ARGS__)
-#define svreinterpret_u64_f64_x2(...) __builtin_sve_reinterpret_u64_f64_x2(__VA_ARGS__)
-#define svreinterpret_f16_s8_x2(...) __builtin_sve_reinterpret_f16_s8_x2(__VA_ARGS__)
-#define svreinterpret_f16_u8_x2(...) __builtin_sve_reinterpret_f16_u8_x2(__VA_ARGS__)
-#define svreinterpret_f16_s16_x2(...) __builtin_sve_reinterpret_f16_s16_x2(__VA_ARGS__)
-#define svreinterpret_f16_u16_x2(...) __builtin_sve_reinterpret_f16_u16_x2(__VA_ARGS__)
-#define svreinterpret_f16_s32_x2(...) __builtin_sve_reinterpret_f16_s32_x2(__VA_ARGS__)
-#define svreinterpret_f16_u32_x2(...) __builtin_sve_reinterpret_f16_u32_x2(__VA_ARGS__)
-#define svreinterpret_f16_s64_x2(...) __builtin_sve_reinterpret_f16_s64_x2(__VA_ARGS__)
-#define svreinterpret_f16_u64_x2(...) __builtin_sve_reinterpret_f16_u64_x2(__VA_ARGS__)
-#define svreinterpret_f16_f16_x2(...) __builtin_sve_reinterpret_f16_f16_x2(__VA_ARGS__)
-#define svreinterpret_f16_bf16_x2(...) __builtin_sve_reinterpret_f16_bf16_x2(__VA_ARGS__)
-#define svreinterpret_f16_f32_x2(...) __builtin_sve_reinterpret_f16_f32_x2(__VA_ARGS__)
-#define svreinterpret_f16_f64_x2(...) __builtin_sve_reinterpret_f16_f64_x2(__VA_ARGS__)
-#define svreinterpret_bf16_s8_x2(...) __builtin_sve_reinterpret_bf16_s8_x2(__VA_ARGS__)
-#define svreinterpret_bf16_u8_x2(...) __builtin_sve_reinterpret_bf16_u8_x2(__VA_ARGS__)
-#define svreinterpret_bf16_s16_x2(...) __builtin_sve_reinterpret_bf16_s16_x2(__VA_ARGS__)
-#define svreinterpret_bf16_u16_x2(...) __builtin_sve_reinterpret_bf16_u16_x2(__VA_ARGS__)
-#define svreinterpret_bf16_s32_x2(...) __builtin_sve_reinterpret_bf16_s32_x2(__VA_ARGS__)
-#define svreinterpret_bf16_u32_x2(...) __builtin_sve_reinterpret_bf16_u32_x2(__VA_ARGS__)
-#define svreinterpret_bf16_s64_x2(...) __builtin_sve_reinterpret_bf16_s64_x2(__VA_ARGS__)
-#define svreinterpret_bf16_u64_x2(...) __builtin_sve_reinterpret_bf16_u64_x2(__VA_ARGS__)
-#define svreinterpret_bf16_f16_x2(...) __builtin_sve_reinterpret_bf16_f16_x2(__VA_ARGS__)
-#define svreinterpret_bf16_bf16_x2(...) __builtin_sve_reinterpret_bf16_bf16_x2(__VA_ARGS__)
-#define svreinterpret_bf16_f32_x2(...) __builtin_sve_reinterpret_bf16_f32_x2(__VA_ARGS__)
-#define svreinterpret_bf16_f64_x2(...) __builtin_sve_reinterpret_bf16_f64_x2(__VA_ARGS__)
-#define svreinterpret_f32_s8_x2(...) __builtin_sve_reinterpret_f32_s8_x2(__VA_ARGS__)
-#define svreinterpret_f32_u8_x2(...) __builtin_sve_reinterpret_f32_u8_x2(__VA_ARGS__)
-#define svreinterpret_f32_s16_x2(...) __builtin_sve_reinterpret_f32_s16_x2(__VA_ARGS__)
-#define svreinterpret_f32_u16_x2(...) __builtin_sve_reinterpret_f32_u16_x2(__VA_ARGS__)
-#define svreinterpret_f32_s32_x2(...) __builtin_sve_reinterpret_f32_s32_x2(__VA_ARGS__)
-#define svreinterpret_f32_u32_x2(...) __builtin_sve_reinterpret_f32_u32_x2(__VA_ARGS__)
-#define svreinterpret_f32_s64_x2(...) __builtin_sve_reinterpret_f32_s64_x2(__VA_ARGS__)
-#define svreinterpret_f32_u64_x2(...) __builtin_sve_reinterpret_f32_u64_x2(__VA_ARGS__)
-#define svreinterpret_f32_f16_x2(...) __builtin_sve_reinterpret_f32_f16_x2(__VA_ARGS__)
-#define svreinterpret_f32_bf16_x2(...) __builtin_sve_reinterpret_f32_bf16_x2(__VA_ARGS__)
-#define svreinterpret_f32_f32_x2(...) __builtin_sve_reinterpret_f32_f32_x2(__VA_ARGS__)
-#define svreinterpret_f32_f64_x2(...) __builtin_sve_reinterpret_f32_f64_x2(__VA_ARGS__)
-#define svreinterpret_f64_s8_x2(...) __builtin_sve_reinterpret_f64_s8_x2(__VA_ARGS__)
-#define svreinterpret_f64_u8_x2(...) __builtin_sve_reinterpret_f64_u8_x2(__VA_ARGS__)
-#define svreinterpret_f64_s16_x2(...) __builtin_sve_reinterpret_f64_s16_x2(__VA_ARGS__)
-#define svreinterpret_f64_u16_x2(...) __builtin_sve_reinterpret_f64_u16_x2(__VA_ARGS__)
-#define svreinterpret_f64_s32_x2(...) __builtin_sve_reinterpret_f64_s32_x2(__VA_ARGS__)
-#define svreinterpret_f64_u32_x2(...) __builtin_sve_reinterpret_f64_u32_x2(__VA_ARGS__)
-#define svreinterpret_f64_s64_x2(...) __builtin_sve_reinterpret_f64_s64_x2(__VA_ARGS__)
-#define svreinterpret_f64_u64_x2(...) __builtin_sve_reinterpret_f64_u64_x2(__VA_ARGS__)
-#define svreinterpret_f64_f16_x2(...) __builtin_sve_reinterpret_f64_f16_x2(__VA_ARGS__)
-#define svreinterpret_f64_bf16_x2(...) __builtin_sve_reinterpret_f64_bf16_x2(__VA_ARGS__)
-#define svreinterpret_f64_f32_x2(...) __builtin_sve_reinterpret_f64_f32_x2(__VA_ARGS__)
-#define svreinterpret_f64_f64_x2(...) __builtin_sve_reinterpret_f64_f64_x2(__VA_ARGS__)
-__aio __attribute__((target("sve"))) svint8x2_t svreinterpret_s8(svint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_s8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x2_t svreinterpret_s8(svuint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_u8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x2_t svreinterpret_s8(svint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_s16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x2_t svreinterpret_s8(svuint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_u16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x2_t svreinterpret_s8(svint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_s32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x2_t svreinterpret_s8(svuint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_u32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x2_t svreinterpret_s8(svint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_s64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x2_t svreinterpret_s8(svuint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_u64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x2_t svreinterpret_s8(svfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_f16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x2_t svreinterpret_s8(svbfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_bf16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x2_t svreinterpret_s8(svfloat32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_f32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x2_t svreinterpret_s8(svfloat64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_f64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x2_t svreinterpret_u8(svint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_s8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x2_t svreinterpret_u8(svuint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_u8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x2_t svreinterpret_u8(svint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_s16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x2_t svreinterpret_u8(svuint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_u16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x2_t svreinterpret_u8(svint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_s32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x2_t svreinterpret_u8(svuint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_u32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x2_t svreinterpret_u8(svint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_s64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x2_t svreinterpret_u8(svuint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_u64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x2_t svreinterpret_u8(svfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_f16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x2_t svreinterpret_u8(svbfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_bf16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x2_t svreinterpret_u8(svfloat32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_f32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x2_t svreinterpret_u8(svfloat64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_f64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x2_t svreinterpret_s16(svint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_s8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x2_t svreinterpret_s16(svuint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_u8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x2_t svreinterpret_s16(svint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_s16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x2_t svreinterpret_s16(svuint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_u16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x2_t svreinterpret_s16(svint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_s32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x2_t svreinterpret_s16(svuint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_u32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x2_t svreinterpret_s16(svint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_s64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x2_t svreinterpret_s16(svuint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_u64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x2_t svreinterpret_s16(svfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_f16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x2_t svreinterpret_s16(svbfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_bf16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x2_t svreinterpret_s16(svfloat32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_f32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x2_t svreinterpret_s16(svfloat64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_f64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x2_t svreinterpret_u16(svint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_s8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x2_t svreinterpret_u16(svuint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_u8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x2_t svreinterpret_u16(svint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_s16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x2_t svreinterpret_u16(svuint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_u16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x2_t svreinterpret_u16(svint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_s32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x2_t svreinterpret_u16(svuint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_u32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x2_t svreinterpret_u16(svint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_s64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x2_t svreinterpret_u16(svuint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_u64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x2_t svreinterpret_u16(svfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_f16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x2_t svreinterpret_u16(svbfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_bf16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x2_t svreinterpret_u16(svfloat32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_f32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x2_t svreinterpret_u16(svfloat64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_f64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x2_t svreinterpret_s32(svint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_s8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x2_t svreinterpret_s32(svuint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_u8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x2_t svreinterpret_s32(svint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_s16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x2_t svreinterpret_s32(svuint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_u16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x2_t svreinterpret_s32(svint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_s32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x2_t svreinterpret_s32(svuint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_u32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x2_t svreinterpret_s32(svint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_s64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x2_t svreinterpret_s32(svuint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_u64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x2_t svreinterpret_s32(svfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_f16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x2_t svreinterpret_s32(svbfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_bf16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x2_t svreinterpret_s32(svfloat32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_f32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x2_t svreinterpret_s32(svfloat64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_f64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x2_t svreinterpret_u32(svint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_s8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x2_t svreinterpret_u32(svuint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_u8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x2_t svreinterpret_u32(svint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_s16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x2_t svreinterpret_u32(svuint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_u16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x2_t svreinterpret_u32(svint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_s32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x2_t svreinterpret_u32(svuint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_u32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x2_t svreinterpret_u32(svint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_s64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x2_t svreinterpret_u32(svuint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_u64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x2_t svreinterpret_u32(svfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_f16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x2_t svreinterpret_u32(svbfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_bf16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x2_t svreinterpret_u32(svfloat32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_f32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x2_t svreinterpret_u32(svfloat64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_f64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x2_t svreinterpret_s64(svint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_s8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x2_t svreinterpret_s64(svuint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_u8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x2_t svreinterpret_s64(svint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_s16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x2_t svreinterpret_s64(svuint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_u16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x2_t svreinterpret_s64(svint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_s32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x2_t svreinterpret_s64(svuint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_u32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x2_t svreinterpret_s64(svint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_s64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x2_t svreinterpret_s64(svuint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_u64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x2_t svreinterpret_s64(svfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_f16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x2_t svreinterpret_s64(svbfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_bf16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x2_t svreinterpret_s64(svfloat32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_f32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x2_t svreinterpret_s64(svfloat64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_f64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x2_t svreinterpret_u64(svint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_s8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x2_t svreinterpret_u64(svuint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_u8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x2_t svreinterpret_u64(svint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_s16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x2_t svreinterpret_u64(svuint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_u16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x2_t svreinterpret_u64(svint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_s32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x2_t svreinterpret_u64(svuint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_u32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x2_t svreinterpret_u64(svint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_s64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x2_t svreinterpret_u64(svuint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_u64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x2_t svreinterpret_u64(svfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_f16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x2_t svreinterpret_u64(svbfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_bf16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x2_t svreinterpret_u64(svfloat32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_f32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x2_t svreinterpret_u64(svfloat64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_f64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x2_t svreinterpret_f16(svint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_s8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x2_t svreinterpret_f16(svuint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_u8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x2_t svreinterpret_f16(svint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_s16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x2_t svreinterpret_f16(svuint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_u16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x2_t svreinterpret_f16(svint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_s32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x2_t svreinterpret_f16(svuint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_u32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x2_t svreinterpret_f16(svint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_s64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x2_t svreinterpret_f16(svuint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_u64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x2_t svreinterpret_f16(svfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_f16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x2_t svreinterpret_f16(svbfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_bf16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x2_t svreinterpret_f16(svfloat32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_f32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x2_t svreinterpret_f16(svfloat64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_f64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x2_t svreinterpret_bf16(svint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_s8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x2_t svreinterpret_bf16(svuint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_u8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x2_t svreinterpret_bf16(svint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_s16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x2_t svreinterpret_bf16(svuint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_u16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x2_t svreinterpret_bf16(svint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_s32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x2_t svreinterpret_bf16(svuint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_u32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x2_t svreinterpret_bf16(svint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_s64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x2_t svreinterpret_bf16(svuint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_u64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x2_t svreinterpret_bf16(svfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_f16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x2_t svreinterpret_bf16(svbfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_bf16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x2_t svreinterpret_bf16(svfloat32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_f32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x2_t svreinterpret_bf16(svfloat64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_f64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x2_t svreinterpret_f32(svint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_s8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x2_t svreinterpret_f32(svuint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_u8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x2_t svreinterpret_f32(svint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_s16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x2_t svreinterpret_f32(svuint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_u16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x2_t svreinterpret_f32(svint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_s32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x2_t svreinterpret_f32(svuint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_u32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x2_t svreinterpret_f32(svint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_s64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x2_t svreinterpret_f32(svuint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_u64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x2_t svreinterpret_f32(svfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_f16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x2_t svreinterpret_f32(svbfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_bf16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x2_t svreinterpret_f32(svfloat32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_f32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x2_t svreinterpret_f32(svfloat64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_f64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x2_t svreinterpret_f64(svint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_s8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x2_t svreinterpret_f64(svuint8x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_u8_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x2_t svreinterpret_f64(svint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_s16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x2_t svreinterpret_f64(svuint16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_u16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x2_t svreinterpret_f64(svint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_s32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x2_t svreinterpret_f64(svuint32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_u32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x2_t svreinterpret_f64(svint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_s64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x2_t svreinterpret_f64(svuint64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_u64_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x2_t svreinterpret_f64(svfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_f16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x2_t svreinterpret_f64(svbfloat16x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_bf16_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x2_t svreinterpret_f64(svfloat32x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_f32_x2(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x2_t svreinterpret_f64(svfloat64x2_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_f64_x2(op);
-}
-
-#define svreinterpret_s8_s8_x3(...) __builtin_sve_reinterpret_s8_s8_x3(__VA_ARGS__)
-#define svreinterpret_s8_u8_x3(...) __builtin_sve_reinterpret_s8_u8_x3(__VA_ARGS__)
-#define svreinterpret_s8_s16_x3(...) __builtin_sve_reinterpret_s8_s16_x3(__VA_ARGS__)
-#define svreinterpret_s8_u16_x3(...) __builtin_sve_reinterpret_s8_u16_x3(__VA_ARGS__)
-#define svreinterpret_s8_s32_x3(...) __builtin_sve_reinterpret_s8_s32_x3(__VA_ARGS__)
-#define svreinterpret_s8_u32_x3(...) __builtin_sve_reinterpret_s8_u32_x3(__VA_ARGS__)
-#define svreinterpret_s8_s64_x3(...) __builtin_sve_reinterpret_s8_s64_x3(__VA_ARGS__)
-#define svreinterpret_s8_u64_x3(...) __builtin_sve_reinterpret_s8_u64_x3(__VA_ARGS__)
-#define svreinterpret_s8_f16_x3(...) __builtin_sve_reinterpret_s8_f16_x3(__VA_ARGS__)
-#define svreinterpret_s8_bf16_x3(...) __builtin_sve_reinterpret_s8_bf16_x3(__VA_ARGS__)
-#define svreinterpret_s8_f32_x3(...) __builtin_sve_reinterpret_s8_f32_x3(__VA_ARGS__)
-#define svreinterpret_s8_f64_x3(...) __builtin_sve_reinterpret_s8_f64_x3(__VA_ARGS__)
-#define svreinterpret_u8_s8_x3(...) __builtin_sve_reinterpret_u8_s8_x3(__VA_ARGS__)
-#define svreinterpret_u8_u8_x3(...) __builtin_sve_reinterpret_u8_u8_x3(__VA_ARGS__)
-#define svreinterpret_u8_s16_x3(...) __builtin_sve_reinterpret_u8_s16_x3(__VA_ARGS__)
-#define svreinterpret_u8_u16_x3(...) __builtin_sve_reinterpret_u8_u16_x3(__VA_ARGS__)
-#define svreinterpret_u8_s32_x3(...) __builtin_sve_reinterpret_u8_s32_x3(__VA_ARGS__)
-#define svreinterpret_u8_u32_x3(...) __builtin_sve_reinterpret_u8_u32_x3(__VA_ARGS__)
-#define svreinterpret_u8_s64_x3(...) __builtin_sve_reinterpret_u8_s64_x3(__VA_ARGS__)
-#define svreinterpret_u8_u64_x3(...) __builtin_sve_reinterpret_u8_u64_x3(__VA_ARGS__)
-#define svreinterpret_u8_f16_x3(...) __builtin_sve_reinterpret_u8_f16_x3(__VA_ARGS__)
-#define svreinterpret_u8_bf16_x3(...) __builtin_sve_reinterpret_u8_bf16_x3(__VA_ARGS__)
-#define svreinterpret_u8_f32_x3(...) __builtin_sve_reinterpret_u8_f32_x3(__VA_ARGS__)
-#define svreinterpret_u8_f64_x3(...) __builtin_sve_reinterpret_u8_f64_x3(__VA_ARGS__)
-#define svreinterpret_s16_s8_x3(...) __builtin_sve_reinterpret_s16_s8_x3(__VA_ARGS__)
-#define svreinterpret_s16_u8_x3(...) __builtin_sve_reinterpret_s16_u8_x3(__VA_ARGS__)
-#define svreinterpret_s16_s16_x3(...) __builtin_sve_reinterpret_s16_s16_x3(__VA_ARGS__)
-#define svreinterpret_s16_u16_x3(...) __builtin_sve_reinterpret_s16_u16_x3(__VA_ARGS__)
-#define svreinterpret_s16_s32_x3(...) __builtin_sve_reinterpret_s16_s32_x3(__VA_ARGS__)
-#define svreinterpret_s16_u32_x3(...) __builtin_sve_reinterpret_s16_u32_x3(__VA_ARGS__)
-#define svreinterpret_s16_s64_x3(...) __builtin_sve_reinterpret_s16_s64_x3(__VA_ARGS__)
-#define svreinterpret_s16_u64_x3(...) __builtin_sve_reinterpret_s16_u64_x3(__VA_ARGS__)
-#define svreinterpret_s16_f16_x3(...) __builtin_sve_reinterpret_s16_f16_x3(__VA_ARGS__)
-#define svreinterpret_s16_bf16_x3(...) __builtin_sve_reinterpret_s16_bf16_x3(__VA_ARGS__)
-#define svreinterpret_s16_f32_x3(...) __builtin_sve_reinterpret_s16_f32_x3(__VA_ARGS__)
-#define svreinterpret_s16_f64_x3(...) __builtin_sve_reinterpret_s16_f64_x3(__VA_ARGS__)
-#define svreinterpret_u16_s8_x3(...) __builtin_sve_reinterpret_u16_s8_x3(__VA_ARGS__)
-#define svreinterpret_u16_u8_x3(...) __builtin_sve_reinterpret_u16_u8_x3(__VA_ARGS__)
-#define svreinterpret_u16_s16_x3(...) __builtin_sve_reinterpret_u16_s16_x3(__VA_ARGS__)
-#define svreinterpret_u16_u16_x3(...) __builtin_sve_reinterpret_u16_u16_x3(__VA_ARGS__)
-#define svreinterpret_u16_s32_x3(...) __builtin_sve_reinterpret_u16_s32_x3(__VA_ARGS__)
-#define svreinterpret_u16_u32_x3(...) __builtin_sve_reinterpret_u16_u32_x3(__VA_ARGS__)
-#define svreinterpret_u16_s64_x3(...) __builtin_sve_reinterpret_u16_s64_x3(__VA_ARGS__)
-#define svreinterpret_u16_u64_x3(...) __builtin_sve_reinterpret_u16_u64_x3(__VA_ARGS__)
-#define svreinterpret_u16_f16_x3(...) __builtin_sve_reinterpret_u16_f16_x3(__VA_ARGS__)
-#define svreinterpret_u16_bf16_x3(...) __builtin_sve_reinterpret_u16_bf16_x3(__VA_ARGS__)
-#define svreinterpret_u16_f32_x3(...) __builtin_sve_reinterpret_u16_f32_x3(__VA_ARGS__)
-#define svreinterpret_u16_f64_x3(...) __builtin_sve_reinterpret_u16_f64_x3(__VA_ARGS__)
-#define svreinterpret_s32_s8_x3(...) __builtin_sve_reinterpret_s32_s8_x3(__VA_ARGS__)
-#define svreinterpret_s32_u8_x3(...) __builtin_sve_reinterpret_s32_u8_x3(__VA_ARGS__)
-#define svreinterpret_s32_s16_x3(...) __builtin_sve_reinterpret_s32_s16_x3(__VA_ARGS__)
-#define svreinterpret_s32_u16_x3(...) __builtin_sve_reinterpret_s32_u16_x3(__VA_ARGS__)
-#define svreinterpret_s32_s32_x3(...) __builtin_sve_reinterpret_s32_s32_x3(__VA_ARGS__)
-#define svreinterpret_s32_u32_x3(...) __builtin_sve_reinterpret_s32_u32_x3(__VA_ARGS__)
-#define svreinterpret_s32_s64_x3(...) __builtin_sve_reinterpret_s32_s64_x3(__VA_ARGS__)
-#define svreinterpret_s32_u64_x3(...) __builtin_sve_reinterpret_s32_u64_x3(__VA_ARGS__)
-#define svreinterpret_s32_f16_x3(...) __builtin_sve_reinterpret_s32_f16_x3(__VA_ARGS__)
-#define svreinterpret_s32_bf16_x3(...) __builtin_sve_reinterpret_s32_bf16_x3(__VA_ARGS__)
-#define svreinterpret_s32_f32_x3(...) __builtin_sve_reinterpret_s32_f32_x3(__VA_ARGS__)
-#define svreinterpret_s32_f64_x3(...) __builtin_sve_reinterpret_s32_f64_x3(__VA_ARGS__)
-#define svreinterpret_u32_s8_x3(...) __builtin_sve_reinterpret_u32_s8_x3(__VA_ARGS__)
-#define svreinterpret_u32_u8_x3(...) __builtin_sve_reinterpret_u32_u8_x3(__VA_ARGS__)
-#define svreinterpret_u32_s16_x3(...) __builtin_sve_reinterpret_u32_s16_x3(__VA_ARGS__)
-#define svreinterpret_u32_u16_x3(...) __builtin_sve_reinterpret_u32_u16_x3(__VA_ARGS__)
-#define svreinterpret_u32_s32_x3(...) __builtin_sve_reinterpret_u32_s32_x3(__VA_ARGS__)
-#define svreinterpret_u32_u32_x3(...) __builtin_sve_reinterpret_u32_u32_x3(__VA_ARGS__)
-#define svreinterpret_u32_s64_x3(...) __builtin_sve_reinterpret_u32_s64_x3(__VA_ARGS__)
-#define svreinterpret_u32_u64_x3(...) __builtin_sve_reinterpret_u32_u64_x3(__VA_ARGS__)
-#define svreinterpret_u32_f16_x3(...) __builtin_sve_reinterpret_u32_f16_x3(__VA_ARGS__)
-#define svreinterpret_u32_bf16_x3(...) __builtin_sve_reinterpret_u32_bf16_x3(__VA_ARGS__)
-#define svreinterpret_u32_f32_x3(...) __builtin_sve_reinterpret_u32_f32_x3(__VA_ARGS__)
-#define svreinterpret_u32_f64_x3(...) __builtin_sve_reinterpret_u32_f64_x3(__VA_ARGS__)
-#define svreinterpret_s64_s8_x3(...) __builtin_sve_reinterpret_s64_s8_x3(__VA_ARGS__)
-#define svreinterpret_s64_u8_x3(...) __builtin_sve_reinterpret_s64_u8_x3(__VA_ARGS__)
-#define svreinterpret_s64_s16_x3(...) __builtin_sve_reinterpret_s64_s16_x3(__VA_ARGS__)
-#define svreinterpret_s64_u16_x3(...) __builtin_sve_reinterpret_s64_u16_x3(__VA_ARGS__)
-#define svreinterpret_s64_s32_x3(...) __builtin_sve_reinterpret_s64_s32_x3(__VA_ARGS__)
-#define svreinterpret_s64_u32_x3(...) __builtin_sve_reinterpret_s64_u32_x3(__VA_ARGS__)
-#define svreinterpret_s64_s64_x3(...) __builtin_sve_reinterpret_s64_s64_x3(__VA_ARGS__)
-#define svreinterpret_s64_u64_x3(...) __builtin_sve_reinterpret_s64_u64_x3(__VA_ARGS__)
-#define svreinterpret_s64_f16_x3(...) __builtin_sve_reinterpret_s64_f16_x3(__VA_ARGS__)
-#define svreinterpret_s64_bf16_x3(...) __builtin_sve_reinterpret_s64_bf16_x3(__VA_ARGS__)
-#define svreinterpret_s64_f32_x3(...) __builtin_sve_reinterpret_s64_f32_x3(__VA_ARGS__)
-#define svreinterpret_s64_f64_x3(...) __builtin_sve_reinterpret_s64_f64_x3(__VA_ARGS__)
-#define svreinterpret_u64_s8_x3(...) __builtin_sve_reinterpret_u64_s8_x3(__VA_ARGS__)
-#define svreinterpret_u64_u8_x3(...) __builtin_sve_reinterpret_u64_u8_x3(__VA_ARGS__)
-#define svreinterpret_u64_s16_x3(...) __builtin_sve_reinterpret_u64_s16_x3(__VA_ARGS__)
-#define svreinterpret_u64_u16_x3(...) __builtin_sve_reinterpret_u64_u16_x3(__VA_ARGS__)
-#define svreinterpret_u64_s32_x3(...) __builtin_sve_reinterpret_u64_s32_x3(__VA_ARGS__)
-#define svreinterpret_u64_u32_x3(...) __builtin_sve_reinterpret_u64_u32_x3(__VA_ARGS__)
-#define svreinterpret_u64_s64_x3(...) __builtin_sve_reinterpret_u64_s64_x3(__VA_ARGS__)
-#define svreinterpret_u64_u64_x3(...) __builtin_sve_reinterpret_u64_u64_x3(__VA_ARGS__)
-#define svreinterpret_u64_f16_x3(...) __builtin_sve_reinterpret_u64_f16_x3(__VA_ARGS__)
-#define svreinterpret_u64_bf16_x3(...) __builtin_sve_reinterpret_u64_bf16_x3(__VA_ARGS__)
-#define svreinterpret_u64_f32_x3(...) __builtin_sve_reinterpret_u64_f32_x3(__VA_ARGS__)
-#define svreinterpret_u64_f64_x3(...) __builtin_sve_reinterpret_u64_f64_x3(__VA_ARGS__)
-#define svreinterpret_f16_s8_x3(...) __builtin_sve_reinterpret_f16_s8_x3(__VA_ARGS__)
-#define svreinterpret_f16_u8_x3(...) __builtin_sve_reinterpret_f16_u8_x3(__VA_ARGS__)
-#define svreinterpret_f16_s16_x3(...) __builtin_sve_reinterpret_f16_s16_x3(__VA_ARGS__)
-#define svreinterpret_f16_u16_x3(...) __builtin_sve_reinterpret_f16_u16_x3(__VA_ARGS__)
-#define svreinterpret_f16_s32_x3(...) __builtin_sve_reinterpret_f16_s32_x3(__VA_ARGS__)
-#define svreinterpret_f16_u32_x3(...) __builtin_sve_reinterpret_f16_u32_x3(__VA_ARGS__)
-#define svreinterpret_f16_s64_x3(...) __builtin_sve_reinterpret_f16_s64_x3(__VA_ARGS__)
-#define svreinterpret_f16_u64_x3(...) __builtin_sve_reinterpret_f16_u64_x3(__VA_ARGS__)
-#define svreinterpret_f16_f16_x3(...) __builtin_sve_reinterpret_f16_f16_x3(__VA_ARGS__)
-#define svreinterpret_f16_bf16_x3(...) __builtin_sve_reinterpret_f16_bf16_x3(__VA_ARGS__)
-#define svreinterpret_f16_f32_x3(...) __builtin_sve_reinterpret_f16_f32_x3(__VA_ARGS__)
-#define svreinterpret_f16_f64_x3(...) __builtin_sve_reinterpret_f16_f64_x3(__VA_ARGS__)
-#define svreinterpret_bf16_s8_x3(...) __builtin_sve_reinterpret_bf16_s8_x3(__VA_ARGS__)
-#define svreinterpret_bf16_u8_x3(...) __builtin_sve_reinterpret_bf16_u8_x3(__VA_ARGS__)
-#define svreinterpret_bf16_s16_x3(...) __builtin_sve_reinterpret_bf16_s16_x3(__VA_ARGS__)
-#define svreinterpret_bf16_u16_x3(...) __builtin_sve_reinterpret_bf16_u16_x3(__VA_ARGS__)
-#define svreinterpret_bf16_s32_x3(...) __builtin_sve_reinterpret_bf16_s32_x3(__VA_ARGS__)
-#define svreinterpret_bf16_u32_x3(...) __builtin_sve_reinterpret_bf16_u32_x3(__VA_ARGS__)
-#define svreinterpret_bf16_s64_x3(...) __builtin_sve_reinterpret_bf16_s64_x3(__VA_ARGS__)
-#define svreinterpret_bf16_u64_x3(...) __builtin_sve_reinterpret_bf16_u64_x3(__VA_ARGS__)
-#define svreinterpret_bf16_f16_x3(...) __builtin_sve_reinterpret_bf16_f16_x3(__VA_ARGS__)
-#define svreinterpret_bf16_bf16_x3(...) __builtin_sve_reinterpret_bf16_bf16_x3(__VA_ARGS__)
-#define svreinterpret_bf16_f32_x3(...) __builtin_sve_reinterpret_bf16_f32_x3(__VA_ARGS__)
-#define svreinterpret_bf16_f64_x3(...) __builtin_sve_reinterpret_bf16_f64_x3(__VA_ARGS__)
-#define svreinterpret_f32_s8_x3(...) __builtin_sve_reinterpret_f32_s8_x3(__VA_ARGS__)
-#define svreinterpret_f32_u8_x3(...) __builtin_sve_reinterpret_f32_u8_x3(__VA_ARGS__)
-#define svreinterpret_f32_s16_x3(...) __builtin_sve_reinterpret_f32_s16_x3(__VA_ARGS__)
-#define svreinterpret_f32_u16_x3(...) __builtin_sve_reinterpret_f32_u16_x3(__VA_ARGS__)
-#define svreinterpret_f32_s32_x3(...) __builtin_sve_reinterpret_f32_s32_x3(__VA_ARGS__)
-#define svreinterpret_f32_u32_x3(...) __builtin_sve_reinterpret_f32_u32_x3(__VA_ARGS__)
-#define svreinterpret_f32_s64_x3(...) __builtin_sve_reinterpret_f32_s64_x3(__VA_ARGS__)
-#define svreinterpret_f32_u64_x3(...) __builtin_sve_reinterpret_f32_u64_x3(__VA_ARGS__)
-#define svreinterpret_f32_f16_x3(...) __builtin_sve_reinterpret_f32_f16_x3(__VA_ARGS__)
-#define svreinterpret_f32_bf16_x3(...) __builtin_sve_reinterpret_f32_bf16_x3(__VA_ARGS__)
-#define svreinterpret_f32_f32_x3(...) __builtin_sve_reinterpret_f32_f32_x3(__VA_ARGS__)
-#define svreinterpret_f32_f64_x3(...) __builtin_sve_reinterpret_f32_f64_x3(__VA_ARGS__)
-#define svreinterpret_f64_s8_x3(...) __builtin_sve_reinterpret_f64_s8_x3(__VA_ARGS__)
-#define svreinterpret_f64_u8_x3(...) __builtin_sve_reinterpret_f64_u8_x3(__VA_ARGS__)
-#define svreinterpret_f64_s16_x3(...) __builtin_sve_reinterpret_f64_s16_x3(__VA_ARGS__)
-#define svreinterpret_f64_u16_x3(...) __builtin_sve_reinterpret_f64_u16_x3(__VA_ARGS__)
-#define svreinterpret_f64_s32_x3(...) __builtin_sve_reinterpret_f64_s32_x3(__VA_ARGS__)
-#define svreinterpret_f64_u32_x3(...) __builtin_sve_reinterpret_f64_u32_x3(__VA_ARGS__)
-#define svreinterpret_f64_s64_x3(...) __builtin_sve_reinterpret_f64_s64_x3(__VA_ARGS__)
-#define svreinterpret_f64_u64_x3(...) __builtin_sve_reinterpret_f64_u64_x3(__VA_ARGS__)
-#define svreinterpret_f64_f16_x3(...) __builtin_sve_reinterpret_f64_f16_x3(__VA_ARGS__)
-#define svreinterpret_f64_bf16_x3(...) __builtin_sve_reinterpret_f64_bf16_x3(__VA_ARGS__)
-#define svreinterpret_f64_f32_x3(...) __builtin_sve_reinterpret_f64_f32_x3(__VA_ARGS__)
-#define svreinterpret_f64_f64_x3(...) __builtin_sve_reinterpret_f64_f64_x3(__VA_ARGS__)
-__aio __attribute__((target("sve"))) svint8x3_t svreinterpret_s8(svint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_s8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x3_t svreinterpret_s8(svuint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_u8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x3_t svreinterpret_s8(svint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_s16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x3_t svreinterpret_s8(svuint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_u16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x3_t svreinterpret_s8(svint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_s32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x3_t svreinterpret_s8(svuint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_u32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x3_t svreinterpret_s8(svint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_s64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x3_t svreinterpret_s8(svuint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_u64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x3_t svreinterpret_s8(svfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_f16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x3_t svreinterpret_s8(svbfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_bf16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x3_t svreinterpret_s8(svfloat32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_f32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x3_t svreinterpret_s8(svfloat64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_f64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x3_t svreinterpret_u8(svint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_s8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x3_t svreinterpret_u8(svuint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_u8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x3_t svreinterpret_u8(svint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_s16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x3_t svreinterpret_u8(svuint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_u16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x3_t svreinterpret_u8(svint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_s32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x3_t svreinterpret_u8(svuint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_u32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x3_t svreinterpret_u8(svint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_s64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x3_t svreinterpret_u8(svuint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_u64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x3_t svreinterpret_u8(svfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_f16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x3_t svreinterpret_u8(svbfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_bf16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x3_t svreinterpret_u8(svfloat32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_f32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x3_t svreinterpret_u8(svfloat64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_f64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x3_t svreinterpret_s16(svint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_s8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x3_t svreinterpret_s16(svuint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_u8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x3_t svreinterpret_s16(svint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_s16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x3_t svreinterpret_s16(svuint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_u16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x3_t svreinterpret_s16(svint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_s32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x3_t svreinterpret_s16(svuint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_u32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x3_t svreinterpret_s16(svint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_s64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x3_t svreinterpret_s16(svuint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_u64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x3_t svreinterpret_s16(svfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_f16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x3_t svreinterpret_s16(svbfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_bf16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x3_t svreinterpret_s16(svfloat32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_f32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x3_t svreinterpret_s16(svfloat64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_f64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x3_t svreinterpret_u16(svint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_s8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x3_t svreinterpret_u16(svuint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_u8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x3_t svreinterpret_u16(svint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_s16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x3_t svreinterpret_u16(svuint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_u16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x3_t svreinterpret_u16(svint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_s32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x3_t svreinterpret_u16(svuint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_u32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x3_t svreinterpret_u16(svint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_s64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x3_t svreinterpret_u16(svuint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_u64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x3_t svreinterpret_u16(svfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_f16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x3_t svreinterpret_u16(svbfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_bf16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x3_t svreinterpret_u16(svfloat32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_f32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x3_t svreinterpret_u16(svfloat64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_f64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x3_t svreinterpret_s32(svint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_s8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x3_t svreinterpret_s32(svuint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_u8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x3_t svreinterpret_s32(svint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_s16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x3_t svreinterpret_s32(svuint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_u16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x3_t svreinterpret_s32(svint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_s32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x3_t svreinterpret_s32(svuint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_u32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x3_t svreinterpret_s32(svint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_s64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x3_t svreinterpret_s32(svuint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_u64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x3_t svreinterpret_s32(svfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_f16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x3_t svreinterpret_s32(svbfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_bf16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x3_t svreinterpret_s32(svfloat32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_f32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x3_t svreinterpret_s32(svfloat64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_f64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x3_t svreinterpret_u32(svint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_s8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x3_t svreinterpret_u32(svuint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_u8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x3_t svreinterpret_u32(svint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_s16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x3_t svreinterpret_u32(svuint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_u16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x3_t svreinterpret_u32(svint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_s32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x3_t svreinterpret_u32(svuint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_u32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x3_t svreinterpret_u32(svint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_s64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x3_t svreinterpret_u32(svuint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_u64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x3_t svreinterpret_u32(svfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_f16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x3_t svreinterpret_u32(svbfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_bf16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x3_t svreinterpret_u32(svfloat32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_f32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x3_t svreinterpret_u32(svfloat64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_f64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x3_t svreinterpret_s64(svint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_s8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x3_t svreinterpret_s64(svuint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_u8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x3_t svreinterpret_s64(svint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_s16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x3_t svreinterpret_s64(svuint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_u16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x3_t svreinterpret_s64(svint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_s32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x3_t svreinterpret_s64(svuint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_u32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x3_t svreinterpret_s64(svint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_s64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x3_t svreinterpret_s64(svuint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_u64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x3_t svreinterpret_s64(svfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_f16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x3_t svreinterpret_s64(svbfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_bf16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x3_t svreinterpret_s64(svfloat32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_f32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x3_t svreinterpret_s64(svfloat64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_f64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x3_t svreinterpret_u64(svint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_s8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x3_t svreinterpret_u64(svuint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_u8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x3_t svreinterpret_u64(svint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_s16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x3_t svreinterpret_u64(svuint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_u16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x3_t svreinterpret_u64(svint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_s32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x3_t svreinterpret_u64(svuint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_u32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x3_t svreinterpret_u64(svint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_s64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x3_t svreinterpret_u64(svuint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_u64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x3_t svreinterpret_u64(svfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_f16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x3_t svreinterpret_u64(svbfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_bf16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x3_t svreinterpret_u64(svfloat32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_f32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x3_t svreinterpret_u64(svfloat64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_f64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x3_t svreinterpret_f16(svint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_s8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x3_t svreinterpret_f16(svuint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_u8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x3_t svreinterpret_f16(svint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_s16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x3_t svreinterpret_f16(svuint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_u16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x3_t svreinterpret_f16(svint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_s32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x3_t svreinterpret_f16(svuint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_u32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x3_t svreinterpret_f16(svint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_s64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x3_t svreinterpret_f16(svuint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_u64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x3_t svreinterpret_f16(svfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_f16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x3_t svreinterpret_f16(svbfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_bf16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x3_t svreinterpret_f16(svfloat32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_f32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x3_t svreinterpret_f16(svfloat64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_f64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x3_t svreinterpret_bf16(svint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_s8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x3_t svreinterpret_bf16(svuint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_u8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x3_t svreinterpret_bf16(svint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_s16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x3_t svreinterpret_bf16(svuint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_u16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x3_t svreinterpret_bf16(svint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_s32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x3_t svreinterpret_bf16(svuint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_u32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x3_t svreinterpret_bf16(svint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_s64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x3_t svreinterpret_bf16(svuint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_u64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x3_t svreinterpret_bf16(svfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_f16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x3_t svreinterpret_bf16(svbfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_bf16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x3_t svreinterpret_bf16(svfloat32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_f32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x3_t svreinterpret_bf16(svfloat64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_f64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x3_t svreinterpret_f32(svint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_s8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x3_t svreinterpret_f32(svuint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_u8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x3_t svreinterpret_f32(svint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_s16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x3_t svreinterpret_f32(svuint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_u16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x3_t svreinterpret_f32(svint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_s32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x3_t svreinterpret_f32(svuint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_u32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x3_t svreinterpret_f32(svint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_s64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x3_t svreinterpret_f32(svuint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_u64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x3_t svreinterpret_f32(svfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_f16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x3_t svreinterpret_f32(svbfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_bf16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x3_t svreinterpret_f32(svfloat32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_f32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x3_t svreinterpret_f32(svfloat64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_f64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x3_t svreinterpret_f64(svint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_s8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x3_t svreinterpret_f64(svuint8x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_u8_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x3_t svreinterpret_f64(svint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_s16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x3_t svreinterpret_f64(svuint16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_u16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x3_t svreinterpret_f64(svint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_s32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x3_t svreinterpret_f64(svuint32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_u32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x3_t svreinterpret_f64(svint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_s64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x3_t svreinterpret_f64(svuint64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_u64_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x3_t svreinterpret_f64(svfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_f16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x3_t svreinterpret_f64(svbfloat16x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_bf16_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x3_t svreinterpret_f64(svfloat32x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_f32_x3(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x3_t svreinterpret_f64(svfloat64x3_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_f64_x3(op);
-}
-
-#define svreinterpret_s8_s8_x4(...) __builtin_sve_reinterpret_s8_s8_x4(__VA_ARGS__)
-#define svreinterpret_s8_u8_x4(...) __builtin_sve_reinterpret_s8_u8_x4(__VA_ARGS__)
-#define svreinterpret_s8_s16_x4(...) __builtin_sve_reinterpret_s8_s16_x4(__VA_ARGS__)
-#define svreinterpret_s8_u16_x4(...) __builtin_sve_reinterpret_s8_u16_x4(__VA_ARGS__)
-#define svreinterpret_s8_s32_x4(...) __builtin_sve_reinterpret_s8_s32_x4(__VA_ARGS__)
-#define svreinterpret_s8_u32_x4(...) __builtin_sve_reinterpret_s8_u32_x4(__VA_ARGS__)
-#define svreinterpret_s8_s64_x4(...) __builtin_sve_reinterpret_s8_s64_x4(__VA_ARGS__)
-#define svreinterpret_s8_u64_x4(...) __builtin_sve_reinterpret_s8_u64_x4(__VA_ARGS__)
-#define svreinterpret_s8_f16_x4(...) __builtin_sve_reinterpret_s8_f16_x4(__VA_ARGS__)
-#define svreinterpret_s8_bf16_x4(...) __builtin_sve_reinterpret_s8_bf16_x4(__VA_ARGS__)
-#define svreinterpret_s8_f32_x4(...) __builtin_sve_reinterpret_s8_f32_x4(__VA_ARGS__)
-#define svreinterpret_s8_f64_x4(...) __builtin_sve_reinterpret_s8_f64_x4(__VA_ARGS__)
-#define svreinterpret_u8_s8_x4(...) __builtin_sve_reinterpret_u8_s8_x4(__VA_ARGS__)
-#define svreinterpret_u8_u8_x4(...) __builtin_sve_reinterpret_u8_u8_x4(__VA_ARGS__)
-#define svreinterpret_u8_s16_x4(...) __builtin_sve_reinterpret_u8_s16_x4(__VA_ARGS__)
-#define svreinterpret_u8_u16_x4(...) __builtin_sve_reinterpret_u8_u16_x4(__VA_ARGS__)
-#define svreinterpret_u8_s32_x4(...) __builtin_sve_reinterpret_u8_s32_x4(__VA_ARGS__)
-#define svreinterpret_u8_u32_x4(...) __builtin_sve_reinterpret_u8_u32_x4(__VA_ARGS__)
-#define svreinterpret_u8_s64_x4(...) __builtin_sve_reinterpret_u8_s64_x4(__VA_ARGS__)
-#define svreinterpret_u8_u64_x4(...) __builtin_sve_reinterpret_u8_u64_x4(__VA_ARGS__)
-#define svreinterpret_u8_f16_x4(...) __builtin_sve_reinterpret_u8_f16_x4(__VA_ARGS__)
-#define svreinterpret_u8_bf16_x4(...) __builtin_sve_reinterpret_u8_bf16_x4(__VA_ARGS__)
-#define svreinterpret_u8_f32_x4(...) __builtin_sve_reinterpret_u8_f32_x4(__VA_ARGS__)
-#define svreinterpret_u8_f64_x4(...) __builtin_sve_reinterpret_u8_f64_x4(__VA_ARGS__)
-#define svreinterpret_s16_s8_x4(...) __builtin_sve_reinterpret_s16_s8_x4(__VA_ARGS__)
-#define svreinterpret_s16_u8_x4(...) __builtin_sve_reinterpret_s16_u8_x4(__VA_ARGS__)
-#define svreinterpret_s16_s16_x4(...) __builtin_sve_reinterpret_s16_s16_x4(__VA_ARGS__)
-#define svreinterpret_s16_u16_x4(...) __builtin_sve_reinterpret_s16_u16_x4(__VA_ARGS__)
-#define svreinterpret_s16_s32_x4(...) __builtin_sve_reinterpret_s16_s32_x4(__VA_ARGS__)
-#define svreinterpret_s16_u32_x4(...) __builtin_sve_reinterpret_s16_u32_x4(__VA_ARGS__)
-#define svreinterpret_s16_s64_x4(...) __builtin_sve_reinterpret_s16_s64_x4(__VA_ARGS__)
-#define svreinterpret_s16_u64_x4(...) __builtin_sve_reinterpret_s16_u64_x4(__VA_ARGS__)
-#define svreinterpret_s16_f16_x4(...) __builtin_sve_reinterpret_s16_f16_x4(__VA_ARGS__)
-#define svreinterpret_s16_bf16_x4(...) __builtin_sve_reinterpret_s16_bf16_x4(__VA_ARGS__)
-#define svreinterpret_s16_f32_x4(...) __builtin_sve_reinterpret_s16_f32_x4(__VA_ARGS__)
-#define svreinterpret_s16_f64_x4(...) __builtin_sve_reinterpret_s16_f64_x4(__VA_ARGS__)
-#define svreinterpret_u16_s8_x4(...) __builtin_sve_reinterpret_u16_s8_x4(__VA_ARGS__)
-#define svreinterpret_u16_u8_x4(...) __builtin_sve_reinterpret_u16_u8_x4(__VA_ARGS__)
-#define svreinterpret_u16_s16_x4(...) __builtin_sve_reinterpret_u16_s16_x4(__VA_ARGS__)
-#define svreinterpret_u16_u16_x4(...) __builtin_sve_reinterpret_u16_u16_x4(__VA_ARGS__)
-#define svreinterpret_u16_s32_x4(...) __builtin_sve_reinterpret_u16_s32_x4(__VA_ARGS__)
-#define svreinterpret_u16_u32_x4(...) __builtin_sve_reinterpret_u16_u32_x4(__VA_ARGS__)
-#define svreinterpret_u16_s64_x4(...) __builtin_sve_reinterpret_u16_s64_x4(__VA_ARGS__)
-#define svreinterpret_u16_u64_x4(...) __builtin_sve_reinterpret_u16_u64_x4(__VA_ARGS__)
-#define svreinterpret_u16_f16_x4(...) __builtin_sve_reinterpret_u16_f16_x4(__VA_ARGS__)
-#define svreinterpret_u16_bf16_x4(...) __builtin_sve_reinterpret_u16_bf16_x4(__VA_ARGS__)
-#define svreinterpret_u16_f32_x4(...) __builtin_sve_reinterpret_u16_f32_x4(__VA_ARGS__)
-#define svreinterpret_u16_f64_x4(...) __builtin_sve_reinterpret_u16_f64_x4(__VA_ARGS__)
-#define svreinterpret_s32_s8_x4(...) __builtin_sve_reinterpret_s32_s8_x4(__VA_ARGS__)
-#define svreinterpret_s32_u8_x4(...) __builtin_sve_reinterpret_s32_u8_x4(__VA_ARGS__)
-#define svreinterpret_s32_s16_x4(...) __builtin_sve_reinterpret_s32_s16_x4(__VA_ARGS__)
-#define svreinterpret_s32_u16_x4(...) __builtin_sve_reinterpret_s32_u16_x4(__VA_ARGS__)
-#define svreinterpret_s32_s32_x4(...) __builtin_sve_reinterpret_s32_s32_x4(__VA_ARGS__)
-#define svreinterpret_s32_u32_x4(...) __builtin_sve_reinterpret_s32_u32_x4(__VA_ARGS__)
-#define svreinterpret_s32_s64_x4(...) __builtin_sve_reinterpret_s32_s64_x4(__VA_ARGS__)
-#define svreinterpret_s32_u64_x4(...) __builtin_sve_reinterpret_s32_u64_x4(__VA_ARGS__)
-#define svreinterpret_s32_f16_x4(...) __builtin_sve_reinterpret_s32_f16_x4(__VA_ARGS__)
-#define svreinterpret_s32_bf16_x4(...) __builtin_sve_reinterpret_s32_bf16_x4(__VA_ARGS__)
-#define svreinterpret_s32_f32_x4(...) __builtin_sve_reinterpret_s32_f32_x4(__VA_ARGS__)
-#define svreinterpret_s32_f64_x4(...) __builtin_sve_reinterpret_s32_f64_x4(__VA_ARGS__)
-#define svreinterpret_u32_s8_x4(...) __builtin_sve_reinterpret_u32_s8_x4(__VA_ARGS__)
-#define svreinterpret_u32_u8_x4(...) __builtin_sve_reinterpret_u32_u8_x4(__VA_ARGS__)
-#define svreinterpret_u32_s16_x4(...) __builtin_sve_reinterpret_u32_s16_x4(__VA_ARGS__)
-#define svreinterpret_u32_u16_x4(...) __builtin_sve_reinterpret_u32_u16_x4(__VA_ARGS__)
-#define svreinterpret_u32_s32_x4(...) __builtin_sve_reinterpret_u32_s32_x4(__VA_ARGS__)
-#define svreinterpret_u32_u32_x4(...) __builtin_sve_reinterpret_u32_u32_x4(__VA_ARGS__)
-#define svreinterpret_u32_s64_x4(...) __builtin_sve_reinterpret_u32_s64_x4(__VA_ARGS__)
-#define svreinterpret_u32_u64_x4(...) __builtin_sve_reinterpret_u32_u64_x4(__VA_ARGS__)
-#define svreinterpret_u32_f16_x4(...) __builtin_sve_reinterpret_u32_f16_x4(__VA_ARGS__)
-#define svreinterpret_u32_bf16_x4(...) __builtin_sve_reinterpret_u32_bf16_x4(__VA_ARGS__)
-#define svreinterpret_u32_f32_x4(...) __builtin_sve_reinterpret_u32_f32_x4(__VA_ARGS__)
-#define svreinterpret_u32_f64_x4(...) __builtin_sve_reinterpret_u32_f64_x4(__VA_ARGS__)
-#define svreinterpret_s64_s8_x4(...) __builtin_sve_reinterpret_s64_s8_x4(__VA_ARGS__)
-#define svreinterpret_s64_u8_x4(...) __builtin_sve_reinterpret_s64_u8_x4(__VA_ARGS__)
-#define svreinterpret_s64_s16_x4(...) __builtin_sve_reinterpret_s64_s16_x4(__VA_ARGS__)
-#define svreinterpret_s64_u16_x4(...) __builtin_sve_reinterpret_s64_u16_x4(__VA_ARGS__)
-#define svreinterpret_s64_s32_x4(...) __builtin_sve_reinterpret_s64_s32_x4(__VA_ARGS__)
-#define svreinterpret_s64_u32_x4(...) __builtin_sve_reinterpret_s64_u32_x4(__VA_ARGS__)
-#define svreinterpret_s64_s64_x4(...) __builtin_sve_reinterpret_s64_s64_x4(__VA_ARGS__)
-#define svreinterpret_s64_u64_x4(...) __builtin_sve_reinterpret_s64_u64_x4(__VA_ARGS__)
-#define svreinterpret_s64_f16_x4(...) __builtin_sve_reinterpret_s64_f16_x4(__VA_ARGS__)
-#define svreinterpret_s64_bf16_x4(...) __builtin_sve_reinterpret_s64_bf16_x4(__VA_ARGS__)
-#define svreinterpret_s64_f32_x4(...) __builtin_sve_reinterpret_s64_f32_x4(__VA_ARGS__)
-#define svreinterpret_s64_f64_x4(...) __builtin_sve_reinterpret_s64_f64_x4(__VA_ARGS__)
-#define svreinterpret_u64_s8_x4(...) __builtin_sve_reinterpret_u64_s8_x4(__VA_ARGS__)
-#define svreinterpret_u64_u8_x4(...) __builtin_sve_reinterpret_u64_u8_x4(__VA_ARGS__)
-#define svreinterpret_u64_s16_x4(...) __builtin_sve_reinterpret_u64_s16_x4(__VA_ARGS__)
-#define svreinterpret_u64_u16_x4(...) __builtin_sve_reinterpret_u64_u16_x4(__VA_ARGS__)
-#define svreinterpret_u64_s32_x4(...) __builtin_sve_reinterpret_u64_s32_x4(__VA_ARGS__)
-#define svreinterpret_u64_u32_x4(...) __builtin_sve_reinterpret_u64_u32_x4(__VA_ARGS__)
-#define svreinterpret_u64_s64_x4(...) __builtin_sve_reinterpret_u64_s64_x4(__VA_ARGS__)
-#define svreinterpret_u64_u64_x4(...) __builtin_sve_reinterpret_u64_u64_x4(__VA_ARGS__)
-#define svreinterpret_u64_f16_x4(...) __builtin_sve_reinterpret_u64_f16_x4(__VA_ARGS__)
-#define svreinterpret_u64_bf16_x4(...) __builtin_sve_reinterpret_u64_bf16_x4(__VA_ARGS__)
-#define svreinterpret_u64_f32_x4(...) __builtin_sve_reinterpret_u64_f32_x4(__VA_ARGS__)
-#define svreinterpret_u64_f64_x4(...) __builtin_sve_reinterpret_u64_f64_x4(__VA_ARGS__)
-#define svreinterpret_f16_s8_x4(...) __builtin_sve_reinterpret_f16_s8_x4(__VA_ARGS__)
-#define svreinterpret_f16_u8_x4(...) __builtin_sve_reinterpret_f16_u8_x4(__VA_ARGS__)
-#define svreinterpret_f16_s16_x4(...) __builtin_sve_reinterpret_f16_s16_x4(__VA_ARGS__)
-#define svreinterpret_f16_u16_x4(...) __builtin_sve_reinterpret_f16_u16_x4(__VA_ARGS__)
-#define svreinterpret_f16_s32_x4(...) __builtin_sve_reinterpret_f16_s32_x4(__VA_ARGS__)
-#define svreinterpret_f16_u32_x4(...) __builtin_sve_reinterpret_f16_u32_x4(__VA_ARGS__)
-#define svreinterpret_f16_s64_x4(...) __builtin_sve_reinterpret_f16_s64_x4(__VA_ARGS__)
-#define svreinterpret_f16_u64_x4(...) __builtin_sve_reinterpret_f16_u64_x4(__VA_ARGS__)
-#define svreinterpret_f16_f16_x4(...) __builtin_sve_reinterpret_f16_f16_x4(__VA_ARGS__)
-#define svreinterpret_f16_bf16_x4(...) __builtin_sve_reinterpret_f16_bf16_x4(__VA_ARGS__)
-#define svreinterpret_f16_f32_x4(...) __builtin_sve_reinterpret_f16_f32_x4(__VA_ARGS__)
-#define svreinterpret_f16_f64_x4(...) __builtin_sve_reinterpret_f16_f64_x4(__VA_ARGS__)
-#define svreinterpret_bf16_s8_x4(...) __builtin_sve_reinterpret_bf16_s8_x4(__VA_ARGS__)
-#define svreinterpret_bf16_u8_x4(...) __builtin_sve_reinterpret_bf16_u8_x4(__VA_ARGS__)
-#define svreinterpret_bf16_s16_x4(...) __builtin_sve_reinterpret_bf16_s16_x4(__VA_ARGS__)
-#define svreinterpret_bf16_u16_x4(...) __builtin_sve_reinterpret_bf16_u16_x4(__VA_ARGS__)
-#define svreinterpret_bf16_s32_x4(...) __builtin_sve_reinterpret_bf16_s32_x4(__VA_ARGS__)
-#define svreinterpret_bf16_u32_x4(...) __builtin_sve_reinterpret_bf16_u32_x4(__VA_ARGS__)
-#define svreinterpret_bf16_s64_x4(...) __builtin_sve_reinterpret_bf16_s64_x4(__VA_ARGS__)
-#define svreinterpret_bf16_u64_x4(...) __builtin_sve_reinterpret_bf16_u64_x4(__VA_ARGS__)
-#define svreinterpret_bf16_f16_x4(...) __builtin_sve_reinterpret_bf16_f16_x4(__VA_ARGS__)
-#define svreinterpret_bf16_bf16_x4(...) __builtin_sve_reinterpret_bf16_bf16_x4(__VA_ARGS__)
-#define svreinterpret_bf16_f32_x4(...) __builtin_sve_reinterpret_bf16_f32_x4(__VA_ARGS__)
-#define svreinterpret_bf16_f64_x4(...) __builtin_sve_reinterpret_bf16_f64_x4(__VA_ARGS__)
-#define svreinterpret_f32_s8_x4(...) __builtin_sve_reinterpret_f32_s8_x4(__VA_ARGS__)
-#define svreinterpret_f32_u8_x4(...) __builtin_sve_reinterpret_f32_u8_x4(__VA_ARGS__)
-#define svreinterpret_f32_s16_x4(...) __builtin_sve_reinterpret_f32_s16_x4(__VA_ARGS__)
-#define svreinterpret_f32_u16_x4(...) __builtin_sve_reinterpret_f32_u16_x4(__VA_ARGS__)
-#define svreinterpret_f32_s32_x4(...) __builtin_sve_reinterpret_f32_s32_x4(__VA_ARGS__)
-#define svreinterpret_f32_u32_x4(...) __builtin_sve_reinterpret_f32_u32_x4(__VA_ARGS__)
-#define svreinterpret_f32_s64_x4(...) __builtin_sve_reinterpret_f32_s64_x4(__VA_ARGS__)
-#define svreinterpret_f32_u64_x4(...) __builtin_sve_reinterpret_f32_u64_x4(__VA_ARGS__)
-#define svreinterpret_f32_f16_x4(...) __builtin_sve_reinterpret_f32_f16_x4(__VA_ARGS__)
-#define svreinterpret_f32_bf16_x4(...) __builtin_sve_reinterpret_f32_bf16_x4(__VA_ARGS__)
-#define svreinterpret_f32_f32_x4(...) __builtin_sve_reinterpret_f32_f32_x4(__VA_ARGS__)
-#define svreinterpret_f32_f64_x4(...) __builtin_sve_reinterpret_f32_f64_x4(__VA_ARGS__)
-#define svreinterpret_f64_s8_x4(...) __builtin_sve_reinterpret_f64_s8_x4(__VA_ARGS__)
-#define svreinterpret_f64_u8_x4(...) __builtin_sve_reinterpret_f64_u8_x4(__VA_ARGS__)
-#define svreinterpret_f64_s16_x4(...) __builtin_sve_reinterpret_f64_s16_x4(__VA_ARGS__)
-#define svreinterpret_f64_u16_x4(...) __builtin_sve_reinterpret_f64_u16_x4(__VA_ARGS__)
-#define svreinterpret_f64_s32_x4(...) __builtin_sve_reinterpret_f64_s32_x4(__VA_ARGS__)
-#define svreinterpret_f64_u32_x4(...) __builtin_sve_reinterpret_f64_u32_x4(__VA_ARGS__)
-#define svreinterpret_f64_s64_x4(...) __builtin_sve_reinterpret_f64_s64_x4(__VA_ARGS__)
-#define svreinterpret_f64_u64_x4(...) __builtin_sve_reinterpret_f64_u64_x4(__VA_ARGS__)
-#define svreinterpret_f64_f16_x4(...) __builtin_sve_reinterpret_f64_f16_x4(__VA_ARGS__)
-#define svreinterpret_f64_bf16_x4(...) __builtin_sve_reinterpret_f64_bf16_x4(__VA_ARGS__)
-#define svreinterpret_f64_f32_x4(...) __builtin_sve_reinterpret_f64_f32_x4(__VA_ARGS__)
-#define svreinterpret_f64_f64_x4(...) __builtin_sve_reinterpret_f64_f64_x4(__VA_ARGS__)
-__aio __attribute__((target("sve"))) svint8x4_t svreinterpret_s8(svint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_s8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x4_t svreinterpret_s8(svuint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_u8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x4_t svreinterpret_s8(svint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_s16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x4_t svreinterpret_s8(svuint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_u16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x4_t svreinterpret_s8(svint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_s32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x4_t svreinterpret_s8(svuint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_u32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x4_t svreinterpret_s8(svint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_s64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x4_t svreinterpret_s8(svuint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_u64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x4_t svreinterpret_s8(svfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_f16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x4_t svreinterpret_s8(svbfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_bf16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x4_t svreinterpret_s8(svfloat32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_f32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint8x4_t svreinterpret_s8(svfloat64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s8_f64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x4_t svreinterpret_u8(svint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_s8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x4_t svreinterpret_u8(svuint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_u8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x4_t svreinterpret_u8(svint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_s16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x4_t svreinterpret_u8(svuint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_u16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x4_t svreinterpret_u8(svint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_s32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x4_t svreinterpret_u8(svuint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_u32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x4_t svreinterpret_u8(svint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_s64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x4_t svreinterpret_u8(svuint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_u64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x4_t svreinterpret_u8(svfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_f16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x4_t svreinterpret_u8(svbfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_bf16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x4_t svreinterpret_u8(svfloat32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_f32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint8x4_t svreinterpret_u8(svfloat64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u8_f64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x4_t svreinterpret_s16(svint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_s8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x4_t svreinterpret_s16(svuint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_u8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x4_t svreinterpret_s16(svint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_s16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x4_t svreinterpret_s16(svuint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_u16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x4_t svreinterpret_s16(svint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_s32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x4_t svreinterpret_s16(svuint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_u32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x4_t svreinterpret_s16(svint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_s64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x4_t svreinterpret_s16(svuint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_u64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x4_t svreinterpret_s16(svfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_f16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x4_t svreinterpret_s16(svbfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_bf16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x4_t svreinterpret_s16(svfloat32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_f32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint16x4_t svreinterpret_s16(svfloat64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s16_f64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x4_t svreinterpret_u16(svint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_s8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x4_t svreinterpret_u16(svuint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_u8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x4_t svreinterpret_u16(svint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_s16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x4_t svreinterpret_u16(svuint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_u16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x4_t svreinterpret_u16(svint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_s32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x4_t svreinterpret_u16(svuint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_u32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x4_t svreinterpret_u16(svint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_s64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x4_t svreinterpret_u16(svuint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_u64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x4_t svreinterpret_u16(svfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_f16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x4_t svreinterpret_u16(svbfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_bf16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x4_t svreinterpret_u16(svfloat32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_f32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint16x4_t svreinterpret_u16(svfloat64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u16_f64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x4_t svreinterpret_s32(svint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_s8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x4_t svreinterpret_s32(svuint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_u8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x4_t svreinterpret_s32(svint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_s16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x4_t svreinterpret_s32(svuint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_u16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x4_t svreinterpret_s32(svint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_s32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x4_t svreinterpret_s32(svuint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_u32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x4_t svreinterpret_s32(svint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_s64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x4_t svreinterpret_s32(svuint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_u64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x4_t svreinterpret_s32(svfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_f16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x4_t svreinterpret_s32(svbfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_bf16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x4_t svreinterpret_s32(svfloat32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_f32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint32x4_t svreinterpret_s32(svfloat64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s32_f64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x4_t svreinterpret_u32(svint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_s8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x4_t svreinterpret_u32(svuint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_u8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x4_t svreinterpret_u32(svint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_s16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x4_t svreinterpret_u32(svuint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_u16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x4_t svreinterpret_u32(svint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_s32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x4_t svreinterpret_u32(svuint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_u32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x4_t svreinterpret_u32(svint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_s64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x4_t svreinterpret_u32(svuint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_u64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x4_t svreinterpret_u32(svfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_f16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x4_t svreinterpret_u32(svbfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_bf16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x4_t svreinterpret_u32(svfloat32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_f32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint32x4_t svreinterpret_u32(svfloat64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u32_f64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x4_t svreinterpret_s64(svint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_s8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x4_t svreinterpret_s64(svuint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_u8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x4_t svreinterpret_s64(svint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_s16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x4_t svreinterpret_s64(svuint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_u16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x4_t svreinterpret_s64(svint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_s32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x4_t svreinterpret_s64(svuint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_u32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x4_t svreinterpret_s64(svint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_s64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x4_t svreinterpret_s64(svuint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_u64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x4_t svreinterpret_s64(svfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_f16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x4_t svreinterpret_s64(svbfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_bf16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x4_t svreinterpret_s64(svfloat32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_f32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svint64x4_t svreinterpret_s64(svfloat64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_s64_f64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x4_t svreinterpret_u64(svint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_s8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x4_t svreinterpret_u64(svuint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_u8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x4_t svreinterpret_u64(svint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_s16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x4_t svreinterpret_u64(svuint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_u16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x4_t svreinterpret_u64(svint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_s32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x4_t svreinterpret_u64(svuint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_u32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x4_t svreinterpret_u64(svint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_s64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x4_t svreinterpret_u64(svuint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_u64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x4_t svreinterpret_u64(svfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_f16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x4_t svreinterpret_u64(svbfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_bf16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x4_t svreinterpret_u64(svfloat32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_f32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svuint64x4_t svreinterpret_u64(svfloat64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_u64_f64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x4_t svreinterpret_f16(svint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_s8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x4_t svreinterpret_f16(svuint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_u8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x4_t svreinterpret_f16(svint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_s16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x4_t svreinterpret_f16(svuint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_u16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x4_t svreinterpret_f16(svint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_s32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x4_t svreinterpret_f16(svuint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_u32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x4_t svreinterpret_f16(svint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_s64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x4_t svreinterpret_f16(svuint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_u64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x4_t svreinterpret_f16(svfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_f16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x4_t svreinterpret_f16(svbfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_bf16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x4_t svreinterpret_f16(svfloat32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_f32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat16x4_t svreinterpret_f16(svfloat64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f16_f64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x4_t svreinterpret_bf16(svint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_s8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x4_t svreinterpret_bf16(svuint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_u8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x4_t svreinterpret_bf16(svint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_s16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x4_t svreinterpret_bf16(svuint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_u16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x4_t svreinterpret_bf16(svint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_s32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x4_t svreinterpret_bf16(svuint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_u32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x4_t svreinterpret_bf16(svint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_s64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x4_t svreinterpret_bf16(svuint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_u64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x4_t svreinterpret_bf16(svfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_f16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x4_t svreinterpret_bf16(svbfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_bf16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x4_t svreinterpret_bf16(svfloat32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_f32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svbfloat16x4_t svreinterpret_bf16(svfloat64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_bf16_f64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x4_t svreinterpret_f32(svint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_s8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x4_t svreinterpret_f32(svuint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_u8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x4_t svreinterpret_f32(svint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_s16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x4_t svreinterpret_f32(svuint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_u16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x4_t svreinterpret_f32(svint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_s32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x4_t svreinterpret_f32(svuint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_u32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x4_t svreinterpret_f32(svint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_s64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x4_t svreinterpret_f32(svuint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_u64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x4_t svreinterpret_f32(svfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_f16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x4_t svreinterpret_f32(svbfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_bf16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x4_t svreinterpret_f32(svfloat32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_f32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat32x4_t svreinterpret_f32(svfloat64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f32_f64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x4_t svreinterpret_f64(svint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_s8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x4_t svreinterpret_f64(svuint8x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_u8_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x4_t svreinterpret_f64(svint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_s16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x4_t svreinterpret_f64(svuint16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_u16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x4_t svreinterpret_f64(svint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_s32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x4_t svreinterpret_f64(svuint32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_u32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x4_t svreinterpret_f64(svint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_s64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x4_t svreinterpret_f64(svuint64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_u64_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x4_t svreinterpret_f64(svfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_f16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x4_t svreinterpret_f64(svbfloat16x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_bf16_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x4_t svreinterpret_f64(svfloat32x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_f32_x4(op);
-}
-
-__aio __attribute__((target("sve"))) svfloat64x4_t svreinterpret_f64(svfloat64x4_t op) __arm_streaming_compatible {
- return __builtin_sve_reinterpret_f64_f64_x4(op);
-}
-
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_bf16_m)))
-svbfloat16_t svadd_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_bf16_x)))
-svbfloat16_t svadd_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_bf16_z)))
-svbfloat16_t svadd_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_bf16_m)))
-svbfloat16_t svadd_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_bf16_x)))
-svbfloat16_t svadd_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_bf16_z)))
-svbfloat16_t svadd_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_bf16)))
-svbfloat16_t svclamp_bf16(svbfloat16_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_bf16_m)))
-svbfloat16_t svmax_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_bf16_x)))
-svbfloat16_t svmax_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_bf16_z)))
-svbfloat16_t svmax_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_m)))
-svbfloat16_t svmax_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_x)))
-svbfloat16_t svmax_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_z)))
-svbfloat16_t svmax_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_bf16_m)))
-svbfloat16_t svmaxnm_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_bf16_x)))
-svbfloat16_t svmaxnm_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_bf16_z)))
-svbfloat16_t svmaxnm_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_m)))
-svbfloat16_t svmaxnm_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_x)))
-svbfloat16_t svmaxnm_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_z)))
-svbfloat16_t svmaxnm_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_bf16_m)))
-svbfloat16_t svmin_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_bf16_x)))
-svbfloat16_t svmin_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_bf16_z)))
-svbfloat16_t svmin_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_m)))
-svbfloat16_t svmin_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_x)))
-svbfloat16_t svmin_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_z)))
-svbfloat16_t svmin_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_bf16_m)))
-svbfloat16_t svminnm_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_bf16_x)))
-svbfloat16_t svminnm_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_bf16_z)))
-svbfloat16_t svminnm_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_m)))
-svbfloat16_t svminnm_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_x)))
-svbfloat16_t svminnm_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_z)))
-svbfloat16_t svminnm_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_bf16_m)))
-svbfloat16_t svmla_n_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_bf16_x)))
-svbfloat16_t svmla_n_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_bf16_z)))
-svbfloat16_t svmla_n_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_bf16_m)))
-svbfloat16_t svmla_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_bf16_x)))
-svbfloat16_t svmla_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_bf16_z)))
-svbfloat16_t svmla_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_bf16)))
-svbfloat16_t svmla_lane_bf16(svbfloat16_t, svbfloat16_t, svbfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_bf16_m)))
-svbfloat16_t svmls_n_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_bf16_x)))
-svbfloat16_t svmls_n_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_bf16_z)))
-svbfloat16_t svmls_n_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_bf16_m)))
-svbfloat16_t svmls_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_bf16_x)))
-svbfloat16_t svmls_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_bf16_z)))
-svbfloat16_t svmls_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_bf16)))
-svbfloat16_t svmls_lane_bf16(svbfloat16_t, svbfloat16_t, svbfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_bf16_m)))
-svbfloat16_t svmul_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_bf16_x)))
-svbfloat16_t svmul_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_bf16_z)))
-svbfloat16_t svmul_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_bf16_m)))
-svbfloat16_t svmul_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_bf16_x)))
-svbfloat16_t svmul_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_bf16_z)))
-svbfloat16_t svmul_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_bf16)))
-svbfloat16_t svmul_lane_bf16(svbfloat16_t, svbfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_bf16_m)))
-svbfloat16_t svsub_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_bf16_x)))
-svbfloat16_t svsub_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_bf16_z)))
-svbfloat16_t svsub_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_bf16_m)))
-svbfloat16_t svsub_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_bf16_x)))
-svbfloat16_t svsub_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_bf16_z)))
-svbfloat16_t svsub_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_bf16_m)))
-svbfloat16_t svadd_m(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_bf16_x)))
-svbfloat16_t svadd_x(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_bf16_z)))
-svbfloat16_t svadd_z(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_bf16_m)))
-svbfloat16_t svadd_m(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_bf16_x)))
-svbfloat16_t svadd_x(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_bf16_z)))
-svbfloat16_t svadd_z(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_bf16)))
-svbfloat16_t svclamp(svbfloat16_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_bf16_m)))
-svbfloat16_t svmax_m(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_bf16_x)))
-svbfloat16_t svmax_x(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_bf16_z)))
-svbfloat16_t svmax_z(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_m)))
-svbfloat16_t svmax_m(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_x)))
-svbfloat16_t svmax_x(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_z)))
-svbfloat16_t svmax_z(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_bf16_m)))
-svbfloat16_t svmaxnm_m(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_bf16_x)))
-svbfloat16_t svmaxnm_x(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_bf16_z)))
-svbfloat16_t svmaxnm_z(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_m)))
-svbfloat16_t svmaxnm_m(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_x)))
-svbfloat16_t svmaxnm_x(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_z)))
-svbfloat16_t svmaxnm_z(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_bf16_m)))
-svbfloat16_t svmin_m(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_bf16_x)))
-svbfloat16_t svmin_x(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_bf16_z)))
-svbfloat16_t svmin_z(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_m)))
-svbfloat16_t svmin_m(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_x)))
-svbfloat16_t svmin_x(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_z)))
-svbfloat16_t svmin_z(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_bf16_m)))
-svbfloat16_t svminnm_m(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_bf16_x)))
-svbfloat16_t svminnm_x(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_bf16_z)))
-svbfloat16_t svminnm_z(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_m)))
-svbfloat16_t svminnm_m(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_x)))
-svbfloat16_t svminnm_x(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_z)))
-svbfloat16_t svminnm_z(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_bf16_m)))
-svbfloat16_t svmla_m(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_bf16_x)))
-svbfloat16_t svmla_x(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_bf16_z)))
-svbfloat16_t svmla_z(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_bf16_m)))
-svbfloat16_t svmla_m(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_bf16_x)))
-svbfloat16_t svmla_x(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_bf16_z)))
-svbfloat16_t svmla_z(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_bf16)))
-svbfloat16_t svmla_lane(svbfloat16_t, svbfloat16_t, svbfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_bf16_m)))
-svbfloat16_t svmls_m(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_bf16_x)))
-svbfloat16_t svmls_x(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_bf16_z)))
-svbfloat16_t svmls_z(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_bf16_m)))
-svbfloat16_t svmls_m(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_bf16_x)))
-svbfloat16_t svmls_x(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_bf16_z)))
-svbfloat16_t svmls_z(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_bf16)))
-svbfloat16_t svmls_lane(svbfloat16_t, svbfloat16_t, svbfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_bf16_m)))
-svbfloat16_t svmul_m(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_bf16_x)))
-svbfloat16_t svmul_x(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_bf16_z)))
-svbfloat16_t svmul_z(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_bf16_m)))
-svbfloat16_t svmul_m(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_bf16_x)))
-svbfloat16_t svmul_x(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_bf16_z)))
-svbfloat16_t svmul_z(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_bf16)))
-svbfloat16_t svmul_lane(svbfloat16_t, svbfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_bf16_m)))
-svbfloat16_t svsub_m(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_bf16_x)))
-svbfloat16_t svsub_x(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_bf16_z)))
-svbfloat16_t svsub_z(svbool_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_bf16_m)))
-svbfloat16_t svsub_m(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_bf16_x)))
-svbfloat16_t svsub_x(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_bf16_z)))
-svbfloat16_t svsub_z(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u8_x2)))
-svuint8x2_t svadd_single_u8_x2(svuint8x2_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u32_x2)))
-svuint32x2_t svadd_single_u32_x2(svuint32x2_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u64_x2)))
-svuint64x2_t svadd_single_u64_x2(svuint64x2_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u16_x2)))
-svuint16x2_t svadd_single_u16_x2(svuint16x2_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s8_x2)))
-svint8x2_t svadd_single_s8_x2(svint8x2_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s32_x2)))
-svint32x2_t svadd_single_s32_x2(svint32x2_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s64_x2)))
-svint64x2_t svadd_single_s64_x2(svint64x2_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s16_x2)))
-svint16x2_t svadd_single_s16_x2(svint16x2_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u8_x4)))
-svuint8x4_t svadd_single_u8_x4(svuint8x4_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u32_x4)))
-svuint32x4_t svadd_single_u32_x4(svuint32x4_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u64_x4)))
-svuint64x4_t svadd_single_u64_x4(svuint64x4_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u16_x4)))
-svuint16x4_t svadd_single_u16_x4(svuint16x4_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s8_x4)))
-svint8x4_t svadd_single_s8_x4(svint8x4_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s32_x4)))
-svint32x4_t svadd_single_s32_x4(svint32x4_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s64_x4)))
-svint64x4_t svadd_single_s64_x4(svint64x4_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s16_x4)))
-svint16x4_t svadd_single_s16_x4(svint16x4_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f64_x2)))
-svfloat64x2_t svclamp_single_f64_x2(svfloat64x2_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f32_x2)))
-svfloat32x2_t svclamp_single_f32_x2(svfloat32x2_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f16_x2)))
-svfloat16x2_t svclamp_single_f16_x2(svfloat16x2_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s8_x2)))
-svint8x2_t svclamp_single_s8_x2(svint8x2_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s32_x2)))
-svint32x2_t svclamp_single_s32_x2(svint32x2_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s64_x2)))
-svint64x2_t svclamp_single_s64_x2(svint64x2_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s16_x2)))
-svint16x2_t svclamp_single_s16_x2(svint16x2_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u8_x2)))
-svuint8x2_t svclamp_single_u8_x2(svuint8x2_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u32_x2)))
-svuint32x2_t svclamp_single_u32_x2(svuint32x2_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u64_x2)))
-svuint64x2_t svclamp_single_u64_x2(svuint64x2_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u16_x2)))
-svuint16x2_t svclamp_single_u16_x2(svuint16x2_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f64_x4)))
-svfloat64x4_t svclamp_single_f64_x4(svfloat64x4_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f32_x4)))
-svfloat32x4_t svclamp_single_f32_x4(svfloat32x4_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f16_x4)))
-svfloat16x4_t svclamp_single_f16_x4(svfloat16x4_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s8_x4)))
-svint8x4_t svclamp_single_s8_x4(svint8x4_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s32_x4)))
-svint32x4_t svclamp_single_s32_x4(svint32x4_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s64_x4)))
-svint64x4_t svclamp_single_s64_x4(svint64x4_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s16_x4)))
-svint16x4_t svclamp_single_s16_x4(svint16x4_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u8_x4)))
-svuint8x4_t svclamp_single_u8_x4(svuint8x4_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u32_x4)))
-svuint32x4_t svclamp_single_u32_x4(svuint32x4_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u64_x4)))
-svuint64x4_t svclamp_single_u64_x4(svuint64x4_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u16_x4)))
-svuint16x4_t svclamp_single_u16_x4(svuint16x4_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_x2)))
-svbfloat16_t svcvt_bf16_f32_x2(svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_x2)))
-svfloat16_t svcvt_f16_f32_x2(svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_x2)))
-svint32x2_t svcvt_s32_f32_x2(svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_x2)))
-svuint32x2_t svcvt_u32_f32_x2(svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_x4)))
-svint32x4_t svcvt_s32_f32_x4(svfloat32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_x4)))
-svuint32x4_t svcvt_u32_f32_x4(svfloat32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_x2)))
-svfloat32x2_t svcvt_f32_s32_x2(svint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_x4)))
-svfloat32x4_t svcvt_f32_s32_x4(svint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_x2)))
-svfloat32x2_t svcvt_f32_u32_x2(svuint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_x4)))
-svfloat32x4_t svcvt_f32_u32_x4(svuint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtn_bf16_f32_x2)))
-svbfloat16_t svcvtn_bf16_f32_x2(svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtn_f16_f32_x2)))
-svfloat16_t svcvtn_f16_f32_x2(svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f64_x2)))
-svfloat64x2_t svmax_single_f64_x2(svfloat64x2_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f32_x2)))
-svfloat32x2_t svmax_single_f32_x2(svfloat32x2_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f16_x2)))
-svfloat16x2_t svmax_single_f16_x2(svfloat16x2_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s8_x2)))
-svint8x2_t svmax_single_s8_x2(svint8x2_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s32_x2)))
-svint32x2_t svmax_single_s32_x2(svint32x2_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s64_x2)))
-svint64x2_t svmax_single_s64_x2(svint64x2_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s16_x2)))
-svint16x2_t svmax_single_s16_x2(svint16x2_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u8_x2)))
-svuint8x2_t svmax_single_u8_x2(svuint8x2_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u32_x2)))
-svuint32x2_t svmax_single_u32_x2(svuint32x2_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u64_x2)))
-svuint64x2_t svmax_single_u64_x2(svuint64x2_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u16_x2)))
-svuint16x2_t svmax_single_u16_x2(svuint16x2_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f64_x4)))
-svfloat64x4_t svmax_single_f64_x4(svfloat64x4_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f32_x4)))
-svfloat32x4_t svmax_single_f32_x4(svfloat32x4_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f16_x4)))
-svfloat16x4_t svmax_single_f16_x4(svfloat16x4_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s8_x4)))
-svint8x4_t svmax_single_s8_x4(svint8x4_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s32_x4)))
-svint32x4_t svmax_single_s32_x4(svint32x4_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s64_x4)))
-svint64x4_t svmax_single_s64_x4(svint64x4_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s16_x4)))
-svint16x4_t svmax_single_s16_x4(svint16x4_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u8_x4)))
-svuint8x4_t svmax_single_u8_x4(svuint8x4_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u32_x4)))
-svuint32x4_t svmax_single_u32_x4(svuint32x4_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u64_x4)))
-svuint64x4_t svmax_single_u64_x4(svuint64x4_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u16_x4)))
-svuint16x4_t svmax_single_u16_x4(svuint16x4_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_x2)))
-svfloat64x2_t svmax_f64_x2(svfloat64x2_t, svfloat64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_x2)))
-svfloat32x2_t svmax_f32_x2(svfloat32x2_t, svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_x2)))
-svfloat16x2_t svmax_f16_x2(svfloat16x2_t, svfloat16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_x2)))
-svint8x2_t svmax_s8_x2(svint8x2_t, svint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_x2)))
-svint32x2_t svmax_s32_x2(svint32x2_t, svint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_x2)))
-svint64x2_t svmax_s64_x2(svint64x2_t, svint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_x2)))
-svint16x2_t svmax_s16_x2(svint16x2_t, svint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_x2)))
-svuint8x2_t svmax_u8_x2(svuint8x2_t, svuint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_x2)))
-svuint32x2_t svmax_u32_x2(svuint32x2_t, svuint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_x2)))
-svuint64x2_t svmax_u64_x2(svuint64x2_t, svuint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_x2)))
-svuint16x2_t svmax_u16_x2(svuint16x2_t, svuint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_x4)))
-svfloat64x4_t svmax_f64_x4(svfloat64x4_t, svfloat64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_x4)))
-svfloat32x4_t svmax_f32_x4(svfloat32x4_t, svfloat32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_x4)))
-svfloat16x4_t svmax_f16_x4(svfloat16x4_t, svfloat16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_x4)))
-svint8x4_t svmax_s8_x4(svint8x4_t, svint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_x4)))
-svint32x4_t svmax_s32_x4(svint32x4_t, svint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_x4)))
-svint64x4_t svmax_s64_x4(svint64x4_t, svint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_x4)))
-svint16x4_t svmax_s16_x4(svint16x4_t, svint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_x4)))
-svuint8x4_t svmax_u8_x4(svuint8x4_t, svuint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_x4)))
-svuint32x4_t svmax_u32_x4(svuint32x4_t, svuint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_x4)))
-svuint64x4_t svmax_u64_x4(svuint64x4_t, svuint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_x4)))
-svuint16x4_t svmax_u16_x4(svuint16x4_t, svuint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f64_x2)))
-svfloat64x2_t svmaxnm_single_f64_x2(svfloat64x2_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f32_x2)))
-svfloat32x2_t svmaxnm_single_f32_x2(svfloat32x2_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f16_x2)))
-svfloat16x2_t svmaxnm_single_f16_x2(svfloat16x2_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f64_x4)))
-svfloat64x4_t svmaxnm_single_f64_x4(svfloat64x4_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f32_x4)))
-svfloat32x4_t svmaxnm_single_f32_x4(svfloat32x4_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f16_x4)))
-svfloat16x4_t svmaxnm_single_f16_x4(svfloat16x4_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_x2)))
-svfloat64x2_t svmaxnm_f64_x2(svfloat64x2_t, svfloat64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_x2)))
-svfloat32x2_t svmaxnm_f32_x2(svfloat32x2_t, svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x2)))
-svfloat16x2_t svmaxnm_f16_x2(svfloat16x2_t, svfloat16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_x4)))
-svfloat64x4_t svmaxnm_f64_x4(svfloat64x4_t, svfloat64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_x4)))
-svfloat32x4_t svmaxnm_f32_x4(svfloat32x4_t, svfloat32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x4)))
-svfloat16x4_t svmaxnm_f16_x4(svfloat16x4_t, svfloat16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f64_x2)))
-svfloat64x2_t svmin_single_f64_x2(svfloat64x2_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f32_x2)))
-svfloat32x2_t svmin_single_f32_x2(svfloat32x2_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f16_x2)))
-svfloat16x2_t svmin_single_f16_x2(svfloat16x2_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s8_x2)))
-svint8x2_t svmin_single_s8_x2(svint8x2_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s32_x2)))
-svint32x2_t svmin_single_s32_x2(svint32x2_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s64_x2)))
-svint64x2_t svmin_single_s64_x2(svint64x2_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s16_x2)))
-svint16x2_t svmin_single_s16_x2(svint16x2_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u8_x2)))
-svuint8x2_t svmin_single_u8_x2(svuint8x2_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u32_x2)))
-svuint32x2_t svmin_single_u32_x2(svuint32x2_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u64_x2)))
-svuint64x2_t svmin_single_u64_x2(svuint64x2_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u16_x2)))
-svuint16x2_t svmin_single_u16_x2(svuint16x2_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f64_x4)))
-svfloat64x4_t svmin_single_f64_x4(svfloat64x4_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f32_x4)))
-svfloat32x4_t svmin_single_f32_x4(svfloat32x4_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f16_x4)))
-svfloat16x4_t svmin_single_f16_x4(svfloat16x4_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s8_x4)))
-svint8x4_t svmin_single_s8_x4(svint8x4_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s32_x4)))
-svint32x4_t svmin_single_s32_x4(svint32x4_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s64_x4)))
-svint64x4_t svmin_single_s64_x4(svint64x4_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s16_x4)))
-svint16x4_t svmin_single_s16_x4(svint16x4_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u8_x4)))
-svuint8x4_t svmin_single_u8_x4(svuint8x4_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u32_x4)))
-svuint32x4_t svmin_single_u32_x4(svuint32x4_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u64_x4)))
-svuint64x4_t svmin_single_u64_x4(svuint64x4_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u16_x4)))
-svuint16x4_t svmin_single_u16_x4(svuint16x4_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_x2)))
-svfloat64x2_t svmin_f64_x2(svfloat64x2_t, svfloat64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_x2)))
-svfloat32x2_t svmin_f32_x2(svfloat32x2_t, svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_x2)))
-svfloat16x2_t svmin_f16_x2(svfloat16x2_t, svfloat16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_x2)))
-svint8x2_t svmin_s8_x2(svint8x2_t, svint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_x2)))
-svint32x2_t svmin_s32_x2(svint32x2_t, svint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_x2)))
-svint64x2_t svmin_s64_x2(svint64x2_t, svint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_x2)))
-svint16x2_t svmin_s16_x2(svint16x2_t, svint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_x2)))
-svuint8x2_t svmin_u8_x2(svuint8x2_t, svuint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_x2)))
-svuint32x2_t svmin_u32_x2(svuint32x2_t, svuint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_x2)))
-svuint64x2_t svmin_u64_x2(svuint64x2_t, svuint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_x2)))
-svuint16x2_t svmin_u16_x2(svuint16x2_t, svuint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_x4)))
-svfloat64x4_t svmin_f64_x4(svfloat64x4_t, svfloat64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_x4)))
-svfloat32x4_t svmin_f32_x4(svfloat32x4_t, svfloat32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_x4)))
-svfloat16x4_t svmin_f16_x4(svfloat16x4_t, svfloat16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_x4)))
-svint8x4_t svmin_s8_x4(svint8x4_t, svint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_x4)))
-svint32x4_t svmin_s32_x4(svint32x4_t, svint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_x4)))
-svint64x4_t svmin_s64_x4(svint64x4_t, svint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_x4)))
-svint16x4_t svmin_s16_x4(svint16x4_t, svint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_x4)))
-svuint8x4_t svmin_u8_x4(svuint8x4_t, svuint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_x4)))
-svuint32x4_t svmin_u32_x4(svuint32x4_t, svuint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_x4)))
-svuint64x4_t svmin_u64_x4(svuint64x4_t, svuint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_x4)))
-svuint16x4_t svmin_u16_x4(svuint16x4_t, svuint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f64_x2)))
-svfloat64x2_t svminnm_single_f64_x2(svfloat64x2_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f32_x2)))
-svfloat32x2_t svminnm_single_f32_x2(svfloat32x2_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f16_x2)))
-svfloat16x2_t svminnm_single_f16_x2(svfloat16x2_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f64_x4)))
-svfloat64x4_t svminnm_single_f64_x4(svfloat64x4_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f32_x4)))
-svfloat32x4_t svminnm_single_f32_x4(svfloat32x4_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f16_x4)))
-svfloat16x4_t svminnm_single_f16_x4(svfloat16x4_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_x2)))
-svfloat64x2_t svminnm_f64_x2(svfloat64x2_t, svfloat64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_x2)))
-svfloat32x2_t svminnm_f32_x2(svfloat32x2_t, svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_x2)))
-svfloat16x2_t svminnm_f16_x2(svfloat16x2_t, svfloat16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_x4)))
-svfloat64x4_t svminnm_f64_x4(svfloat64x4_t, svfloat64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_x4)))
-svfloat32x4_t svminnm_f32_x4(svfloat32x4_t, svfloat32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_x4)))
-svfloat16x4_t svminnm_f16_x4(svfloat16x4_t, svfloat16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_s16_s32_x2)))
-svint16_t svqcvt_s16_s32_x2(svint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_s16_s64_x4)))
-svint16_t svqcvt_s16_s64_x4(svint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_s8_s32_x4)))
-svint8_t svqcvt_s8_s32_x4(svint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_s32_x2)))
-svuint16_t svqcvt_u16_s32_x2(svint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_u32_x2)))
-svuint16_t svqcvt_u16_u32_x2(svuint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_s64_x4)))
-svuint16_t svqcvt_u16_s64_x4(svint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_u64_x4)))
-svuint16_t svqcvt_u16_u64_x4(svuint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u8_s32_x4)))
-svuint8_t svqcvt_u8_s32_x4(svint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u8_u32_x4)))
-svuint8_t svqcvt_u8_u32_x4(svuint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_s16_s64_x4)))
-svint16_t svqcvtn_s16_s64_x4(svint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_s8_s32_x4)))
-svint8_t svqcvtn_s8_s32_x4(svint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_s64_x4)))
-svuint16_t svqcvtn_u16_s64_x4(svint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_u64_x4)))
-svuint16_t svqcvtn_u16_u64_x4(svuint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u8_s32_x4)))
-svuint8_t svqcvtn_u8_s32_x4(svint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u8_u32_x4)))
-svuint8_t svqcvtn_u8_u32_x4(svuint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s8_x2)))
-svint8x2_t svqdmulh_single_s8_x2(svint8x2_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s32_x2)))
-svint32x2_t svqdmulh_single_s32_x2(svint32x2_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s64_x2)))
-svint64x2_t svqdmulh_single_s64_x2(svint64x2_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s16_x2)))
-svint16x2_t svqdmulh_single_s16_x2(svint16x2_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s8_x4)))
-svint8x4_t svqdmulh_single_s8_x4(svint8x4_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s32_x4)))
-svint32x4_t svqdmulh_single_s32_x4(svint32x4_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s64_x4)))
-svint64x4_t svqdmulh_single_s64_x4(svint64x4_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s16_x4)))
-svint16x4_t svqdmulh_single_s16_x4(svint16x4_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s8_x2)))
-svint8x2_t svqdmulh_s8_x2(svint8x2_t, svint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s32_x2)))
-svint32x2_t svqdmulh_s32_x2(svint32x2_t, svint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s64_x2)))
-svint64x2_t svqdmulh_s64_x2(svint64x2_t, svint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s16_x2)))
-svint16x2_t svqdmulh_s16_x2(svint16x2_t, svint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s8_x4)))
-svint8x4_t svqdmulh_s8_x4(svint8x4_t, svint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s32_x4)))
-svint32x4_t svqdmulh_s32_x4(svint32x4_t, svint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s64_x4)))
-svint64x4_t svqdmulh_s64_x4(svint64x4_t, svint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s16_x4)))
-svint16x4_t svqdmulh_s16_x4(svint16x4_t, svint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_s16_s32_x2)))
-svint16_t svqrshr_n_s16_s32_x2(svint32x2_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_u16_u32_x2)))
-svuint16_t svqrshr_n_u16_u32_x2(svuint32x2_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_s8_s32_x4)))
-svint8_t svqrshr_n_s8_s32_x4(svint32x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_s16_s64_x4)))
-svint16_t svqrshr_n_s16_s64_x4(svint64x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_u8_u32_x4)))
-svuint8_t svqrshr_n_u8_u32_x4(svuint32x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_u16_u64_x4)))
-svuint16_t svqrshr_n_u16_u64_x4(svuint64x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_s8_s32_x4)))
-svint8_t svqrshrn_n_s8_s32_x4(svint32x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_s16_s64_x4)))
-svint16_t svqrshrn_n_s16_s64_x4(svint64x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_u8_u32_x4)))
-svuint8_t svqrshrn_n_u8_u32_x4(svuint32x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_u16_u64_x4)))
-svuint16_t svqrshrn_n_u16_u64_x4(svuint64x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshru_n_u16_s32_x2)))
-svuint16_t svqrshru_n_u16_s32_x2(svint32x2_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshru_n_u8_s32_x4)))
-svuint8_t svqrshru_n_u8_s32_x4(svint32x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshru_n_u16_s64_x4)))
-svuint16_t svqrshru_n_u16_s64_x4(svint64x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrun_n_u8_s32_x4)))
-svuint8_t svqrshrun_n_u8_s32_x4(svint32x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrun_n_u16_s64_x4)))
-svuint16_t svqrshrun_n_u16_s64_x4(svint64x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svreinterpret_b)))
-svbool_t svreinterpret_b(svcount_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svreinterpret_c)))
-svcount_t svreinterpret_c(svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_x2)))
-svfloat32x2_t svrinta_f32_x2(svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_x4)))
-svfloat32x4_t svrinta_f32_x4(svfloat32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_x2)))
-svfloat32x2_t svrintm_f32_x2(svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_x4)))
-svfloat32x4_t svrintm_f32_x4(svfloat32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_x2)))
-svfloat32x2_t svrintn_f32_x2(svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_x4)))
-svfloat32x4_t svrintn_f32_x4(svfloat32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_x2)))
-svfloat32x2_t svrintp_f32_x2(svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_x4)))
-svfloat32x4_t svrintp_f32_x4(svfloat32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s8_x2)))
-svint8x2_t svrshl_single_s8_x2(svint8x2_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s32_x2)))
-svint32x2_t svrshl_single_s32_x2(svint32x2_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s64_x2)))
-svint64x2_t svrshl_single_s64_x2(svint64x2_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s16_x2)))
-svint16x2_t svrshl_single_s16_x2(svint16x2_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u8_x2)))
-svuint8x2_t svrshl_single_u8_x2(svuint8x2_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u32_x2)))
-svuint32x2_t svrshl_single_u32_x2(svuint32x2_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u64_x2)))
-svuint64x2_t svrshl_single_u64_x2(svuint64x2_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u16_x2)))
-svuint16x2_t svrshl_single_u16_x2(svuint16x2_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s8_x4)))
-svint8x4_t svrshl_single_s8_x4(svint8x4_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s32_x4)))
-svint32x4_t svrshl_single_s32_x4(svint32x4_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s64_x4)))
-svint64x4_t svrshl_single_s64_x4(svint64x4_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s16_x4)))
-svint16x4_t svrshl_single_s16_x4(svint16x4_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u8_x4)))
-svuint8x4_t svrshl_single_u8_x4(svuint8x4_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u32_x4)))
-svuint32x4_t svrshl_single_u32_x4(svuint32x4_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u64_x4)))
-svuint64x4_t svrshl_single_u64_x4(svuint64x4_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u16_x4)))
-svuint16x4_t svrshl_single_u16_x4(svuint16x4_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_x2)))
-svint8x2_t svrshl_s8_x2(svint8x2_t, svint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_x2)))
-svint32x2_t svrshl_s32_x2(svint32x2_t, svint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_x2)))
-svint64x2_t svrshl_s64_x2(svint64x2_t, svint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_x2)))
-svint16x2_t svrshl_s16_x2(svint16x2_t, svint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_x2)))
-svuint8x2_t svrshl_u8_x2(svuint8x2_t, svuint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_x2)))
-svuint32x2_t svrshl_u32_x2(svuint32x2_t, svuint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_x2)))
-svuint64x2_t svrshl_u64_x2(svuint64x2_t, svuint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_x2)))
-svuint16x2_t svrshl_u16_x2(svuint16x2_t, svuint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_x4)))
-svint8x4_t svrshl_s8_x4(svint8x4_t, svint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_x4)))
-svint32x4_t svrshl_s32_x4(svint32x4_t, svint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_x4)))
-svint64x4_t svrshl_s64_x4(svint64x4_t, svint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_x4)))
-svint16x4_t svrshl_s16_x4(svint16x4_t, svint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_x4)))
-svuint8x4_t svrshl_u8_x4(svuint8x4_t, svuint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_x4)))
-svuint32x4_t svrshl_u32_x4(svuint32x4_t, svuint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_x4)))
-svuint64x4_t svrshl_u64_x4(svuint64x4_t, svuint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_x4)))
-svuint16x4_t svrshl_u16_x4(svuint16x4_t, svuint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8_x2)))
-svuint8x2_t svsel_u8_x2(svcount_t, svuint8x2_t, svuint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u32_x2)))
-svuint32x2_t svsel_u32_x2(svcount_t, svuint32x2_t, svuint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u64_x2)))
-svuint64x2_t svsel_u64_x2(svcount_t, svuint64x2_t, svuint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u16_x2)))
-svuint16x2_t svsel_u16_x2(svcount_t, svuint16x2_t, svuint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_bf16_x2)))
-svbfloat16x2_t svsel_bf16_x2(svcount_t, svbfloat16x2_t, svbfloat16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s8_x2)))
-svint8x2_t svsel_s8_x2(svcount_t, svint8x2_t, svint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f64_x2)))
-svfloat64x2_t svsel_f64_x2(svcount_t, svfloat64x2_t, svfloat64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f32_x2)))
-svfloat32x2_t svsel_f32_x2(svcount_t, svfloat32x2_t, svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16_x2)))
-svfloat16x2_t svsel_f16_x2(svcount_t, svfloat16x2_t, svfloat16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s32_x2)))
-svint32x2_t svsel_s32_x2(svcount_t, svint32x2_t, svint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s64_x2)))
-svint64x2_t svsel_s64_x2(svcount_t, svint64x2_t, svint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s16_x2)))
-svint16x2_t svsel_s16_x2(svcount_t, svint16x2_t, svint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8_x4)))
-svuint8x4_t svsel_u8_x4(svcount_t, svuint8x4_t, svuint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u32_x4)))
-svuint32x4_t svsel_u32_x4(svcount_t, svuint32x4_t, svuint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u64_x4)))
-svuint64x4_t svsel_u64_x4(svcount_t, svuint64x4_t, svuint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u16_x4)))
-svuint16x4_t svsel_u16_x4(svcount_t, svuint16x4_t, svuint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_bf16_x4)))
-svbfloat16x4_t svsel_bf16_x4(svcount_t, svbfloat16x4_t, svbfloat16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s8_x4)))
-svint8x4_t svsel_s8_x4(svcount_t, svint8x4_t, svint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f64_x4)))
-svfloat64x4_t svsel_f64_x4(svcount_t, svfloat64x4_t, svfloat64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f32_x4)))
-svfloat32x4_t svsel_f32_x4(svcount_t, svfloat32x4_t, svfloat32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16_x4)))
-svfloat16x4_t svsel_f16_x4(svcount_t, svfloat16x4_t, svfloat16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s32_x4)))
-svint32x4_t svsel_s32_x4(svcount_t, svint32x4_t, svint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s64_x4)))
-svint64x4_t svsel_s64_x4(svcount_t, svint64x4_t, svint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s16_x4)))
-svint16x4_t svsel_s16_x4(svcount_t, svint16x4_t, svint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s32_s16_x2)))
-svint32x2_t svunpk_s32_s16_x2(svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s64_s32_x2)))
-svint64x2_t svunpk_s64_s32_x2(svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s16_s8_x2)))
-svint16x2_t svunpk_s16_s8_x2(svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u32_u16_x2)))
-svuint32x2_t svunpk_u32_u16_x2(svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u64_u32_x2)))
-svuint64x2_t svunpk_u64_u32_x2(svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u16_u8_x2)))
-svuint16x2_t svunpk_u16_u8_x2(svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s32_s16_x4)))
-svint32x4_t svunpk_s32_s16_x4(svint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s64_s32_x4)))
-svint64x4_t svunpk_s64_s32_x4(svint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s16_s8_x4)))
-svint16x4_t svunpk_s16_s8_x4(svint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u32_u16_x4)))
-svuint32x4_t svunpk_u32_u16_x4(svuint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u64_u32_x4)))
-svuint64x4_t svunpk_u64_u32_x4(svuint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u16_u8_x4)))
-svuint16x4_t svunpk_u16_u8_x4(svuint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u8_x2)))
-svuint8x2_t svuzp_u8_x2(svuint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u32_x2)))
-svuint32x2_t svuzp_u32_x2(svuint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u64_x2)))
-svuint64x2_t svuzp_u64_x2(svuint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u16_x2)))
-svuint16x2_t svuzp_u16_x2(svuint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_bf16_x2)))
-svbfloat16x2_t svuzp_bf16_x2(svbfloat16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s8_x2)))
-svint8x2_t svuzp_s8_x2(svint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f64_x2)))
-svfloat64x2_t svuzp_f64_x2(svfloat64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f32_x2)))
-svfloat32x2_t svuzp_f32_x2(svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f16_x2)))
-svfloat16x2_t svuzp_f16_x2(svfloat16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s32_x2)))
-svint32x2_t svuzp_s32_x2(svint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s64_x2)))
-svint64x2_t svuzp_s64_x2(svint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s16_x2)))
-svint16x2_t svuzp_s16_x2(svint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u8_x4)))
-svuint8x4_t svuzp_u8_x4(svuint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u32_x4)))
-svuint32x4_t svuzp_u32_x4(svuint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u64_x4)))
-svuint64x4_t svuzp_u64_x4(svuint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u16_x4)))
-svuint16x4_t svuzp_u16_x4(svuint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_bf16_x4)))
-svbfloat16x4_t svuzp_bf16_x4(svbfloat16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s8_x4)))
-svint8x4_t svuzp_s8_x4(svint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f64_x4)))
-svfloat64x4_t svuzp_f64_x4(svfloat64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f32_x4)))
-svfloat32x4_t svuzp_f32_x4(svfloat32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f16_x4)))
-svfloat16x4_t svuzp_f16_x4(svfloat16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s32_x4)))
-svint32x4_t svuzp_s32_x4(svint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s64_x4)))
-svint64x4_t svuzp_s64_x4(svint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s16_x4)))
-svint16x4_t svuzp_s16_x4(svint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u8_x2)))
-svuint8x2_t svuzpq_u8_x2(svuint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u32_x2)))
-svuint32x2_t svuzpq_u32_x2(svuint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u64_x2)))
-svuint64x2_t svuzpq_u64_x2(svuint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u16_x2)))
-svuint16x2_t svuzpq_u16_x2(svuint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_bf16_x2)))
-svbfloat16x2_t svuzpq_bf16_x2(svbfloat16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s8_x2)))
-svint8x2_t svuzpq_s8_x2(svint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f64_x2)))
-svfloat64x2_t svuzpq_f64_x2(svfloat64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f32_x2)))
-svfloat32x2_t svuzpq_f32_x2(svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f16_x2)))
-svfloat16x2_t svuzpq_f16_x2(svfloat16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s32_x2)))
-svint32x2_t svuzpq_s32_x2(svint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s64_x2)))
-svint64x2_t svuzpq_s64_x2(svint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s16_x2)))
-svint16x2_t svuzpq_s16_x2(svint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u8_x4)))
-svuint8x4_t svuzpq_u8_x4(svuint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u32_x4)))
-svuint32x4_t svuzpq_u32_x4(svuint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u64_x4)))
-svuint64x4_t svuzpq_u64_x4(svuint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u16_x4)))
-svuint16x4_t svuzpq_u16_x4(svuint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_bf16_x4)))
-svbfloat16x4_t svuzpq_bf16_x4(svbfloat16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s8_x4)))
-svint8x4_t svuzpq_s8_x4(svint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f64_x4)))
-svfloat64x4_t svuzpq_f64_x4(svfloat64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f32_x4)))
-svfloat32x4_t svuzpq_f32_x4(svfloat32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f16_x4)))
-svfloat16x4_t svuzpq_f16_x4(svfloat16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s32_x4)))
-svint32x4_t svuzpq_s32_x4(svint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s64_x4)))
-svint64x4_t svuzpq_s64_x4(svint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s16_x4)))
-svint16x4_t svuzpq_s16_x4(svint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u8_x2)))
-svuint8x2_t svzip_u8_x2(svuint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u32_x2)))
-svuint32x2_t svzip_u32_x2(svuint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u64_x2)))
-svuint64x2_t svzip_u64_x2(svuint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u16_x2)))
-svuint16x2_t svzip_u16_x2(svuint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_bf16_x2)))
-svbfloat16x2_t svzip_bf16_x2(svbfloat16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s8_x2)))
-svint8x2_t svzip_s8_x2(svint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f64_x2)))
-svfloat64x2_t svzip_f64_x2(svfloat64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f32_x2)))
-svfloat32x2_t svzip_f32_x2(svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f16_x2)))
-svfloat16x2_t svzip_f16_x2(svfloat16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s32_x2)))
-svint32x2_t svzip_s32_x2(svint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s64_x2)))
-svint64x2_t svzip_s64_x2(svint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s16_x2)))
-svint16x2_t svzip_s16_x2(svint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u8_x4)))
-svuint8x4_t svzip_u8_x4(svuint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u32_x4)))
-svuint32x4_t svzip_u32_x4(svuint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u64_x4)))
-svuint64x4_t svzip_u64_x4(svuint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u16_x4)))
-svuint16x4_t svzip_u16_x4(svuint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_bf16_x4)))
-svbfloat16x4_t svzip_bf16_x4(svbfloat16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s8_x4)))
-svint8x4_t svzip_s8_x4(svint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f64_x4)))
-svfloat64x4_t svzip_f64_x4(svfloat64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f32_x4)))
-svfloat32x4_t svzip_f32_x4(svfloat32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f16_x4)))
-svfloat16x4_t svzip_f16_x4(svfloat16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s32_x4)))
-svint32x4_t svzip_s32_x4(svint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s64_x4)))
-svint64x4_t svzip_s64_x4(svint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s16_x4)))
-svint16x4_t svzip_s16_x4(svint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u8_x2)))
-svuint8x2_t svzipq_u8_x2(svuint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u32_x2)))
-svuint32x2_t svzipq_u32_x2(svuint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u64_x2)))
-svuint64x2_t svzipq_u64_x2(svuint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u16_x2)))
-svuint16x2_t svzipq_u16_x2(svuint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_bf16_x2)))
-svbfloat16x2_t svzipq_bf16_x2(svbfloat16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s8_x2)))
-svint8x2_t svzipq_s8_x2(svint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f64_x2)))
-svfloat64x2_t svzipq_f64_x2(svfloat64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f32_x2)))
-svfloat32x2_t svzipq_f32_x2(svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f16_x2)))
-svfloat16x2_t svzipq_f16_x2(svfloat16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s32_x2)))
-svint32x2_t svzipq_s32_x2(svint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s64_x2)))
-svint64x2_t svzipq_s64_x2(svint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s16_x2)))
-svint16x2_t svzipq_s16_x2(svint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u8_x4)))
-svuint8x4_t svzipq_u8_x4(svuint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u32_x4)))
-svuint32x4_t svzipq_u32_x4(svuint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u64_x4)))
-svuint64x4_t svzipq_u64_x4(svuint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u16_x4)))
-svuint16x4_t svzipq_u16_x4(svuint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_bf16_x4)))
-svbfloat16x4_t svzipq_bf16_x4(svbfloat16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s8_x4)))
-svint8x4_t svzipq_s8_x4(svint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f64_x4)))
-svfloat64x4_t svzipq_f64_x4(svfloat64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f32_x4)))
-svfloat32x4_t svzipq_f32_x4(svfloat32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f16_x4)))
-svfloat16x4_t svzipq_f16_x4(svfloat16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s32_x4)))
-svint32x4_t svzipq_s32_x4(svint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s64_x4)))
-svint64x4_t svzipq_s64_x4(svint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s16_x4)))
-svint16x4_t svzipq_s16_x4(svint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u8_x2)))
-svuint8x2_t svadd(svuint8x2_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u32_x2)))
-svuint32x2_t svadd(svuint32x2_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u64_x2)))
-svuint64x2_t svadd(svuint64x2_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u16_x2)))
-svuint16x2_t svadd(svuint16x2_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s8_x2)))
-svint8x2_t svadd(svint8x2_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s32_x2)))
-svint32x2_t svadd(svint32x2_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s64_x2)))
-svint64x2_t svadd(svint64x2_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s16_x2)))
-svint16x2_t svadd(svint16x2_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u8_x4)))
-svuint8x4_t svadd(svuint8x4_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u32_x4)))
-svuint32x4_t svadd(svuint32x4_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u64_x4)))
-svuint64x4_t svadd(svuint64x4_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u16_x4)))
-svuint16x4_t svadd(svuint16x4_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s8_x4)))
-svint8x4_t svadd(svint8x4_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s32_x4)))
-svint32x4_t svadd(svint32x4_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s64_x4)))
-svint64x4_t svadd(svint64x4_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s16_x4)))
-svint16x4_t svadd(svint16x4_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f64_x2)))
-svfloat64x2_t svclamp(svfloat64x2_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f32_x2)))
-svfloat32x2_t svclamp(svfloat32x2_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f16_x2)))
-svfloat16x2_t svclamp(svfloat16x2_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s8_x2)))
-svint8x2_t svclamp(svint8x2_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s32_x2)))
-svint32x2_t svclamp(svint32x2_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s64_x2)))
-svint64x2_t svclamp(svint64x2_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s16_x2)))
-svint16x2_t svclamp(svint16x2_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u8_x2)))
-svuint8x2_t svclamp(svuint8x2_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u32_x2)))
-svuint32x2_t svclamp(svuint32x2_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u64_x2)))
-svuint64x2_t svclamp(svuint64x2_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u16_x2)))
-svuint16x2_t svclamp(svuint16x2_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f64_x4)))
-svfloat64x4_t svclamp(svfloat64x4_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f32_x4)))
-svfloat32x4_t svclamp(svfloat32x4_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f16_x4)))
-svfloat16x4_t svclamp(svfloat16x4_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s8_x4)))
-svint8x4_t svclamp(svint8x4_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s32_x4)))
-svint32x4_t svclamp(svint32x4_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s64_x4)))
-svint64x4_t svclamp(svint64x4_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s16_x4)))
-svint16x4_t svclamp(svint16x4_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u8_x4)))
-svuint8x4_t svclamp(svuint8x4_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u32_x4)))
-svuint32x4_t svclamp(svuint32x4_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u64_x4)))
-svuint64x4_t svclamp(svuint64x4_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u16_x4)))
-svuint16x4_t svclamp(svuint16x4_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_x2)))
-svbfloat16_t svcvt_bf16(svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_x2)))
-svfloat16_t svcvt_f16(svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_x2)))
-svint32x2_t svcvt_s32(svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_x2)))
-svuint32x2_t svcvt_u32(svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_x4)))
-svint32x4_t svcvt_s32(svfloat32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_x4)))
-svuint32x4_t svcvt_u32(svfloat32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_x2)))
-svfloat32x2_t svcvt_f32(svint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_x4)))
-svfloat32x4_t svcvt_f32(svint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_x2)))
-svfloat32x2_t svcvt_f32(svuint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_x4)))
-svfloat32x4_t svcvt_f32(svuint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtn_bf16_f32_x2)))
-svbfloat16_t svcvtn_bf16(svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtn_f16_f32_x2)))
-svfloat16_t svcvtn_f16(svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f64_x2)))
-svfloat64x2_t svmax(svfloat64x2_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f32_x2)))
-svfloat32x2_t svmax(svfloat32x2_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f16_x2)))
-svfloat16x2_t svmax(svfloat16x2_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s8_x2)))
-svint8x2_t svmax(svint8x2_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s32_x2)))
-svint32x2_t svmax(svint32x2_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s64_x2)))
-svint64x2_t svmax(svint64x2_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s16_x2)))
-svint16x2_t svmax(svint16x2_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u8_x2)))
-svuint8x2_t svmax(svuint8x2_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u32_x2)))
-svuint32x2_t svmax(svuint32x2_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u64_x2)))
-svuint64x2_t svmax(svuint64x2_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u16_x2)))
-svuint16x2_t svmax(svuint16x2_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f64_x4)))
-svfloat64x4_t svmax(svfloat64x4_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f32_x4)))
-svfloat32x4_t svmax(svfloat32x4_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f16_x4)))
-svfloat16x4_t svmax(svfloat16x4_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s8_x4)))
-svint8x4_t svmax(svint8x4_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s32_x4)))
-svint32x4_t svmax(svint32x4_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s64_x4)))
-svint64x4_t svmax(svint64x4_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s16_x4)))
-svint16x4_t svmax(svint16x4_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u8_x4)))
-svuint8x4_t svmax(svuint8x4_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u32_x4)))
-svuint32x4_t svmax(svuint32x4_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u64_x4)))
-svuint64x4_t svmax(svuint64x4_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u16_x4)))
-svuint16x4_t svmax(svuint16x4_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_x2)))
-svfloat64x2_t svmax(svfloat64x2_t, svfloat64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_x2)))
-svfloat32x2_t svmax(svfloat32x2_t, svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_x2)))
-svfloat16x2_t svmax(svfloat16x2_t, svfloat16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_x2)))
-svint8x2_t svmax(svint8x2_t, svint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_x2)))
-svint32x2_t svmax(svint32x2_t, svint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_x2)))
-svint64x2_t svmax(svint64x2_t, svint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_x2)))
-svint16x2_t svmax(svint16x2_t, svint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_x2)))
-svuint8x2_t svmax(svuint8x2_t, svuint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_x2)))
-svuint32x2_t svmax(svuint32x2_t, svuint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_x2)))
-svuint64x2_t svmax(svuint64x2_t, svuint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_x2)))
-svuint16x2_t svmax(svuint16x2_t, svuint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_x4)))
-svfloat64x4_t svmax(svfloat64x4_t, svfloat64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_x4)))
-svfloat32x4_t svmax(svfloat32x4_t, svfloat32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_x4)))
-svfloat16x4_t svmax(svfloat16x4_t, svfloat16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_x4)))
-svint8x4_t svmax(svint8x4_t, svint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_x4)))
-svint32x4_t svmax(svint32x4_t, svint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_x4)))
-svint64x4_t svmax(svint64x4_t, svint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_x4)))
-svint16x4_t svmax(svint16x4_t, svint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_x4)))
-svuint8x4_t svmax(svuint8x4_t, svuint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_x4)))
-svuint32x4_t svmax(svuint32x4_t, svuint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_x4)))
-svuint64x4_t svmax(svuint64x4_t, svuint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_x4)))
-svuint16x4_t svmax(svuint16x4_t, svuint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f64_x2)))
-svfloat64x2_t svmaxnm(svfloat64x2_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f32_x2)))
-svfloat32x2_t svmaxnm(svfloat32x2_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f16_x2)))
-svfloat16x2_t svmaxnm(svfloat16x2_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f64_x4)))
-svfloat64x4_t svmaxnm(svfloat64x4_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f32_x4)))
-svfloat32x4_t svmaxnm(svfloat32x4_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f16_x4)))
-svfloat16x4_t svmaxnm(svfloat16x4_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_x2)))
-svfloat64x2_t svmaxnm(svfloat64x2_t, svfloat64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_x2)))
-svfloat32x2_t svmaxnm(svfloat32x2_t, svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x2)))
-svfloat16x2_t svmaxnm(svfloat16x2_t, svfloat16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_x4)))
-svfloat64x4_t svmaxnm(svfloat64x4_t, svfloat64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_x4)))
-svfloat32x4_t svmaxnm(svfloat32x4_t, svfloat32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x4)))
-svfloat16x4_t svmaxnm(svfloat16x4_t, svfloat16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f64_x2)))
-svfloat64x2_t svmin(svfloat64x2_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f32_x2)))
-svfloat32x2_t svmin(svfloat32x2_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f16_x2)))
-svfloat16x2_t svmin(svfloat16x2_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s8_x2)))
-svint8x2_t svmin(svint8x2_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s32_x2)))
-svint32x2_t svmin(svint32x2_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s64_x2)))
-svint64x2_t svmin(svint64x2_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s16_x2)))
-svint16x2_t svmin(svint16x2_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u8_x2)))
-svuint8x2_t svmin(svuint8x2_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u32_x2)))
-svuint32x2_t svmin(svuint32x2_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u64_x2)))
-svuint64x2_t svmin(svuint64x2_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u16_x2)))
-svuint16x2_t svmin(svuint16x2_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f64_x4)))
-svfloat64x4_t svmin(svfloat64x4_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f32_x4)))
-svfloat32x4_t svmin(svfloat32x4_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f16_x4)))
-svfloat16x4_t svmin(svfloat16x4_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s8_x4)))
-svint8x4_t svmin(svint8x4_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s32_x4)))
-svint32x4_t svmin(svint32x4_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s64_x4)))
-svint64x4_t svmin(svint64x4_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s16_x4)))
-svint16x4_t svmin(svint16x4_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u8_x4)))
-svuint8x4_t svmin(svuint8x4_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u32_x4)))
-svuint32x4_t svmin(svuint32x4_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u64_x4)))
-svuint64x4_t svmin(svuint64x4_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u16_x4)))
-svuint16x4_t svmin(svuint16x4_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_x2)))
-svfloat64x2_t svmin(svfloat64x2_t, svfloat64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_x2)))
-svfloat32x2_t svmin(svfloat32x2_t, svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_x2)))
-svfloat16x2_t svmin(svfloat16x2_t, svfloat16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_x2)))
-svint8x2_t svmin(svint8x2_t, svint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_x2)))
-svint32x2_t svmin(svint32x2_t, svint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_x2)))
-svint64x2_t svmin(svint64x2_t, svint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_x2)))
-svint16x2_t svmin(svint16x2_t, svint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_x2)))
-svuint8x2_t svmin(svuint8x2_t, svuint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_x2)))
-svuint32x2_t svmin(svuint32x2_t, svuint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_x2)))
-svuint64x2_t svmin(svuint64x2_t, svuint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_x2)))
-svuint16x2_t svmin(svuint16x2_t, svuint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_x4)))
-svfloat64x4_t svmin(svfloat64x4_t, svfloat64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_x4)))
-svfloat32x4_t svmin(svfloat32x4_t, svfloat32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_x4)))
-svfloat16x4_t svmin(svfloat16x4_t, svfloat16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_x4)))
-svint8x4_t svmin(svint8x4_t, svint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_x4)))
-svint32x4_t svmin(svint32x4_t, svint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_x4)))
-svint64x4_t svmin(svint64x4_t, svint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_x4)))
-svint16x4_t svmin(svint16x4_t, svint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_x4)))
-svuint8x4_t svmin(svuint8x4_t, svuint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_x4)))
-svuint32x4_t svmin(svuint32x4_t, svuint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_x4)))
-svuint64x4_t svmin(svuint64x4_t, svuint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_x4)))
-svuint16x4_t svmin(svuint16x4_t, svuint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f64_x2)))
-svfloat64x2_t svminnm(svfloat64x2_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f32_x2)))
-svfloat32x2_t svminnm(svfloat32x2_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f16_x2)))
-svfloat16x2_t svminnm(svfloat16x2_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f64_x4)))
-svfloat64x4_t svminnm(svfloat64x4_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f32_x4)))
-svfloat32x4_t svminnm(svfloat32x4_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f16_x4)))
-svfloat16x4_t svminnm(svfloat16x4_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_x2)))
-svfloat64x2_t svminnm(svfloat64x2_t, svfloat64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_x2)))
-svfloat32x2_t svminnm(svfloat32x2_t, svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_x2)))
-svfloat16x2_t svminnm(svfloat16x2_t, svfloat16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_x4)))
-svfloat64x4_t svminnm(svfloat64x4_t, svfloat64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_x4)))
-svfloat32x4_t svminnm(svfloat32x4_t, svfloat32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_x4)))
-svfloat16x4_t svminnm(svfloat16x4_t, svfloat16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_s16_s32_x2)))
-svint16_t svqcvt_s16(svint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_s16_s64_x4)))
-svint16_t svqcvt_s16(svint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_s8_s32_x4)))
-svint8_t svqcvt_s8(svint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_s32_x2)))
-svuint16_t svqcvt_u16(svint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_u32_x2)))
-svuint16_t svqcvt_u16(svuint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_s64_x4)))
-svuint16_t svqcvt_u16(svint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_u64_x4)))
-svuint16_t svqcvt_u16(svuint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u8_s32_x4)))
-svuint8_t svqcvt_u8(svint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u8_u32_x4)))
-svuint8_t svqcvt_u8(svuint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_s16_s64_x4)))
-svint16_t svqcvtn_s16(svint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_s8_s32_x4)))
-svint8_t svqcvtn_s8(svint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_s64_x4)))
-svuint16_t svqcvtn_u16(svint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_u64_x4)))
-svuint16_t svqcvtn_u16(svuint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u8_s32_x4)))
-svuint8_t svqcvtn_u8(svint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u8_u32_x4)))
-svuint8_t svqcvtn_u8(svuint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s8_x2)))
-svint8x2_t svqdmulh(svint8x2_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s32_x2)))
-svint32x2_t svqdmulh(svint32x2_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s64_x2)))
-svint64x2_t svqdmulh(svint64x2_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s16_x2)))
-svint16x2_t svqdmulh(svint16x2_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s8_x4)))
-svint8x4_t svqdmulh(svint8x4_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s32_x4)))
-svint32x4_t svqdmulh(svint32x4_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s64_x4)))
-svint64x4_t svqdmulh(svint64x4_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s16_x4)))
-svint16x4_t svqdmulh(svint16x4_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s8_x2)))
-svint8x2_t svqdmulh(svint8x2_t, svint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s32_x2)))
-svint32x2_t svqdmulh(svint32x2_t, svint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s64_x2)))
-svint64x2_t svqdmulh(svint64x2_t, svint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s16_x2)))
-svint16x2_t svqdmulh(svint16x2_t, svint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s8_x4)))
-svint8x4_t svqdmulh(svint8x4_t, svint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s32_x4)))
-svint32x4_t svqdmulh(svint32x4_t, svint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s64_x4)))
-svint64x4_t svqdmulh(svint64x4_t, svint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s16_x4)))
-svint16x4_t svqdmulh(svint16x4_t, svint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_s16_s32_x2)))
-svint16_t svqrshr_s16(svint32x2_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_u16_u32_x2)))
-svuint16_t svqrshr_u16(svuint32x2_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_s8_s32_x4)))
-svint8_t svqrshr_s8(svint32x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_s16_s64_x4)))
-svint16_t svqrshr_s16(svint64x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_u8_u32_x4)))
-svuint8_t svqrshr_u8(svuint32x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_u16_u64_x4)))
-svuint16_t svqrshr_u16(svuint64x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_s8_s32_x4)))
-svint8_t svqrshrn_s8(svint32x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_s16_s64_x4)))
-svint16_t svqrshrn_s16(svint64x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_u8_u32_x4)))
-svuint8_t svqrshrn_u8(svuint32x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_u16_u64_x4)))
-svuint16_t svqrshrn_u16(svuint64x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshru_n_u16_s32_x2)))
-svuint16_t svqrshru_u16(svint32x2_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshru_n_u8_s32_x4)))
-svuint8_t svqrshru_u8(svint32x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshru_n_u16_s64_x4)))
-svuint16_t svqrshru_u16(svint64x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrun_n_u8_s32_x4)))
-svuint8_t svqrshrun_u8(svint32x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrun_n_u16_s64_x4)))
-svuint16_t svqrshrun_u16(svint64x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svreinterpret_b)))
-svbool_t svreinterpret(svcount_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svreinterpret_c)))
-svcount_t svreinterpret(svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_x2)))
-svfloat32x2_t svrinta(svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_x4)))
-svfloat32x4_t svrinta(svfloat32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_x2)))
-svfloat32x2_t svrintm(svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_x4)))
-svfloat32x4_t svrintm(svfloat32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_x2)))
-svfloat32x2_t svrintn(svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_x4)))
-svfloat32x4_t svrintn(svfloat32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_x2)))
-svfloat32x2_t svrintp(svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_x4)))
-svfloat32x4_t svrintp(svfloat32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s8_x2)))
-svint8x2_t svrshl(svint8x2_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s32_x2)))
-svint32x2_t svrshl(svint32x2_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s64_x2)))
-svint64x2_t svrshl(svint64x2_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s16_x2)))
-svint16x2_t svrshl(svint16x2_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u8_x2)))
-svuint8x2_t svrshl(svuint8x2_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u32_x2)))
-svuint32x2_t svrshl(svuint32x2_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u64_x2)))
-svuint64x2_t svrshl(svuint64x2_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u16_x2)))
-svuint16x2_t svrshl(svuint16x2_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s8_x4)))
-svint8x4_t svrshl(svint8x4_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s32_x4)))
-svint32x4_t svrshl(svint32x4_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s64_x4)))
-svint64x4_t svrshl(svint64x4_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s16_x4)))
-svint16x4_t svrshl(svint16x4_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u8_x4)))
-svuint8x4_t svrshl(svuint8x4_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u32_x4)))
-svuint32x4_t svrshl(svuint32x4_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u64_x4)))
-svuint64x4_t svrshl(svuint64x4_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u16_x4)))
-svuint16x4_t svrshl(svuint16x4_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_x2)))
-svint8x2_t svrshl(svint8x2_t, svint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_x2)))
-svint32x2_t svrshl(svint32x2_t, svint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_x2)))
-svint64x2_t svrshl(svint64x2_t, svint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_x2)))
-svint16x2_t svrshl(svint16x2_t, svint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_x2)))
-svuint8x2_t svrshl(svuint8x2_t, svuint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_x2)))
-svuint32x2_t svrshl(svuint32x2_t, svuint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_x2)))
-svuint64x2_t svrshl(svuint64x2_t, svuint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_x2)))
-svuint16x2_t svrshl(svuint16x2_t, svuint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_x4)))
-svint8x4_t svrshl(svint8x4_t, svint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_x4)))
-svint32x4_t svrshl(svint32x4_t, svint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_x4)))
-svint64x4_t svrshl(svint64x4_t, svint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_x4)))
-svint16x4_t svrshl(svint16x4_t, svint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_x4)))
-svuint8x4_t svrshl(svuint8x4_t, svuint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_x4)))
-svuint32x4_t svrshl(svuint32x4_t, svuint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_x4)))
-svuint64x4_t svrshl(svuint64x4_t, svuint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_x4)))
-svuint16x4_t svrshl(svuint16x4_t, svuint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8_x2)))
-svuint8x2_t svsel(svcount_t, svuint8x2_t, svuint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u32_x2)))
-svuint32x2_t svsel(svcount_t, svuint32x2_t, svuint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u64_x2)))
-svuint64x2_t svsel(svcount_t, svuint64x2_t, svuint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u16_x2)))
-svuint16x2_t svsel(svcount_t, svuint16x2_t, svuint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_bf16_x2)))
-svbfloat16x2_t svsel(svcount_t, svbfloat16x2_t, svbfloat16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s8_x2)))
-svint8x2_t svsel(svcount_t, svint8x2_t, svint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f64_x2)))
-svfloat64x2_t svsel(svcount_t, svfloat64x2_t, svfloat64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f32_x2)))
-svfloat32x2_t svsel(svcount_t, svfloat32x2_t, svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16_x2)))
-svfloat16x2_t svsel(svcount_t, svfloat16x2_t, svfloat16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s32_x2)))
-svint32x2_t svsel(svcount_t, svint32x2_t, svint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s64_x2)))
-svint64x2_t svsel(svcount_t, svint64x2_t, svint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s16_x2)))
-svint16x2_t svsel(svcount_t, svint16x2_t, svint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8_x4)))
-svuint8x4_t svsel(svcount_t, svuint8x4_t, svuint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u32_x4)))
-svuint32x4_t svsel(svcount_t, svuint32x4_t, svuint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u64_x4)))
-svuint64x4_t svsel(svcount_t, svuint64x4_t, svuint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u16_x4)))
-svuint16x4_t svsel(svcount_t, svuint16x4_t, svuint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_bf16_x4)))
-svbfloat16x4_t svsel(svcount_t, svbfloat16x4_t, svbfloat16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s8_x4)))
-svint8x4_t svsel(svcount_t, svint8x4_t, svint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f64_x4)))
-svfloat64x4_t svsel(svcount_t, svfloat64x4_t, svfloat64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f32_x4)))
-svfloat32x4_t svsel(svcount_t, svfloat32x4_t, svfloat32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16_x4)))
-svfloat16x4_t svsel(svcount_t, svfloat16x4_t, svfloat16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s32_x4)))
-svint32x4_t svsel(svcount_t, svint32x4_t, svint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s64_x4)))
-svint64x4_t svsel(svcount_t, svint64x4_t, svint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s16_x4)))
-svint16x4_t svsel(svcount_t, svint16x4_t, svint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s32_s16_x2)))
-svint32x2_t svunpk_s32(svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s64_s32_x2)))
-svint64x2_t svunpk_s64(svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s16_s8_x2)))
-svint16x2_t svunpk_s16(svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u32_u16_x2)))
-svuint32x2_t svunpk_u32(svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u64_u32_x2)))
-svuint64x2_t svunpk_u64(svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u16_u8_x2)))
-svuint16x2_t svunpk_u16(svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s32_s16_x4)))
-svint32x4_t svunpk_s32(svint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s64_s32_x4)))
-svint64x4_t svunpk_s64(svint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s16_s8_x4)))
-svint16x4_t svunpk_s16(svint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u32_u16_x4)))
-svuint32x4_t svunpk_u32(svuint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u64_u32_x4)))
-svuint64x4_t svunpk_u64(svuint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u16_u8_x4)))
-svuint16x4_t svunpk_u16(svuint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u8_x2)))
-svuint8x2_t svuzp(svuint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u32_x2)))
-svuint32x2_t svuzp(svuint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u64_x2)))
-svuint64x2_t svuzp(svuint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u16_x2)))
-svuint16x2_t svuzp(svuint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_bf16_x2)))
-svbfloat16x2_t svuzp(svbfloat16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s8_x2)))
-svint8x2_t svuzp(svint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f64_x2)))
-svfloat64x2_t svuzp(svfloat64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f32_x2)))
-svfloat32x2_t svuzp(svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f16_x2)))
-svfloat16x2_t svuzp(svfloat16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s32_x2)))
-svint32x2_t svuzp(svint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s64_x2)))
-svint64x2_t svuzp(svint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s16_x2)))
-svint16x2_t svuzp(svint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u8_x4)))
-svuint8x4_t svuzp(svuint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u32_x4)))
-svuint32x4_t svuzp(svuint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u64_x4)))
-svuint64x4_t svuzp(svuint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u16_x4)))
-svuint16x4_t svuzp(svuint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_bf16_x4)))
-svbfloat16x4_t svuzp(svbfloat16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s8_x4)))
-svint8x4_t svuzp(svint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f64_x4)))
-svfloat64x4_t svuzp(svfloat64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f32_x4)))
-svfloat32x4_t svuzp(svfloat32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f16_x4)))
-svfloat16x4_t svuzp(svfloat16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s32_x4)))
-svint32x4_t svuzp(svint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s64_x4)))
-svint64x4_t svuzp(svint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s16_x4)))
-svint16x4_t svuzp(svint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u8_x2)))
-svuint8x2_t svuzpq(svuint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u32_x2)))
-svuint32x2_t svuzpq(svuint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u64_x2)))
-svuint64x2_t svuzpq(svuint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u16_x2)))
-svuint16x2_t svuzpq(svuint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_bf16_x2)))
-svbfloat16x2_t svuzpq(svbfloat16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s8_x2)))
-svint8x2_t svuzpq(svint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f64_x2)))
-svfloat64x2_t svuzpq(svfloat64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f32_x2)))
-svfloat32x2_t svuzpq(svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f16_x2)))
-svfloat16x2_t svuzpq(svfloat16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s32_x2)))
-svint32x2_t svuzpq(svint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s64_x2)))
-svint64x2_t svuzpq(svint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s16_x2)))
-svint16x2_t svuzpq(svint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u8_x4)))
-svuint8x4_t svuzpq(svuint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u32_x4)))
-svuint32x4_t svuzpq(svuint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u64_x4)))
-svuint64x4_t svuzpq(svuint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u16_x4)))
-svuint16x4_t svuzpq(svuint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_bf16_x4)))
-svbfloat16x4_t svuzpq(svbfloat16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s8_x4)))
-svint8x4_t svuzpq(svint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f64_x4)))
-svfloat64x4_t svuzpq(svfloat64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f32_x4)))
-svfloat32x4_t svuzpq(svfloat32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f16_x4)))
-svfloat16x4_t svuzpq(svfloat16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s32_x4)))
-svint32x4_t svuzpq(svint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s64_x4)))
-svint64x4_t svuzpq(svint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s16_x4)))
-svint16x4_t svuzpq(svint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u8_x2)))
-svuint8x2_t svzip(svuint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u32_x2)))
-svuint32x2_t svzip(svuint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u64_x2)))
-svuint64x2_t svzip(svuint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u16_x2)))
-svuint16x2_t svzip(svuint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_bf16_x2)))
-svbfloat16x2_t svzip(svbfloat16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s8_x2)))
-svint8x2_t svzip(svint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f64_x2)))
-svfloat64x2_t svzip(svfloat64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f32_x2)))
-svfloat32x2_t svzip(svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f16_x2)))
-svfloat16x2_t svzip(svfloat16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s32_x2)))
-svint32x2_t svzip(svint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s64_x2)))
-svint64x2_t svzip(svint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s16_x2)))
-svint16x2_t svzip(svint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u8_x4)))
-svuint8x4_t svzip(svuint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u32_x4)))
-svuint32x4_t svzip(svuint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u64_x4)))
-svuint64x4_t svzip(svuint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u16_x4)))
-svuint16x4_t svzip(svuint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_bf16_x4)))
-svbfloat16x4_t svzip(svbfloat16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s8_x4)))
-svint8x4_t svzip(svint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f64_x4)))
-svfloat64x4_t svzip(svfloat64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f32_x4)))
-svfloat32x4_t svzip(svfloat32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f16_x4)))
-svfloat16x4_t svzip(svfloat16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s32_x4)))
-svint32x4_t svzip(svint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s64_x4)))
-svint64x4_t svzip(svint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s16_x4)))
-svint16x4_t svzip(svint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u8_x2)))
-svuint8x2_t svzipq(svuint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u32_x2)))
-svuint32x2_t svzipq(svuint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u64_x2)))
-svuint64x2_t svzipq(svuint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u16_x2)))
-svuint16x2_t svzipq(svuint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_bf16_x2)))
-svbfloat16x2_t svzipq(svbfloat16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s8_x2)))
-svint8x2_t svzipq(svint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f64_x2)))
-svfloat64x2_t svzipq(svfloat64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f32_x2)))
-svfloat32x2_t svzipq(svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f16_x2)))
-svfloat16x2_t svzipq(svfloat16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s32_x2)))
-svint32x2_t svzipq(svint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s64_x2)))
-svint64x2_t svzipq(svint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s16_x2)))
-svint16x2_t svzipq(svint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u8_x4)))
-svuint8x4_t svzipq(svuint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u32_x4)))
-svuint32x4_t svzipq(svuint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u64_x4)))
-svuint64x4_t svzipq(svuint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u16_x4)))
-svuint16x4_t svzipq(svuint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_bf16_x4)))
-svbfloat16x4_t svzipq(svbfloat16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s8_x4)))
-svint8x4_t svzipq(svint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f64_x4)))
-svfloat64x4_t svzipq(svfloat64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f32_x4)))
-svfloat32x4_t svzipq(svfloat32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f16_x4)))
-svfloat16x4_t svzipq(svfloat16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s32_x4)))
-svint32x4_t svzipq(svint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s64_x4)))
-svint64x4_t svzipq(svint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s16_x4)))
-svint16x4_t svzipq(svint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_s16_s32_x2)))
-svint16_t svqcvtn_s16_s32_x2(svint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_s32_x2)))
-svuint16_t svqcvtn_u16_s32_x2(svint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_u32_x2)))
-svuint16_t svqcvtn_u16_u32_x2(svuint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_s16_s32_x2)))
-svint16_t svqcvtn_s16(svint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_s32_x2)))
-svuint16_t svqcvtn_u16(svint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_u32_x2)))
-svuint16_t svqcvtn_u16(svuint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f64_m)))
-svfloat64_t svabd_n_f64_m(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f32_m)))
-svfloat32_t svabd_n_f32_m(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f16_m)))
-svfloat16_t svabd_n_f16_m(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f64_x)))
-svfloat64_t svabd_n_f64_x(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f32_x)))
-svfloat32_t svabd_n_f32_x(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f16_x)))
-svfloat16_t svabd_n_f16_x(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f64_z)))
-svfloat64_t svabd_n_f64_z(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f32_z)))
-svfloat32_t svabd_n_f32_z(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f16_z)))
-svfloat16_t svabd_n_f16_z(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s8_m)))
-svint8_t svabd_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s32_m)))
-svint32_t svabd_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s64_m)))
-svint64_t svabd_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s16_m)))
-svint16_t svabd_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s8_x)))
-svint8_t svabd_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s32_x)))
-svint32_t svabd_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s64_x)))
-svint64_t svabd_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s16_x)))
-svint16_t svabd_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s8_z)))
-svint8_t svabd_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s32_z)))
-svint32_t svabd_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s64_z)))
-svint64_t svabd_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s16_z)))
-svint16_t svabd_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u8_m)))
-svuint8_t svabd_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u32_m)))
-svuint32_t svabd_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u64_m)))
-svuint64_t svabd_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u16_m)))
-svuint16_t svabd_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u8_x)))
-svuint8_t svabd_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u32_x)))
-svuint32_t svabd_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u64_x)))
-svuint64_t svabd_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u16_x)))
-svuint16_t svabd_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u8_z)))
-svuint8_t svabd_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u32_z)))
-svuint32_t svabd_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u64_z)))
-svuint64_t svabd_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u16_z)))
-svuint16_t svabd_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f64_m)))
-svfloat64_t svabd_f64_m(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f32_m)))
-svfloat32_t svabd_f32_m(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f16_m)))
-svfloat16_t svabd_f16_m(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f64_x)))
-svfloat64_t svabd_f64_x(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f32_x)))
-svfloat32_t svabd_f32_x(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f16_x)))
-svfloat16_t svabd_f16_x(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f64_z)))
-svfloat64_t svabd_f64_z(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f32_z)))
-svfloat32_t svabd_f32_z(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f16_z)))
-svfloat16_t svabd_f16_z(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s8_m)))
-svint8_t svabd_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s32_m)))
-svint32_t svabd_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s64_m)))
-svint64_t svabd_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s16_m)))
-svint16_t svabd_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s8_x)))
-svint8_t svabd_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s32_x)))
-svint32_t svabd_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s64_x)))
-svint64_t svabd_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s16_x)))
-svint16_t svabd_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s8_z)))
-svint8_t svabd_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s32_z)))
-svint32_t svabd_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s64_z)))
-svint64_t svabd_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s16_z)))
-svint16_t svabd_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u8_m)))
-svuint8_t svabd_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u32_m)))
-svuint32_t svabd_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u64_m)))
-svuint64_t svabd_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u16_m)))
-svuint16_t svabd_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u8_x)))
-svuint8_t svabd_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u32_x)))
-svuint32_t svabd_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u64_x)))
-svuint64_t svabd_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u16_x)))
-svuint16_t svabd_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u8_z)))
-svuint8_t svabd_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u32_z)))
-svuint32_t svabd_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u64_z)))
-svuint64_t svabd_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u16_z)))
-svuint16_t svabd_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f64_m)))
-svfloat64_t svabs_f64_m(svfloat64_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f32_m)))
-svfloat32_t svabs_f32_m(svfloat32_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f16_m)))
-svfloat16_t svabs_f16_m(svfloat16_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f64_x)))
-svfloat64_t svabs_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f32_x)))
-svfloat32_t svabs_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f16_x)))
-svfloat16_t svabs_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f64_z)))
-svfloat64_t svabs_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f32_z)))
-svfloat32_t svabs_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f16_z)))
-svfloat16_t svabs_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s8_m)))
-svint8_t svabs_s8_m(svint8_t, svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s32_m)))
-svint32_t svabs_s32_m(svint32_t, svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s64_m)))
-svint64_t svabs_s64_m(svint64_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s16_m)))
-svint16_t svabs_s16_m(svint16_t, svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s8_x)))
-svint8_t svabs_s8_x(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s32_x)))
-svint32_t svabs_s32_x(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s64_x)))
-svint64_t svabs_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s16_x)))
-svint16_t svabs_s16_x(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s8_z)))
-svint8_t svabs_s8_z(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s32_z)))
-svint32_t svabs_s32_z(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s64_z)))
-svint64_t svabs_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s16_z)))
-svint16_t svabs_s16_z(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_n_f64)))
-svbool_t svacge_n_f64(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_n_f32)))
-svbool_t svacge_n_f32(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_n_f16)))
-svbool_t svacge_n_f16(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_f64)))
-svbool_t svacge_f64(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_f32)))
-svbool_t svacge_f32(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_f16)))
-svbool_t svacge_f16(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_n_f64)))
-svbool_t svacgt_n_f64(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_n_f32)))
-svbool_t svacgt_n_f32(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_n_f16)))
-svbool_t svacgt_n_f16(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_f64)))
-svbool_t svacgt_f64(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_f32)))
-svbool_t svacgt_f32(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_f16)))
-svbool_t svacgt_f16(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_n_f64)))
-svbool_t svacle_n_f64(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_n_f32)))
-svbool_t svacle_n_f32(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_n_f16)))
-svbool_t svacle_n_f16(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_f64)))
-svbool_t svacle_f64(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_f32)))
-svbool_t svacle_f32(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_f16)))
-svbool_t svacle_f16(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_n_f64)))
-svbool_t svaclt_n_f64(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_n_f32)))
-svbool_t svaclt_n_f32(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_n_f16)))
-svbool_t svaclt_n_f16(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_f64)))
-svbool_t svaclt_f64(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_f32)))
-svbool_t svaclt_f32(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_f16)))
-svbool_t svaclt_f16(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f64_m)))
-svfloat64_t svadd_n_f64_m(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f32_m)))
-svfloat32_t svadd_n_f32_m(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f16_m)))
-svfloat16_t svadd_n_f16_m(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f64_x)))
-svfloat64_t svadd_n_f64_x(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f32_x)))
-svfloat32_t svadd_n_f32_x(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f16_x)))
-svfloat16_t svadd_n_f16_x(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f64_z)))
-svfloat64_t svadd_n_f64_z(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f32_z)))
-svfloat32_t svadd_n_f32_z(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f16_z)))
-svfloat16_t svadd_n_f16_z(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u8_m)))
-svuint8_t svadd_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u32_m)))
-svuint32_t svadd_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u64_m)))
-svuint64_t svadd_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u16_m)))
-svuint16_t svadd_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s8_m)))
-svint8_t svadd_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s32_m)))
-svint32_t svadd_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s64_m)))
-svint64_t svadd_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s16_m)))
-svint16_t svadd_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u8_x)))
-svuint8_t svadd_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u32_x)))
-svuint32_t svadd_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u64_x)))
-svuint64_t svadd_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u16_x)))
-svuint16_t svadd_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s8_x)))
-svint8_t svadd_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s32_x)))
-svint32_t svadd_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s64_x)))
-svint64_t svadd_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s16_x)))
-svint16_t svadd_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u8_z)))
-svuint8_t svadd_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u32_z)))
-svuint32_t svadd_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u64_z)))
-svuint64_t svadd_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u16_z)))
-svuint16_t svadd_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s8_z)))
-svint8_t svadd_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s32_z)))
-svint32_t svadd_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s64_z)))
-svint64_t svadd_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s16_z)))
-svint16_t svadd_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f64_m)))
-svfloat64_t svadd_f64_m(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f32_m)))
-svfloat32_t svadd_f32_m(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f16_m)))
-svfloat16_t svadd_f16_m(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f64_x)))
-svfloat64_t svadd_f64_x(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f32_x)))
-svfloat32_t svadd_f32_x(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f16_x)))
-svfloat16_t svadd_f16_x(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f64_z)))
-svfloat64_t svadd_f64_z(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f32_z)))
-svfloat32_t svadd_f32_z(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f16_z)))
-svfloat16_t svadd_f16_z(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u8_m)))
-svuint8_t svadd_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u32_m)))
-svuint32_t svadd_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u64_m)))
-svuint64_t svadd_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u16_m)))
-svuint16_t svadd_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s8_m)))
-svint8_t svadd_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s32_m)))
-svint32_t svadd_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s64_m)))
-svint64_t svadd_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s16_m)))
-svint16_t svadd_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u8_x)))
-svuint8_t svadd_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u32_x)))
-svuint32_t svadd_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u64_x)))
-svuint64_t svadd_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u16_x)))
-svuint16_t svadd_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s8_x)))
-svint8_t svadd_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s32_x)))
-svint32_t svadd_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s64_x)))
-svint64_t svadd_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s16_x)))
-svint16_t svadd_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u8_z)))
-svuint8_t svadd_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u32_z)))
-svuint32_t svadd_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u64_z)))
-svuint64_t svadd_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u16_z)))
-svuint16_t svadd_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s8_z)))
-svint8_t svadd_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s32_z)))
-svint32_t svadd_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s64_z)))
-svint64_t svadd_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s16_z)))
-svint16_t svadd_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadda_f64)))
-float64_t svadda_f64(svbool_t, float64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadda_f32)))
-float32_t svadda_f32(svbool_t, float32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadda_f16)))
-float16_t svadda_f16(svbool_t, float16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s8)))
-int64_t svaddv_s8(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s32)))
-int64_t svaddv_s32(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s64)))
-int64_t svaddv_s64(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s16)))
-int64_t svaddv_s16(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u8)))
-uint64_t svaddv_u8(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u32)))
-uint64_t svaddv_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u64)))
-uint64_t svaddv_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u16)))
-uint64_t svaddv_u16(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_f64)))
-float64_t svaddv_f64(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_f32)))
-float32_t svaddv_f32(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_f16)))
-float16_t svaddv_f16(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u32base_u32offset)))
-svuint32_t svadrb_u32base_u32offset(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u64base_u64offset)))
-svuint64_t svadrb_u64base_u64offset(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u32base_s32offset)))
-svuint32_t svadrb_u32base_s32offset(svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u64base_s64offset)))
-svuint64_t svadrb_u64base_s64offset(svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u32base_u32index)))
-svuint32_t svadrd_u32base_u32index(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u64base_u64index)))
-svuint64_t svadrd_u64base_u64index(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u32base_s32index)))
-svuint32_t svadrd_u32base_s32index(svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u64base_s64index)))
-svuint64_t svadrd_u64base_s64index(svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u32base_u32index)))
-svuint32_t svadrh_u32base_u32index(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u64base_u64index)))
-svuint64_t svadrh_u64base_u64index(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u32base_s32index)))
-svuint32_t svadrh_u32base_s32index(svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u64base_s64index)))
-svuint64_t svadrh_u64base_s64index(svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u32base_u32index)))
-svuint32_t svadrw_u32base_u32index(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u64base_u64index)))
-svuint64_t svadrw_u64base_u64index(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u32base_s32index)))
-svuint32_t svadrw_u32base_s32index(svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u64base_s64index)))
-svuint64_t svadrw_u64base_s64index(svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_b_z)))
-svbool_t svand_b_z(svbool_t, svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u8_m)))
-svuint8_t svand_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u32_m)))
-svuint32_t svand_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u64_m)))
-svuint64_t svand_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u16_m)))
-svuint16_t svand_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s8_m)))
-svint8_t svand_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s32_m)))
-svint32_t svand_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s64_m)))
-svint64_t svand_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s16_m)))
-svint16_t svand_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u8_x)))
-svuint8_t svand_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u32_x)))
-svuint32_t svand_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u64_x)))
-svuint64_t svand_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u16_x)))
-svuint16_t svand_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s8_x)))
-svint8_t svand_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s32_x)))
-svint32_t svand_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s64_x)))
-svint64_t svand_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s16_x)))
-svint16_t svand_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u8_z)))
-svuint8_t svand_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u32_z)))
-svuint32_t svand_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u64_z)))
-svuint64_t svand_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u16_z)))
-svuint16_t svand_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s8_z)))
-svint8_t svand_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s32_z)))
-svint32_t svand_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s64_z)))
-svint64_t svand_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s16_z)))
-svint16_t svand_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u8_m)))
-svuint8_t svand_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u32_m)))
-svuint32_t svand_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u64_m)))
-svuint64_t svand_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u16_m)))
-svuint16_t svand_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s8_m)))
-svint8_t svand_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s32_m)))
-svint32_t svand_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s64_m)))
-svint64_t svand_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s16_m)))
-svint16_t svand_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u8_x)))
-svuint8_t svand_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u32_x)))
-svuint32_t svand_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u64_x)))
-svuint64_t svand_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u16_x)))
-svuint16_t svand_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s8_x)))
-svint8_t svand_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s32_x)))
-svint32_t svand_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s64_x)))
-svint64_t svand_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s16_x)))
-svint16_t svand_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u8_z)))
-svuint8_t svand_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u32_z)))
-svuint32_t svand_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u64_z)))
-svuint64_t svand_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u16_z)))
-svuint16_t svand_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s8_z)))
-svint8_t svand_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s32_z)))
-svint32_t svand_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s64_z)))
-svint64_t svand_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s16_z)))
-svint16_t svand_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u8)))
-uint8_t svandv_u8(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u32)))
-uint32_t svandv_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u64)))
-uint64_t svandv_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u16)))
-uint16_t svandv_u16(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s8)))
-int8_t svandv_s8(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s32)))
-int32_t svandv_s32(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s64)))
-int64_t svandv_s64(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s16)))
-int16_t svandv_s16(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s8_m)))
-svint8_t svasr_n_s8_m(svbool_t, svint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s32_m)))
-svint32_t svasr_n_s32_m(svbool_t, svint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s64_m)))
-svint64_t svasr_n_s64_m(svbool_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s16_m)))
-svint16_t svasr_n_s16_m(svbool_t, svint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s8_x)))
-svint8_t svasr_n_s8_x(svbool_t, svint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s32_x)))
-svint32_t svasr_n_s32_x(svbool_t, svint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s64_x)))
-svint64_t svasr_n_s64_x(svbool_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s16_x)))
-svint16_t svasr_n_s16_x(svbool_t, svint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s8_z)))
-svint8_t svasr_n_s8_z(svbool_t, svint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s32_z)))
-svint32_t svasr_n_s32_z(svbool_t, svint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s64_z)))
-svint64_t svasr_n_s64_z(svbool_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s16_z)))
-svint16_t svasr_n_s16_z(svbool_t, svint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s8_m)))
-svint8_t svasr_s8_m(svbool_t, svint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s32_m)))
-svint32_t svasr_s32_m(svbool_t, svint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s64_m)))
-svint64_t svasr_s64_m(svbool_t, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s16_m)))
-svint16_t svasr_s16_m(svbool_t, svint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s8_x)))
-svint8_t svasr_s8_x(svbool_t, svint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s32_x)))
-svint32_t svasr_s32_x(svbool_t, svint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s64_x)))
-svint64_t svasr_s64_x(svbool_t, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s16_x)))
-svint16_t svasr_s16_x(svbool_t, svint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s8_z)))
-svint8_t svasr_s8_z(svbool_t, svint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s32_z)))
-svint32_t svasr_s32_z(svbool_t, svint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s64_z)))
-svint64_t svasr_s64_z(svbool_t, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s16_z)))
-svint16_t svasr_s16_z(svbool_t, svint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s8_m)))
-svint8_t svasr_wide_n_s8_m(svbool_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s32_m)))
-svint32_t svasr_wide_n_s32_m(svbool_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s16_m)))
-svint16_t svasr_wide_n_s16_m(svbool_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s8_x)))
-svint8_t svasr_wide_n_s8_x(svbool_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s32_x)))
-svint32_t svasr_wide_n_s32_x(svbool_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s16_x)))
-svint16_t svasr_wide_n_s16_x(svbool_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s8_z)))
-svint8_t svasr_wide_n_s8_z(svbool_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s32_z)))
-svint32_t svasr_wide_n_s32_z(svbool_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s16_z)))
-svint16_t svasr_wide_n_s16_z(svbool_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s8_m)))
-svint8_t svasr_wide_s8_m(svbool_t, svint8_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s32_m)))
-svint32_t svasr_wide_s32_m(svbool_t, svint32_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s16_m)))
-svint16_t svasr_wide_s16_m(svbool_t, svint16_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s8_x)))
-svint8_t svasr_wide_s8_x(svbool_t, svint8_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s32_x)))
-svint32_t svasr_wide_s32_x(svbool_t, svint32_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s16_x)))
-svint16_t svasr_wide_s16_x(svbool_t, svint16_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s8_z)))
-svint8_t svasr_wide_s8_z(svbool_t, svint8_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s32_z)))
-svint32_t svasr_wide_s32_z(svbool_t, svint32_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s16_z)))
-svint16_t svasr_wide_s16_z(svbool_t, svint16_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s8_m)))
-svint8_t svasrd_n_s8_m(svbool_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s32_m)))
-svint32_t svasrd_n_s32_m(svbool_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s64_m)))
-svint64_t svasrd_n_s64_m(svbool_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s16_m)))
-svint16_t svasrd_n_s16_m(svbool_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s8_x)))
-svint8_t svasrd_n_s8_x(svbool_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s32_x)))
-svint32_t svasrd_n_s32_x(svbool_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s64_x)))
-svint64_t svasrd_n_s64_x(svbool_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s16_x)))
-svint16_t svasrd_n_s16_x(svbool_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s8_z)))
-svint8_t svasrd_n_s8_z(svbool_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s32_z)))
-svint32_t svasrd_n_s32_z(svbool_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s64_z)))
-svint64_t svasrd_n_s64_z(svbool_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s16_z)))
-svint16_t svasrd_n_s16_z(svbool_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_b_z)))
-svbool_t svbic_b_z(svbool_t, svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u8_m)))
-svuint8_t svbic_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u32_m)))
-svuint32_t svbic_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u64_m)))
-svuint64_t svbic_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u16_m)))
-svuint16_t svbic_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s8_m)))
-svint8_t svbic_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s32_m)))
-svint32_t svbic_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s64_m)))
-svint64_t svbic_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s16_m)))
-svint16_t svbic_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u8_x)))
-svuint8_t svbic_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u32_x)))
-svuint32_t svbic_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u64_x)))
-svuint64_t svbic_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u16_x)))
-svuint16_t svbic_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s8_x)))
-svint8_t svbic_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s32_x)))
-svint32_t svbic_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s64_x)))
-svint64_t svbic_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s16_x)))
-svint16_t svbic_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u8_z)))
-svuint8_t svbic_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u32_z)))
-svuint32_t svbic_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u64_z)))
-svuint64_t svbic_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u16_z)))
-svuint16_t svbic_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s8_z)))
-svint8_t svbic_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s32_z)))
-svint32_t svbic_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s64_z)))
-svint64_t svbic_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s16_z)))
-svint16_t svbic_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u8_m)))
-svuint8_t svbic_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u32_m)))
-svuint32_t svbic_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u64_m)))
-svuint64_t svbic_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u16_m)))
-svuint16_t svbic_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s8_m)))
-svint8_t svbic_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s32_m)))
-svint32_t svbic_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s64_m)))
-svint64_t svbic_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s16_m)))
-svint16_t svbic_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u8_x)))
-svuint8_t svbic_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u32_x)))
-svuint32_t svbic_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u64_x)))
-svuint64_t svbic_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u16_x)))
-svuint16_t svbic_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s8_x)))
-svint8_t svbic_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s32_x)))
-svint32_t svbic_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s64_x)))
-svint64_t svbic_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s16_x)))
-svint16_t svbic_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u8_z)))
-svuint8_t svbic_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u32_z)))
-svuint32_t svbic_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u64_z)))
-svuint64_t svbic_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u16_z)))
-svuint16_t svbic_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s8_z)))
-svint8_t svbic_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s32_z)))
-svint32_t svbic_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s64_z)))
-svint64_t svbic_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s16_z)))
-svint16_t svbic_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrka_b_m)))
-svbool_t svbrka_b_m(svbool_t, svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrka_b_z)))
-svbool_t svbrka_b_z(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkb_b_m)))
-svbool_t svbrkb_b_m(svbool_t, svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkb_b_z)))
-svbool_t svbrkb_b_z(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkn_b_z)))
-svbool_t svbrkn_b_z(svbool_t, svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkpa_b_z)))
-svbool_t svbrkpa_b_z(svbool_t, svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkpb_b_z)))
-svbool_t svbrkpb_b_z(svbool_t, svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f64_m)))
-svfloat64_t svcadd_f64_m(svbool_t, svfloat64_t, svfloat64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f32_m)))
-svfloat32_t svcadd_f32_m(svbool_t, svfloat32_t, svfloat32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f16_m)))
-svfloat16_t svcadd_f16_m(svbool_t, svfloat16_t, svfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f64_x)))
-svfloat64_t svcadd_f64_x(svbool_t, svfloat64_t, svfloat64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f32_x)))
-svfloat32_t svcadd_f32_x(svbool_t, svfloat32_t, svfloat32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f16_x)))
-svfloat16_t svcadd_f16_x(svbool_t, svfloat16_t, svfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f64_z)))
-svfloat64_t svcadd_f64_z(svbool_t, svfloat64_t, svfloat64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f32_z)))
-svfloat32_t svcadd_f32_z(svbool_t, svfloat32_t, svfloat32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f16_z)))
-svfloat16_t svcadd_f16_z(svbool_t, svfloat16_t, svfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u8)))
-uint8_t svclasta_n_u8(svbool_t, uint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u32)))
-uint32_t svclasta_n_u32(svbool_t, uint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u64)))
-uint64_t svclasta_n_u64(svbool_t, uint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u16)))
-uint16_t svclasta_n_u16(svbool_t, uint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s8)))
-int8_t svclasta_n_s8(svbool_t, int8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_f64)))
-float64_t svclasta_n_f64(svbool_t, float64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_f32)))
-float32_t svclasta_n_f32(svbool_t, float32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_f16)))
-float16_t svclasta_n_f16(svbool_t, float16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s32)))
-int32_t svclasta_n_s32(svbool_t, int32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s64)))
-int64_t svclasta_n_s64(svbool_t, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s16)))
-int16_t svclasta_n_s16(svbool_t, int16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u8)))
-svuint8_t svclasta_u8(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u32)))
-svuint32_t svclasta_u32(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u64)))
-svuint64_t svclasta_u64(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u16)))
-svuint16_t svclasta_u16(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s8)))
-svint8_t svclasta_s8(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_f64)))
-svfloat64_t svclasta_f64(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_f32)))
-svfloat32_t svclasta_f32(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_f16)))
-svfloat16_t svclasta_f16(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s32)))
-svint32_t svclasta_s32(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s64)))
-svint64_t svclasta_s64(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s16)))
-svint16_t svclasta_s16(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u8)))
-uint8_t svclastb_n_u8(svbool_t, uint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u32)))
-uint32_t svclastb_n_u32(svbool_t, uint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u64)))
-uint64_t svclastb_n_u64(svbool_t, uint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u16)))
-uint16_t svclastb_n_u16(svbool_t, uint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s8)))
-int8_t svclastb_n_s8(svbool_t, int8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_f64)))
-float64_t svclastb_n_f64(svbool_t, float64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_f32)))
-float32_t svclastb_n_f32(svbool_t, float32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_f16)))
-float16_t svclastb_n_f16(svbool_t, float16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s32)))
-int32_t svclastb_n_s32(svbool_t, int32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s64)))
-int64_t svclastb_n_s64(svbool_t, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s16)))
-int16_t svclastb_n_s16(svbool_t, int16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u8)))
-svuint8_t svclastb_u8(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u32)))
-svuint32_t svclastb_u32(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u64)))
-svuint64_t svclastb_u64(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u16)))
-svuint16_t svclastb_u16(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s8)))
-svint8_t svclastb_s8(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_f64)))
-svfloat64_t svclastb_f64(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_f32)))
-svfloat32_t svclastb_f32(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_f16)))
-svfloat16_t svclastb_f16(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s32)))
-svint32_t svclastb_s32(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s64)))
-svint64_t svclastb_s64(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s16)))
-svint16_t svclastb_s16(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s8_m)))
-svuint8_t svcls_s8_m(svuint8_t, svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s32_m)))
-svuint32_t svcls_s32_m(svuint32_t, svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s64_m)))
-svuint64_t svcls_s64_m(svuint64_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s16_m)))
-svuint16_t svcls_s16_m(svuint16_t, svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s8_x)))
-svuint8_t svcls_s8_x(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s32_x)))
-svuint32_t svcls_s32_x(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s64_x)))
-svuint64_t svcls_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s16_x)))
-svuint16_t svcls_s16_x(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s8_z)))
-svuint8_t svcls_s8_z(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s32_z)))
-svuint32_t svcls_s32_z(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s64_z)))
-svuint64_t svcls_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s16_z)))
-svuint16_t svcls_s16_z(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u8_m)))
-svuint8_t svclz_u8_m(svuint8_t, svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u32_m)))
-svuint32_t svclz_u32_m(svuint32_t, svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u64_m)))
-svuint64_t svclz_u64_m(svuint64_t, svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u16_m)))
-svuint16_t svclz_u16_m(svuint16_t, svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s8_m)))
-svuint8_t svclz_s8_m(svuint8_t, svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s32_m)))
-svuint32_t svclz_s32_m(svuint32_t, svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s64_m)))
-svuint64_t svclz_s64_m(svuint64_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s16_m)))
-svuint16_t svclz_s16_m(svuint16_t, svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u8_x)))
-svuint8_t svclz_u8_x(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u32_x)))
-svuint32_t svclz_u32_x(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u64_x)))
-svuint64_t svclz_u64_x(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u16_x)))
-svuint16_t svclz_u16_x(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s8_x)))
-svuint8_t svclz_s8_x(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s32_x)))
-svuint32_t svclz_s32_x(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s64_x)))
-svuint64_t svclz_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s16_x)))
-svuint16_t svclz_s16_x(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u8_z)))
-svuint8_t svclz_u8_z(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u32_z)))
-svuint32_t svclz_u32_z(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u64_z)))
-svuint64_t svclz_u64_z(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u16_z)))
-svuint16_t svclz_u16_z(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s8_z)))
-svuint8_t svclz_s8_z(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s32_z)))
-svuint32_t svclz_s32_z(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s64_z)))
-svuint64_t svclz_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s16_z)))
-svuint16_t svclz_s16_z(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f64_m)))
-svfloat64_t svcmla_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f32_m)))
-svfloat32_t svcmla_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f16_m)))
-svfloat16_t svcmla_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f64_x)))
-svfloat64_t svcmla_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f32_x)))
-svfloat32_t svcmla_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f16_x)))
-svfloat16_t svcmla_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f64_z)))
-svfloat64_t svcmla_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f32_z)))
-svfloat32_t svcmla_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f16_z)))
-svfloat16_t svcmla_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_f32)))
-svfloat32_t svcmla_lane_f32(svfloat32_t, svfloat32_t, svfloat32_t, uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_f16)))
-svfloat16_t svcmla_lane_f16(svfloat16_t, svfloat16_t, svfloat16_t, uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_f64)))
-svbool_t svcmpeq_n_f64(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_f32)))
-svbool_t svcmpeq_n_f32(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_f16)))
-svbool_t svcmpeq_n_f16(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u8)))
-svbool_t svcmpeq_n_u8(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u32)))
-svbool_t svcmpeq_n_u32(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u64)))
-svbool_t svcmpeq_n_u64(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u16)))
-svbool_t svcmpeq_n_u16(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s8)))
-svbool_t svcmpeq_n_s8(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s32)))
-svbool_t svcmpeq_n_s32(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s64)))
-svbool_t svcmpeq_n_s64(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s16)))
-svbool_t svcmpeq_n_s16(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u8)))
-svbool_t svcmpeq_u8(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u32)))
-svbool_t svcmpeq_u32(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u64)))
-svbool_t svcmpeq_u64(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u16)))
-svbool_t svcmpeq_u16(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s8)))
-svbool_t svcmpeq_s8(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s32)))
-svbool_t svcmpeq_s32(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s64)))
-svbool_t svcmpeq_s64(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s16)))
-svbool_t svcmpeq_s16(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_f64)))
-svbool_t svcmpeq_f64(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_f32)))
-svbool_t svcmpeq_f32(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_f16)))
-svbool_t svcmpeq_f16(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_n_s8)))
-svbool_t svcmpeq_wide_n_s8(svbool_t, svint8_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_n_s32)))
-svbool_t svcmpeq_wide_n_s32(svbool_t, svint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_n_s16)))
-svbool_t svcmpeq_wide_n_s16(svbool_t, svint16_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_s8)))
-svbool_t svcmpeq_wide_s8(svbool_t, svint8_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_s32)))
-svbool_t svcmpeq_wide_s32(svbool_t, svint32_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_s16)))
-svbool_t svcmpeq_wide_s16(svbool_t, svint16_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_f64)))
-svbool_t svcmpge_n_f64(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_f32)))
-svbool_t svcmpge_n_f32(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_f16)))
-svbool_t svcmpge_n_f16(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s8)))
-svbool_t svcmpge_n_s8(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s32)))
-svbool_t svcmpge_n_s32(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s64)))
-svbool_t svcmpge_n_s64(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s16)))
-svbool_t svcmpge_n_s16(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u8)))
-svbool_t svcmpge_n_u8(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u32)))
-svbool_t svcmpge_n_u32(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u64)))
-svbool_t svcmpge_n_u64(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u16)))
-svbool_t svcmpge_n_u16(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s8)))
-svbool_t svcmpge_s8(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s32)))
-svbool_t svcmpge_s32(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s64)))
-svbool_t svcmpge_s64(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s16)))
-svbool_t svcmpge_s16(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_f64)))
-svbool_t svcmpge_f64(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_f32)))
-svbool_t svcmpge_f32(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_f16)))
-svbool_t svcmpge_f16(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u8)))
-svbool_t svcmpge_u8(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u32)))
-svbool_t svcmpge_u32(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u64)))
-svbool_t svcmpge_u64(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u16)))
-svbool_t svcmpge_u16(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_s8)))
-svbool_t svcmpge_wide_n_s8(svbool_t, svint8_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_s32)))
-svbool_t svcmpge_wide_n_s32(svbool_t, svint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_s16)))
-svbool_t svcmpge_wide_n_s16(svbool_t, svint16_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_u8)))
-svbool_t svcmpge_wide_n_u8(svbool_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_u32)))
-svbool_t svcmpge_wide_n_u32(svbool_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_u16)))
-svbool_t svcmpge_wide_n_u16(svbool_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_s8)))
-svbool_t svcmpge_wide_s8(svbool_t, svint8_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_s32)))
-svbool_t svcmpge_wide_s32(svbool_t, svint32_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_s16)))
-svbool_t svcmpge_wide_s16(svbool_t, svint16_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_u8)))
-svbool_t svcmpge_wide_u8(svbool_t, svuint8_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_u32)))
-svbool_t svcmpge_wide_u32(svbool_t, svuint32_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_u16)))
-svbool_t svcmpge_wide_u16(svbool_t, svuint16_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_f64)))
-svbool_t svcmpgt_n_f64(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_f32)))
-svbool_t svcmpgt_n_f32(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_f16)))
-svbool_t svcmpgt_n_f16(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s8)))
-svbool_t svcmpgt_n_s8(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s32)))
-svbool_t svcmpgt_n_s32(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s64)))
-svbool_t svcmpgt_n_s64(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s16)))
-svbool_t svcmpgt_n_s16(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u8)))
-svbool_t svcmpgt_n_u8(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u32)))
-svbool_t svcmpgt_n_u32(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u64)))
-svbool_t svcmpgt_n_u64(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u16)))
-svbool_t svcmpgt_n_u16(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s8)))
-svbool_t svcmpgt_s8(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s32)))
-svbool_t svcmpgt_s32(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s64)))
-svbool_t svcmpgt_s64(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s16)))
-svbool_t svcmpgt_s16(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_f64)))
-svbool_t svcmpgt_f64(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_f32)))
-svbool_t svcmpgt_f32(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_f16)))
-svbool_t svcmpgt_f16(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u8)))
-svbool_t svcmpgt_u8(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u32)))
-svbool_t svcmpgt_u32(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u64)))
-svbool_t svcmpgt_u64(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u16)))
-svbool_t svcmpgt_u16(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_s8)))
-svbool_t svcmpgt_wide_n_s8(svbool_t, svint8_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_s32)))
-svbool_t svcmpgt_wide_n_s32(svbool_t, svint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_s16)))
-svbool_t svcmpgt_wide_n_s16(svbool_t, svint16_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_u8)))
-svbool_t svcmpgt_wide_n_u8(svbool_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_u32)))
-svbool_t svcmpgt_wide_n_u32(svbool_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_u16)))
-svbool_t svcmpgt_wide_n_u16(svbool_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_s8)))
-svbool_t svcmpgt_wide_s8(svbool_t, svint8_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_s32)))
-svbool_t svcmpgt_wide_s32(svbool_t, svint32_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_s16)))
-svbool_t svcmpgt_wide_s16(svbool_t, svint16_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_u8)))
-svbool_t svcmpgt_wide_u8(svbool_t, svuint8_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_u32)))
-svbool_t svcmpgt_wide_u32(svbool_t, svuint32_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_u16)))
-svbool_t svcmpgt_wide_u16(svbool_t, svuint16_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_f64)))
-svbool_t svcmple_n_f64(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_f32)))
-svbool_t svcmple_n_f32(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_f16)))
-svbool_t svcmple_n_f16(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s8)))
-svbool_t svcmple_n_s8(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s32)))
-svbool_t svcmple_n_s32(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s64)))
-svbool_t svcmple_n_s64(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s16)))
-svbool_t svcmple_n_s16(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u8)))
-svbool_t svcmple_n_u8(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u32)))
-svbool_t svcmple_n_u32(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u64)))
-svbool_t svcmple_n_u64(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u16)))
-svbool_t svcmple_n_u16(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s8)))
-svbool_t svcmple_s8(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s32)))
-svbool_t svcmple_s32(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s64)))
-svbool_t svcmple_s64(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s16)))
-svbool_t svcmple_s16(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_f64)))
-svbool_t svcmple_f64(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_f32)))
-svbool_t svcmple_f32(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_f16)))
-svbool_t svcmple_f16(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u8)))
-svbool_t svcmple_u8(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u32)))
-svbool_t svcmple_u32(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u64)))
-svbool_t svcmple_u64(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u16)))
-svbool_t svcmple_u16(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_s8)))
-svbool_t svcmple_wide_n_s8(svbool_t, svint8_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_s32)))
-svbool_t svcmple_wide_n_s32(svbool_t, svint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_s16)))
-svbool_t svcmple_wide_n_s16(svbool_t, svint16_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_u8)))
-svbool_t svcmple_wide_n_u8(svbool_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_u32)))
-svbool_t svcmple_wide_n_u32(svbool_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_u16)))
-svbool_t svcmple_wide_n_u16(svbool_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_s8)))
-svbool_t svcmple_wide_s8(svbool_t, svint8_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_s32)))
-svbool_t svcmple_wide_s32(svbool_t, svint32_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_s16)))
-svbool_t svcmple_wide_s16(svbool_t, svint16_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_u8)))
-svbool_t svcmple_wide_u8(svbool_t, svuint8_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_u32)))
-svbool_t svcmple_wide_u32(svbool_t, svuint32_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_u16)))
-svbool_t svcmple_wide_u16(svbool_t, svuint16_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u8)))
-svbool_t svcmplt_n_u8(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u32)))
-svbool_t svcmplt_n_u32(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u64)))
-svbool_t svcmplt_n_u64(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u16)))
-svbool_t svcmplt_n_u16(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_f64)))
-svbool_t svcmplt_n_f64(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_f32)))
-svbool_t svcmplt_n_f32(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_f16)))
-svbool_t svcmplt_n_f16(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s8)))
-svbool_t svcmplt_n_s8(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s32)))
-svbool_t svcmplt_n_s32(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s64)))
-svbool_t svcmplt_n_s64(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s16)))
-svbool_t svcmplt_n_s16(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u8)))
-svbool_t svcmplt_u8(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u32)))
-svbool_t svcmplt_u32(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u64)))
-svbool_t svcmplt_u64(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u16)))
-svbool_t svcmplt_u16(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s8)))
-svbool_t svcmplt_s8(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s32)))
-svbool_t svcmplt_s32(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s64)))
-svbool_t svcmplt_s64(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s16)))
-svbool_t svcmplt_s16(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f64)))
-svbool_t svcmplt_f64(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f32)))
-svbool_t svcmplt_f32(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f16)))
-svbool_t svcmplt_f16(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_u8)))
-svbool_t svcmplt_wide_n_u8(svbool_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_u32)))
-svbool_t svcmplt_wide_n_u32(svbool_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_u16)))
-svbool_t svcmplt_wide_n_u16(svbool_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_s8)))
-svbool_t svcmplt_wide_n_s8(svbool_t, svint8_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_s32)))
-svbool_t svcmplt_wide_n_s32(svbool_t, svint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_s16)))
-svbool_t svcmplt_wide_n_s16(svbool_t, svint16_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_u8)))
-svbool_t svcmplt_wide_u8(svbool_t, svuint8_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_u32)))
-svbool_t svcmplt_wide_u32(svbool_t, svuint32_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_u16)))
-svbool_t svcmplt_wide_u16(svbool_t, svuint16_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_s8)))
-svbool_t svcmplt_wide_s8(svbool_t, svint8_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_s32)))
-svbool_t svcmplt_wide_s32(svbool_t, svint32_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_s16)))
-svbool_t svcmplt_wide_s16(svbool_t, svint16_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_f64)))
-svbool_t svcmpne_n_f64(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_f32)))
-svbool_t svcmpne_n_f32(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_f16)))
-svbool_t svcmpne_n_f16(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u8)))
-svbool_t svcmpne_n_u8(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u32)))
-svbool_t svcmpne_n_u32(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u64)))
-svbool_t svcmpne_n_u64(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u16)))
-svbool_t svcmpne_n_u16(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s8)))
-svbool_t svcmpne_n_s8(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s32)))
-svbool_t svcmpne_n_s32(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s64)))
-svbool_t svcmpne_n_s64(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s16)))
-svbool_t svcmpne_n_s16(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u8)))
-svbool_t svcmpne_u8(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u32)))
-svbool_t svcmpne_u32(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u64)))
-svbool_t svcmpne_u64(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u16)))
-svbool_t svcmpne_u16(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s8)))
-svbool_t svcmpne_s8(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s32)))
-svbool_t svcmpne_s32(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s64)))
-svbool_t svcmpne_s64(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s16)))
-svbool_t svcmpne_s16(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_f64)))
-svbool_t svcmpne_f64(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_f32)))
-svbool_t svcmpne_f32(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_f16)))
-svbool_t svcmpne_f16(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_n_s8)))
-svbool_t svcmpne_wide_n_s8(svbool_t, svint8_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_n_s32)))
-svbool_t svcmpne_wide_n_s32(svbool_t, svint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_n_s16)))
-svbool_t svcmpne_wide_n_s16(svbool_t, svint16_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_s8)))
-svbool_t svcmpne_wide_s8(svbool_t, svint8_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_s32)))
-svbool_t svcmpne_wide_s32(svbool_t, svint32_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_s16)))
-svbool_t svcmpne_wide_s16(svbool_t, svint16_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_n_f64)))
-svbool_t svcmpuo_n_f64(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_n_f32)))
-svbool_t svcmpuo_n_f32(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_n_f16)))
-svbool_t svcmpuo_n_f16(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_f64)))
-svbool_t svcmpuo_f64(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_f32)))
-svbool_t svcmpuo_f32(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_f16)))
-svbool_t svcmpuo_f16(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u8_m)))
-svuint8_t svcnot_u8_m(svuint8_t, svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u32_m)))
-svuint32_t svcnot_u32_m(svuint32_t, svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u64_m)))
-svuint64_t svcnot_u64_m(svuint64_t, svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u16_m)))
-svuint16_t svcnot_u16_m(svuint16_t, svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s8_m)))
-svint8_t svcnot_s8_m(svint8_t, svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s32_m)))
-svint32_t svcnot_s32_m(svint32_t, svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s64_m)))
-svint64_t svcnot_s64_m(svint64_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s16_m)))
-svint16_t svcnot_s16_m(svint16_t, svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u8_x)))
-svuint8_t svcnot_u8_x(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u32_x)))
-svuint32_t svcnot_u32_x(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u64_x)))
-svuint64_t svcnot_u64_x(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u16_x)))
-svuint16_t svcnot_u16_x(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s8_x)))
-svint8_t svcnot_s8_x(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s32_x)))
-svint32_t svcnot_s32_x(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s64_x)))
-svint64_t svcnot_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s16_x)))
-svint16_t svcnot_s16_x(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u8_z)))
-svuint8_t svcnot_u8_z(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u32_z)))
-svuint32_t svcnot_u32_z(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u64_z)))
-svuint64_t svcnot_u64_z(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u16_z)))
-svuint16_t svcnot_u16_z(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s8_z)))
-svint8_t svcnot_s8_z(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s32_z)))
-svint32_t svcnot_s32_z(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s64_z)))
-svint64_t svcnot_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s16_z)))
-svint16_t svcnot_s16_z(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u8_m)))
-svuint8_t svcnt_u8_m(svuint8_t, svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u32_m)))
-svuint32_t svcnt_u32_m(svuint32_t, svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u64_m)))
-svuint64_t svcnt_u64_m(svuint64_t, svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u16_m)))
-svuint16_t svcnt_u16_m(svuint16_t, svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s8_m)))
-svuint8_t svcnt_s8_m(svuint8_t, svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f64_m)))
-svuint64_t svcnt_f64_m(svuint64_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f32_m)))
-svuint32_t svcnt_f32_m(svuint32_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f16_m)))
-svuint16_t svcnt_f16_m(svuint16_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s32_m)))
-svuint32_t svcnt_s32_m(svuint32_t, svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s64_m)))
-svuint64_t svcnt_s64_m(svuint64_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s16_m)))
-svuint16_t svcnt_s16_m(svuint16_t, svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u8_x)))
-svuint8_t svcnt_u8_x(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u32_x)))
-svuint32_t svcnt_u32_x(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u64_x)))
-svuint64_t svcnt_u64_x(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u16_x)))
-svuint16_t svcnt_u16_x(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s8_x)))
-svuint8_t svcnt_s8_x(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f64_x)))
-svuint64_t svcnt_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f32_x)))
-svuint32_t svcnt_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f16_x)))
-svuint16_t svcnt_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s32_x)))
-svuint32_t svcnt_s32_x(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s64_x)))
-svuint64_t svcnt_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s16_x)))
-svuint16_t svcnt_s16_x(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u8_z)))
-svuint8_t svcnt_u8_z(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u32_z)))
-svuint32_t svcnt_u32_z(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u64_z)))
-svuint64_t svcnt_u64_z(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u16_z)))
-svuint16_t svcnt_u16_z(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s8_z)))
-svuint8_t svcnt_s8_z(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f64_z)))
-svuint64_t svcnt_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f32_z)))
-svuint32_t svcnt_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f16_z)))
-svuint16_t svcnt_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s32_z)))
-svuint32_t svcnt_s32_z(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s64_z)))
-svuint64_t svcnt_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s16_z)))
-svuint16_t svcnt_s16_z(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntb)))
-uint64_t svcntb(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntb_pat)))
-uint64_t svcntb_pat(enum svpattern);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntd)))
-uint64_t svcntd(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntd_pat)))
-uint64_t svcntd_pat(enum svpattern);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnth)))
-uint64_t svcnth(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnth_pat)))
-uint64_t svcnth_pat(enum svpattern);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntp_b8)))
-uint64_t svcntp_b8(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntp_b32)))
-uint64_t svcntp_b32(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntp_b64)))
-uint64_t svcntp_b64(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntp_b16)))
-uint64_t svcntp_b16(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntw)))
-uint64_t svcntw(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntw_pat)))
-uint64_t svcntw_pat(enum svpattern);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_u32)))
-svuint32_t svcompact_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_u64)))
-svuint64_t svcompact_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_f64)))
-svfloat64_t svcompact_f64(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_f32)))
-svfloat32_t svcompact_f32(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_s32)))
-svint32_t svcompact_s32(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_s64)))
-svint64_t svcompact_s64(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u8)))
-svuint8x2_t svcreate2_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u32)))
-svuint32x2_t svcreate2_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u64)))
-svuint64x2_t svcreate2_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u16)))
-svuint16x2_t svcreate2_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s8)))
-svint8x2_t svcreate2_s8(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_f64)))
-svfloat64x2_t svcreate2_f64(svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_f32)))
-svfloat32x2_t svcreate2_f32(svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_f16)))
-svfloat16x2_t svcreate2_f16(svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s32)))
-svint32x2_t svcreate2_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s64)))
-svint64x2_t svcreate2_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s16)))
-svint16x2_t svcreate2_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u8)))
-svuint8x3_t svcreate3_u8(svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u32)))
-svuint32x3_t svcreate3_u32(svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u64)))
-svuint64x3_t svcreate3_u64(svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u16)))
-svuint16x3_t svcreate3_u16(svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s8)))
-svint8x3_t svcreate3_s8(svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_f64)))
-svfloat64x3_t svcreate3_f64(svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_f32)))
-svfloat32x3_t svcreate3_f32(svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_f16)))
-svfloat16x3_t svcreate3_f16(svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s32)))
-svint32x3_t svcreate3_s32(svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s64)))
-svint64x3_t svcreate3_s64(svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s16)))
-svint16x3_t svcreate3_s16(svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u8)))
-svuint8x4_t svcreate4_u8(svuint8_t, svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u32)))
-svuint32x4_t svcreate4_u32(svuint32_t, svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u64)))
-svuint64x4_t svcreate4_u64(svuint64_t, svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u16)))
-svuint16x4_t svcreate4_u16(svuint16_t, svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s8)))
-svint8x4_t svcreate4_s8(svint8_t, svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_f64)))
-svfloat64x4_t svcreate4_f64(svfloat64_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_f32)))
-svfloat32x4_t svcreate4_f32(svfloat32_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_f16)))
-svfloat16x4_t svcreate4_f16(svfloat16_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s32)))
-svint32x4_t svcreate4_s32(svint32_t, svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s64)))
-svint64x4_t svcreate4_s64(svint64_t, svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s16)))
-svint16x4_t svcreate4_s16(svint16_t, svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_m)))
-svfloat16_t svcvt_f16_f32_m(svfloat16_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_x)))
-svfloat16_t svcvt_f16_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_z)))
-svfloat16_t svcvt_f16_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f64_m)))
-svfloat16_t svcvt_f16_f64_m(svfloat16_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f64_x)))
-svfloat16_t svcvt_f16_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f64_z)))
-svfloat16_t svcvt_f16_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s16_m)))
-svfloat16_t svcvt_f16_s16_m(svfloat16_t, svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s16_x)))
-svfloat16_t svcvt_f16_s16_x(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s16_z)))
-svfloat16_t svcvt_f16_s16_z(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s32_m)))
-svfloat16_t svcvt_f16_s32_m(svfloat16_t, svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s32_x)))
-svfloat16_t svcvt_f16_s32_x(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s32_z)))
-svfloat16_t svcvt_f16_s32_z(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s64_m)))
-svfloat16_t svcvt_f16_s64_m(svfloat16_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s64_x)))
-svfloat16_t svcvt_f16_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s64_z)))
-svfloat16_t svcvt_f16_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u16_m)))
-svfloat16_t svcvt_f16_u16_m(svfloat16_t, svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u16_x)))
-svfloat16_t svcvt_f16_u16_x(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u16_z)))
-svfloat16_t svcvt_f16_u16_z(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u32_m)))
-svfloat16_t svcvt_f16_u32_m(svfloat16_t, svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u32_x)))
-svfloat16_t svcvt_f16_u32_x(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u32_z)))
-svfloat16_t svcvt_f16_u32_z(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u64_m)))
-svfloat16_t svcvt_f16_u64_m(svfloat16_t, svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u64_x)))
-svfloat16_t svcvt_f16_u64_x(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u64_z)))
-svfloat16_t svcvt_f16_u64_z(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_m)))
-svfloat32_t svcvt_f32_f16_m(svfloat32_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_x)))
-svfloat32_t svcvt_f32_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_z)))
-svfloat32_t svcvt_f32_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f64_m)))
-svfloat32_t svcvt_f32_f64_m(svfloat32_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f64_x)))
-svfloat32_t svcvt_f32_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f64_z)))
-svfloat32_t svcvt_f32_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_m)))
-svfloat32_t svcvt_f32_s32_m(svfloat32_t, svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_x)))
-svfloat32_t svcvt_f32_s32_x(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_z)))
-svfloat32_t svcvt_f32_s32_z(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s64_m)))
-svfloat32_t svcvt_f32_s64_m(svfloat32_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s64_x)))
-svfloat32_t svcvt_f32_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s64_z)))
-svfloat32_t svcvt_f32_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_m)))
-svfloat32_t svcvt_f32_u32_m(svfloat32_t, svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_x)))
-svfloat32_t svcvt_f32_u32_x(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_z)))
-svfloat32_t svcvt_f32_u32_z(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u64_m)))
-svfloat32_t svcvt_f32_u64_m(svfloat32_t, svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u64_x)))
-svfloat32_t svcvt_f32_u64_x(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u64_z)))
-svfloat32_t svcvt_f32_u64_z(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f16_m)))
-svfloat64_t svcvt_f64_f16_m(svfloat64_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f16_x)))
-svfloat64_t svcvt_f64_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f16_z)))
-svfloat64_t svcvt_f64_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f32_m)))
-svfloat64_t svcvt_f64_f32_m(svfloat64_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f32_x)))
-svfloat64_t svcvt_f64_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f32_z)))
-svfloat64_t svcvt_f64_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s32_m)))
-svfloat64_t svcvt_f64_s32_m(svfloat64_t, svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s32_x)))
-svfloat64_t svcvt_f64_s32_x(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s32_z)))
-svfloat64_t svcvt_f64_s32_z(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s64_m)))
-svfloat64_t svcvt_f64_s64_m(svfloat64_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s64_x)))
-svfloat64_t svcvt_f64_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s64_z)))
-svfloat64_t svcvt_f64_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u32_m)))
-svfloat64_t svcvt_f64_u32_m(svfloat64_t, svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u32_x)))
-svfloat64_t svcvt_f64_u32_x(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u32_z)))
-svfloat64_t svcvt_f64_u32_z(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u64_m)))
-svfloat64_t svcvt_f64_u64_m(svfloat64_t, svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u64_x)))
-svfloat64_t svcvt_f64_u64_x(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u64_z)))
-svfloat64_t svcvt_f64_u64_z(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s16_f16_m)))
-svint16_t svcvt_s16_f16_m(svint16_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s16_f16_x)))
-svint16_t svcvt_s16_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s16_f16_z)))
-svint16_t svcvt_s16_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f16_m)))
-svint32_t svcvt_s32_f16_m(svint32_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f16_x)))
-svint32_t svcvt_s32_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f16_z)))
-svint32_t svcvt_s32_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_m)))
-svint32_t svcvt_s32_f32_m(svint32_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_x)))
-svint32_t svcvt_s32_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_z)))
-svint32_t svcvt_s32_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f64_m)))
-svint32_t svcvt_s32_f64_m(svint32_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f64_x)))
-svint32_t svcvt_s32_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f64_z)))
-svint32_t svcvt_s32_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f16_m)))
-svint64_t svcvt_s64_f16_m(svint64_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f16_x)))
-svint64_t svcvt_s64_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f16_z)))
-svint64_t svcvt_s64_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f32_m)))
-svint64_t svcvt_s64_f32_m(svint64_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f32_x)))
-svint64_t svcvt_s64_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f32_z)))
-svint64_t svcvt_s64_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f64_m)))
-svint64_t svcvt_s64_f64_m(svint64_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f64_x)))
-svint64_t svcvt_s64_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f64_z)))
-svint64_t svcvt_s64_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u16_f16_m)))
-svuint16_t svcvt_u16_f16_m(svuint16_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u16_f16_x)))
-svuint16_t svcvt_u16_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u16_f16_z)))
-svuint16_t svcvt_u16_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f16_m)))
-svuint32_t svcvt_u32_f16_m(svuint32_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f16_x)))
-svuint32_t svcvt_u32_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f16_z)))
-svuint32_t svcvt_u32_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_m)))
-svuint32_t svcvt_u32_f32_m(svuint32_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_x)))
-svuint32_t svcvt_u32_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_z)))
-svuint32_t svcvt_u32_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f64_m)))
-svuint32_t svcvt_u32_f64_m(svuint32_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f64_x)))
-svuint32_t svcvt_u32_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f64_z)))
-svuint32_t svcvt_u32_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f16_m)))
-svuint64_t svcvt_u64_f16_m(svuint64_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f16_x)))
-svuint64_t svcvt_u64_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f16_z)))
-svuint64_t svcvt_u64_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f32_m)))
-svuint64_t svcvt_u64_f32_m(svuint64_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f32_x)))
-svuint64_t svcvt_u64_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f32_z)))
-svuint64_t svcvt_u64_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f64_m)))
-svuint64_t svcvt_u64_f64_m(svuint64_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f64_x)))
-svuint64_t svcvt_u64_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f64_z)))
-svuint64_t svcvt_u64_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f64_m)))
-svfloat64_t svdiv_n_f64_m(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f32_m)))
-svfloat32_t svdiv_n_f32_m(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f16_m)))
-svfloat16_t svdiv_n_f16_m(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f64_x)))
-svfloat64_t svdiv_n_f64_x(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f32_x)))
-svfloat32_t svdiv_n_f32_x(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f16_x)))
-svfloat16_t svdiv_n_f16_x(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f64_z)))
-svfloat64_t svdiv_n_f64_z(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f32_z)))
-svfloat32_t svdiv_n_f32_z(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f16_z)))
-svfloat16_t svdiv_n_f16_z(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s32_m)))
-svint32_t svdiv_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s64_m)))
-svint64_t svdiv_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s32_x)))
-svint32_t svdiv_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s64_x)))
-svint64_t svdiv_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s32_z)))
-svint32_t svdiv_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s64_z)))
-svint64_t svdiv_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u32_m)))
-svuint32_t svdiv_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u64_m)))
-svuint64_t svdiv_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u32_x)))
-svuint32_t svdiv_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u64_x)))
-svuint64_t svdiv_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u32_z)))
-svuint32_t svdiv_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u64_z)))
-svuint64_t svdiv_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f64_m)))
-svfloat64_t svdiv_f64_m(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f32_m)))
-svfloat32_t svdiv_f32_m(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f16_m)))
-svfloat16_t svdiv_f16_m(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f64_x)))
-svfloat64_t svdiv_f64_x(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f32_x)))
-svfloat32_t svdiv_f32_x(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f16_x)))
-svfloat16_t svdiv_f16_x(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f64_z)))
-svfloat64_t svdiv_f64_z(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f32_z)))
-svfloat32_t svdiv_f32_z(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f16_z)))
-svfloat16_t svdiv_f16_z(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s32_m)))
-svint32_t svdiv_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s64_m)))
-svint64_t svdiv_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s32_x)))
-svint32_t svdiv_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s64_x)))
-svint64_t svdiv_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s32_z)))
-svint32_t svdiv_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s64_z)))
-svint64_t svdiv_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u32_m)))
-svuint32_t svdiv_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u64_m)))
-svuint64_t svdiv_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u32_x)))
-svuint32_t svdiv_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u64_x)))
-svuint64_t svdiv_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u32_z)))
-svuint32_t svdiv_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u64_z)))
-svuint64_t svdiv_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f64_m)))
-svfloat64_t svdivr_n_f64_m(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f32_m)))
-svfloat32_t svdivr_n_f32_m(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f16_m)))
-svfloat16_t svdivr_n_f16_m(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f64_x)))
-svfloat64_t svdivr_n_f64_x(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f32_x)))
-svfloat32_t svdivr_n_f32_x(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f16_x)))
-svfloat16_t svdivr_n_f16_x(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f64_z)))
-svfloat64_t svdivr_n_f64_z(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f32_z)))
-svfloat32_t svdivr_n_f32_z(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f16_z)))
-svfloat16_t svdivr_n_f16_z(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s32_m)))
-svint32_t svdivr_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s64_m)))
-svint64_t svdivr_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s32_x)))
-svint32_t svdivr_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s64_x)))
-svint64_t svdivr_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s32_z)))
-svint32_t svdivr_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s64_z)))
-svint64_t svdivr_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u32_m)))
-svuint32_t svdivr_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u64_m)))
-svuint64_t svdivr_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u32_x)))
-svuint32_t svdivr_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u64_x)))
-svuint64_t svdivr_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u32_z)))
-svuint32_t svdivr_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u64_z)))
-svuint64_t svdivr_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f64_m)))
-svfloat64_t svdivr_f64_m(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f32_m)))
-svfloat32_t svdivr_f32_m(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f16_m)))
-svfloat16_t svdivr_f16_m(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f64_x)))
-svfloat64_t svdivr_f64_x(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f32_x)))
-svfloat32_t svdivr_f32_x(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f16_x)))
-svfloat16_t svdivr_f16_x(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f64_z)))
-svfloat64_t svdivr_f64_z(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f32_z)))
-svfloat32_t svdivr_f32_z(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f16_z)))
-svfloat16_t svdivr_f16_z(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s32_m)))
-svint32_t svdivr_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s64_m)))
-svint64_t svdivr_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s32_x)))
-svint32_t svdivr_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s64_x)))
-svint64_t svdivr_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s32_z)))
-svint32_t svdivr_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s64_z)))
-svint64_t svdivr_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u32_m)))
-svuint32_t svdivr_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u64_m)))
-svuint64_t svdivr_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u32_x)))
-svuint32_t svdivr_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u64_x)))
-svuint64_t svdivr_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u32_z)))
-svuint32_t svdivr_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u64_z)))
-svuint64_t svdivr_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_s32)))
-svint32_t svdot_n_s32(svint32_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_s64)))
-svint64_t svdot_n_s64(svint64_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_u32)))
-svuint32_t svdot_n_u32(svuint32_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_u64)))
-svuint64_t svdot_n_u64(svuint64_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_s32)))
-svint32_t svdot_s32(svint32_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_s64)))
-svint64_t svdot_s64(svint64_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_u32)))
-svuint32_t svdot_u32(svuint32_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_u64)))
-svuint64_t svdot_u64(svuint64_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_s32)))
-svint32_t svdot_lane_s32(svint32_t, svint8_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_s64)))
-svint64_t svdot_lane_s64(svint64_t, svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_u32)))
-svuint32_t svdot_lane_u32(svuint32_t, svuint8_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_u64)))
-svuint64_t svdot_lane_u64(svuint64_t, svuint16_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8)))
-svuint8_t svdup_n_u8(uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32)))
-svuint32_t svdup_n_u32(uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64)))
-svuint64_t svdup_n_u64(uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16)))
-svuint16_t svdup_n_u16(uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8)))
-svint8_t svdup_n_s8(int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64)))
-svfloat64_t svdup_n_f64(float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32)))
-svfloat32_t svdup_n_f32(float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16)))
-svfloat16_t svdup_n_f16(float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32)))
-svint32_t svdup_n_s32(int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64)))
-svint64_t svdup_n_s64(int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16)))
-svint16_t svdup_n_s16(int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8_m)))
-svuint8_t svdup_n_u8_m(svuint8_t, svbool_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32_m)))
-svuint32_t svdup_n_u32_m(svuint32_t, svbool_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64_m)))
-svuint64_t svdup_n_u64_m(svuint64_t, svbool_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16_m)))
-svuint16_t svdup_n_u16_m(svuint16_t, svbool_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8_m)))
-svint8_t svdup_n_s8_m(svint8_t, svbool_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64_m)))
-svfloat64_t svdup_n_f64_m(svfloat64_t, svbool_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32_m)))
-svfloat32_t svdup_n_f32_m(svfloat32_t, svbool_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16_m)))
-svfloat16_t svdup_n_f16_m(svfloat16_t, svbool_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32_m)))
-svint32_t svdup_n_s32_m(svint32_t, svbool_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64_m)))
-svint64_t svdup_n_s64_m(svint64_t, svbool_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16_m)))
-svint16_t svdup_n_s16_m(svint16_t, svbool_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b8)))
-svbool_t svdup_n_b8(bool);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b32)))
-svbool_t svdup_n_b32(bool);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b64)))
-svbool_t svdup_n_b64(bool);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b16)))
-svbool_t svdup_n_b16(bool);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8_x)))
-svuint8_t svdup_n_u8_x(svbool_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32_x)))
-svuint32_t svdup_n_u32_x(svbool_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64_x)))
-svuint64_t svdup_n_u64_x(svbool_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16_x)))
-svuint16_t svdup_n_u16_x(svbool_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8_x)))
-svint8_t svdup_n_s8_x(svbool_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64_x)))
-svfloat64_t svdup_n_f64_x(svbool_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32_x)))
-svfloat32_t svdup_n_f32_x(svbool_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16_x)))
-svfloat16_t svdup_n_f16_x(svbool_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32_x)))
-svint32_t svdup_n_s32_x(svbool_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64_x)))
-svint64_t svdup_n_s64_x(svbool_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16_x)))
-svint16_t svdup_n_s16_x(svbool_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8_z)))
-svuint8_t svdup_n_u8_z(svbool_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32_z)))
-svuint32_t svdup_n_u32_z(svbool_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64_z)))
-svuint64_t svdup_n_u64_z(svbool_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16_z)))
-svuint16_t svdup_n_u16_z(svbool_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8_z)))
-svint8_t svdup_n_s8_z(svbool_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64_z)))
-svfloat64_t svdup_n_f64_z(svbool_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32_z)))
-svfloat32_t svdup_n_f32_z(svbool_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16_z)))
-svfloat16_t svdup_n_f16_z(svbool_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32_z)))
-svint32_t svdup_n_s32_z(svbool_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64_z)))
-svint64_t svdup_n_s64_z(svbool_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16_z)))
-svint16_t svdup_n_s16_z(svbool_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u8)))
-svuint8_t svdup_lane_u8(svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u32)))
-svuint32_t svdup_lane_u32(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u64)))
-svuint64_t svdup_lane_u64(svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u16)))
-svuint16_t svdup_lane_u16(svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s8)))
-svint8_t svdup_lane_s8(svint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_f64)))
-svfloat64_t svdup_lane_f64(svfloat64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_f32)))
-svfloat32_t svdup_lane_f32(svfloat32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_f16)))
-svfloat16_t svdup_lane_f16(svfloat16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s32)))
-svint32_t svdup_lane_s32(svint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s64)))
-svint64_t svdup_lane_s64(svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s16)))
-svint16_t svdup_lane_s16(svint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u8)))
-svuint8_t svdupq_n_u8(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s8)))
-svint8_t svdupq_n_s8(int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u16)))
-svuint16_t svdupq_n_u16(uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_f16)))
-svfloat16_t svdupq_n_f16(float16_t, float16_t, float16_t, float16_t, float16_t, float16_t, float16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s16)))
-svint16_t svdupq_n_s16(int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u32)))
-svuint32_t svdupq_n_u32(uint32_t, uint32_t, uint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_f32)))
-svfloat32_t svdupq_n_f32(float32_t, float32_t, float32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s32)))
-svint32_t svdupq_n_s32(int32_t, int32_t, int32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u64)))
-svuint64_t svdupq_n_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_f64)))
-svfloat64_t svdupq_n_f64(float64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s64)))
-svint64_t svdupq_n_s64(int64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b8)))
-svbool_t svdupq_n_b8(bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b16)))
-svbool_t svdupq_n_b16(bool, bool, bool, bool, bool, bool, bool, bool);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b32)))
-svbool_t svdupq_n_b32(bool, bool, bool, bool);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b64)))
-svbool_t svdupq_n_b64(bool, bool);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u8)))
-svuint8_t svdupq_lane_u8(svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u32)))
-svuint32_t svdupq_lane_u32(svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u64)))
-svuint64_t svdupq_lane_u64(svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u16)))
-svuint16_t svdupq_lane_u16(svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s8)))
-svint8_t svdupq_lane_s8(svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_f64)))
-svfloat64_t svdupq_lane_f64(svfloat64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_f32)))
-svfloat32_t svdupq_lane_f32(svfloat32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_f16)))
-svfloat16_t svdupq_lane_f16(svfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s32)))
-svint32_t svdupq_lane_s32(svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s64)))
-svint64_t svdupq_lane_s64(svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s16)))
-svint16_t svdupq_lane_s16(svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_b_z)))
-svbool_t sveor_b_z(svbool_t, svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u8_m)))
-svuint8_t sveor_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u32_m)))
-svuint32_t sveor_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u64_m)))
-svuint64_t sveor_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u16_m)))
-svuint16_t sveor_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s8_m)))
-svint8_t sveor_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s32_m)))
-svint32_t sveor_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s64_m)))
-svint64_t sveor_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s16_m)))
-svint16_t sveor_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u8_x)))
-svuint8_t sveor_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u32_x)))
-svuint32_t sveor_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u64_x)))
-svuint64_t sveor_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u16_x)))
-svuint16_t sveor_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s8_x)))
-svint8_t sveor_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s32_x)))
-svint32_t sveor_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s64_x)))
-svint64_t sveor_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s16_x)))
-svint16_t sveor_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u8_z)))
-svuint8_t sveor_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u32_z)))
-svuint32_t sveor_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u64_z)))
-svuint64_t sveor_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u16_z)))
-svuint16_t sveor_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s8_z)))
-svint8_t sveor_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s32_z)))
-svint32_t sveor_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s64_z)))
-svint64_t sveor_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s16_z)))
-svint16_t sveor_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u8_m)))
-svuint8_t sveor_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u32_m)))
-svuint32_t sveor_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u64_m)))
-svuint64_t sveor_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u16_m)))
-svuint16_t sveor_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s8_m)))
-svint8_t sveor_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s32_m)))
-svint32_t sveor_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s64_m)))
-svint64_t sveor_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s16_m)))
-svint16_t sveor_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u8_x)))
-svuint8_t sveor_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u32_x)))
-svuint32_t sveor_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u64_x)))
-svuint64_t sveor_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u16_x)))
-svuint16_t sveor_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s8_x)))
-svint8_t sveor_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s32_x)))
-svint32_t sveor_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s64_x)))
-svint64_t sveor_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s16_x)))
-svint16_t sveor_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u8_z)))
-svuint8_t sveor_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u32_z)))
-svuint32_t sveor_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u64_z)))
-svuint64_t sveor_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u16_z)))
-svuint16_t sveor_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s8_z)))
-svint8_t sveor_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s32_z)))
-svint32_t sveor_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s64_z)))
-svint64_t sveor_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s16_z)))
-svint16_t sveor_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u8)))
-uint8_t sveorv_u8(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u32)))
-uint32_t sveorv_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u64)))
-uint64_t sveorv_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u16)))
-uint16_t sveorv_u16(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s8)))
-int8_t sveorv_s8(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s32)))
-int32_t sveorv_s32(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s64)))
-int64_t sveorv_s64(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s16)))
-int16_t sveorv_s16(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexpa_f64)))
-svfloat64_t svexpa_f64(svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexpa_f32)))
-svfloat32_t svexpa_f32(svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexpa_f16)))
-svfloat16_t svexpa_f16(svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u8)))
-svuint8_t svext_u8(svuint8_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u32)))
-svuint32_t svext_u32(svuint32_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u64)))
-svuint64_t svext_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u16)))
-svuint16_t svext_u16(svuint16_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s8)))
-svint8_t svext_s8(svint8_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_f64)))
-svfloat64_t svext_f64(svfloat64_t, svfloat64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_f32)))
-svfloat32_t svext_f32(svfloat32_t, svfloat32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_f16)))
-svfloat16_t svext_f16(svfloat16_t, svfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s32)))
-svint32_t svext_s32(svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s64)))
-svint64_t svext_s64(svint64_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s16)))
-svint16_t svext_s16(svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s32_m)))
-svint32_t svextb_s32_m(svint32_t, svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s64_m)))
-svint64_t svextb_s64_m(svint64_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s16_m)))
-svint16_t svextb_s16_m(svint16_t, svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s32_x)))
-svint32_t svextb_s32_x(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s64_x)))
-svint64_t svextb_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s16_x)))
-svint16_t svextb_s16_x(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s32_z)))
-svint32_t svextb_s32_z(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s64_z)))
-svint64_t svextb_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s16_z)))
-svint16_t svextb_s16_z(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u32_m)))
-svuint32_t svextb_u32_m(svuint32_t, svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u64_m)))
-svuint64_t svextb_u64_m(svuint64_t, svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u16_m)))
-svuint16_t svextb_u16_m(svuint16_t, svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u32_x)))
-svuint32_t svextb_u32_x(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u64_x)))
-svuint64_t svextb_u64_x(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u16_x)))
-svuint16_t svextb_u16_x(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u32_z)))
-svuint32_t svextb_u32_z(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u64_z)))
-svuint64_t svextb_u64_z(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u16_z)))
-svuint16_t svextb_u16_z(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s32_m)))
-svint32_t svexth_s32_m(svint32_t, svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s64_m)))
-svint64_t svexth_s64_m(svint64_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s32_x)))
-svint32_t svexth_s32_x(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s64_x)))
-svint64_t svexth_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s32_z)))
-svint32_t svexth_s32_z(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s64_z)))
-svint64_t svexth_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u32_m)))
-svuint32_t svexth_u32_m(svuint32_t, svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u64_m)))
-svuint64_t svexth_u64_m(svuint64_t, svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u32_x)))
-svuint32_t svexth_u32_x(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u64_x)))
-svuint64_t svexth_u64_x(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u32_z)))
-svuint32_t svexth_u32_z(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u64_z)))
-svuint64_t svexth_u64_z(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_s64_m)))
-svint64_t svextw_s64_m(svint64_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_s64_x)))
-svint64_t svextw_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_s64_z)))
-svint64_t svextw_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_u64_m)))
-svuint64_t svextw_u64_m(svuint64_t, svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_u64_x)))
-svuint64_t svextw_u64_x(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_u64_z)))
-svuint64_t svextw_u64_z(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u8)))
-svuint8_t svget2_u8(svuint8x2_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u32)))
-svuint32_t svget2_u32(svuint32x2_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u64)))
-svuint64_t svget2_u64(svuint64x2_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u16)))
-svuint16_t svget2_u16(svuint16x2_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s8)))
-svint8_t svget2_s8(svint8x2_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_f64)))
-svfloat64_t svget2_f64(svfloat64x2_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_f32)))
-svfloat32_t svget2_f32(svfloat32x2_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_f16)))
-svfloat16_t svget2_f16(svfloat16x2_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s32)))
-svint32_t svget2_s32(svint32x2_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s64)))
-svint64_t svget2_s64(svint64x2_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s16)))
-svint16_t svget2_s16(svint16x2_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u8)))
-svuint8_t svget3_u8(svuint8x3_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u32)))
-svuint32_t svget3_u32(svuint32x3_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u64)))
-svuint64_t svget3_u64(svuint64x3_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u16)))
-svuint16_t svget3_u16(svuint16x3_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s8)))
-svint8_t svget3_s8(svint8x3_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_f64)))
-svfloat64_t svget3_f64(svfloat64x3_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_f32)))
-svfloat32_t svget3_f32(svfloat32x3_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_f16)))
-svfloat16_t svget3_f16(svfloat16x3_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s32)))
-svint32_t svget3_s32(svint32x3_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s64)))
-svint64_t svget3_s64(svint64x3_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s16)))
-svint16_t svget3_s16(svint16x3_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u8)))
-svuint8_t svget4_u8(svuint8x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u32)))
-svuint32_t svget4_u32(svuint32x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u64)))
-svuint64_t svget4_u64(svuint64x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u16)))
-svuint16_t svget4_u16(svuint16x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s8)))
-svint8_t svget4_s8(svint8x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_f64)))
-svfloat64_t svget4_f64(svfloat64x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_f32)))
-svfloat32_t svget4_f32(svfloat32x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_f16)))
-svfloat16_t svget4_f16(svfloat16x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s32)))
-svint32_t svget4_s32(svint32x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s64)))
-svint64_t svget4_s64(svint64x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s16)))
-svint16_t svget4_s16(svint16x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_u8)))
-svuint8_t svindex_u8(uint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_u32)))
-svuint32_t svindex_u32(uint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_u64)))
-svuint64_t svindex_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_u16)))
-svuint16_t svindex_u16(uint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_s8)))
-svint8_t svindex_s8(int8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_s32)))
-svint32_t svindex_s32(int32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_s64)))
-svint64_t svindex_s64(int64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_s16)))
-svint16_t svindex_s16(int16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u8)))
-svuint8_t svinsr_n_u8(svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u32)))
-svuint32_t svinsr_n_u32(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u64)))
-svuint64_t svinsr_n_u64(svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u16)))
-svuint16_t svinsr_n_u16(svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s8)))
-svint8_t svinsr_n_s8(svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_f64)))
-svfloat64_t svinsr_n_f64(svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_f32)))
-svfloat32_t svinsr_n_f32(svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_f16)))
-svfloat16_t svinsr_n_f16(svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s32)))
-svint32_t svinsr_n_s32(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s64)))
-svint64_t svinsr_n_s64(svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s16)))
-svint16_t svinsr_n_s16(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u8)))
-uint8_t svlasta_u8(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u32)))
-uint32_t svlasta_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u64)))
-uint64_t svlasta_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u16)))
-uint16_t svlasta_u16(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s8)))
-int8_t svlasta_s8(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_f64)))
-float64_t svlasta_f64(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_f32)))
-float32_t svlasta_f32(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_f16)))
-float16_t svlasta_f16(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s32)))
-int32_t svlasta_s32(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s64)))
-int64_t svlasta_s64(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s16)))
-int16_t svlasta_s16(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u8)))
-uint8_t svlastb_u8(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u32)))
-uint32_t svlastb_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u64)))
-uint64_t svlastb_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u16)))
-uint16_t svlastb_u16(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s8)))
-int8_t svlastb_s8(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_f64)))
-float64_t svlastb_f64(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_f32)))
-float32_t svlastb_f32(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_f16)))
-float16_t svlastb_f16(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s32)))
-int32_t svlastb_s32(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s64)))
-int64_t svlastb_s64(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s16)))
-int16_t svlastb_s16(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u8)))
-svuint8_t svld1_u8(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u32)))
-svuint32_t svld1_u32(svbool_t, uint32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u64)))
-svuint64_t svld1_u64(svbool_t, uint64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u16)))
-svuint16_t svld1_u16(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s8)))
-svint8_t svld1_s8(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f64)))
-svfloat64_t svld1_f64(svbool_t, float64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f32)))
-svfloat32_t svld1_f32(svbool_t, float32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f16)))
-svfloat16_t svld1_f16(svbool_t, float16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s32)))
-svint32_t svld1_s32(svbool_t, int32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s64)))
-svint64_t svld1_s64(svbool_t, int64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s16)))
-svint16_t svld1_s16(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_index_u32)))
-svuint32_t svld1_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_index_u64)))
-svuint64_t svld1_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_index_f64)))
-svfloat64_t svld1_gather_u64base_index_f64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_index_f32)))
-svfloat32_t svld1_gather_u32base_index_f32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_index_s32)))
-svint32_t svld1_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_index_s64)))
-svint64_t svld1_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_offset_u32)))
-svuint32_t svld1_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_offset_u64)))
-svuint64_t svld1_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_offset_f64)))
-svfloat64_t svld1_gather_u64base_offset_f64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_offset_f32)))
-svfloat32_t svld1_gather_u32base_offset_f32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_offset_s32)))
-svint32_t svld1_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_offset_s64)))
-svint64_t svld1_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_u32)))
-svuint32_t svld1_gather_u32base_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_u64)))
-svuint64_t svld1_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_f64)))
-svfloat64_t svld1_gather_u64base_f64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_f32)))
-svfloat32_t svld1_gather_u32base_f32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_s32)))
-svint32_t svld1_gather_u32base_s32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_s64)))
-svint64_t svld1_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32index_u32)))
-svuint32_t svld1_gather_s32index_u32(svbool_t, uint32_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32index_f32)))
-svfloat32_t svld1_gather_s32index_f32(svbool_t, float32_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32index_s32)))
-svint32_t svld1_gather_s32index_s32(svbool_t, int32_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32index_u32)))
-svuint32_t svld1_gather_u32index_u32(svbool_t, uint32_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32index_f32)))
-svfloat32_t svld1_gather_u32index_f32(svbool_t, float32_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32index_s32)))
-svint32_t svld1_gather_u32index_s32(svbool_t, int32_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64index_u64)))
-svuint64_t svld1_gather_s64index_u64(svbool_t, uint64_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64index_f64)))
-svfloat64_t svld1_gather_s64index_f64(svbool_t, float64_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64index_s64)))
-svint64_t svld1_gather_s64index_s64(svbool_t, int64_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64index_u64)))
-svuint64_t svld1_gather_u64index_u64(svbool_t, uint64_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64index_f64)))
-svfloat64_t svld1_gather_u64index_f64(svbool_t, float64_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64index_s64)))
-svint64_t svld1_gather_u64index_s64(svbool_t, int64_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32offset_u32)))
-svuint32_t svld1_gather_s32offset_u32(svbool_t, uint32_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32offset_f32)))
-svfloat32_t svld1_gather_s32offset_f32(svbool_t, float32_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32offset_s32)))
-svint32_t svld1_gather_s32offset_s32(svbool_t, int32_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32offset_u32)))
-svuint32_t svld1_gather_u32offset_u32(svbool_t, uint32_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32offset_f32)))
-svfloat32_t svld1_gather_u32offset_f32(svbool_t, float32_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32offset_s32)))
-svint32_t svld1_gather_u32offset_s32(svbool_t, int32_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64offset_u64)))
-svuint64_t svld1_gather_s64offset_u64(svbool_t, uint64_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64offset_f64)))
-svfloat64_t svld1_gather_s64offset_f64(svbool_t, float64_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64offset_s64)))
-svint64_t svld1_gather_s64offset_s64(svbool_t, int64_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64offset_u64)))
-svuint64_t svld1_gather_u64offset_u64(svbool_t, uint64_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64offset_f64)))
-svfloat64_t svld1_gather_u64offset_f64(svbool_t, float64_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64offset_s64)))
-svint64_t svld1_gather_u64offset_s64(svbool_t, int64_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u8)))
-svuint8_t svld1_vnum_u8(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u32)))
-svuint32_t svld1_vnum_u32(svbool_t, uint32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u64)))
-svuint64_t svld1_vnum_u64(svbool_t, uint64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u16)))
-svuint16_t svld1_vnum_u16(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s8)))
-svint8_t svld1_vnum_s8(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f64)))
-svfloat64_t svld1_vnum_f64(svbool_t, float64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f32)))
-svfloat32_t svld1_vnum_f32(svbool_t, float32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f16)))
-svfloat16_t svld1_vnum_f16(svbool_t, float16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s32)))
-svint32_t svld1_vnum_s32(svbool_t, int32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s64)))
-svint64_t svld1_vnum_s64(svbool_t, int64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s16)))
-svint16_t svld1_vnum_s16(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u8)))
-svuint8_t svld1rq_u8(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u32)))
-svuint32_t svld1rq_u32(svbool_t, uint32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u64)))
-svuint64_t svld1rq_u64(svbool_t, uint64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u16)))
-svuint16_t svld1rq_u16(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s8)))
-svint8_t svld1rq_s8(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_f64)))
-svfloat64_t svld1rq_f64(svbool_t, float64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_f32)))
-svfloat32_t svld1rq_f32(svbool_t, float32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_f16)))
-svfloat16_t svld1rq_f16(svbool_t, float16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s32)))
-svint32_t svld1rq_s32(svbool_t, int32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s64)))
-svint64_t svld1rq_s64(svbool_t, int64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s16)))
-svint16_t svld1rq_s16(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_offset_u32)))
-svuint32_t svld1sb_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_offset_u64)))
-svuint64_t svld1sb_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_offset_s32)))
-svint32_t svld1sb_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_offset_s64)))
-svint64_t svld1sb_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_u32)))
-svuint32_t svld1sb_gather_u32base_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_u64)))
-svuint64_t svld1sb_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_s32)))
-svint32_t svld1sb_gather_u32base_s32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_s64)))
-svint64_t svld1sb_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s32offset_u32)))
-svuint32_t svld1sb_gather_s32offset_u32(svbool_t, int8_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s32offset_s32)))
-svint32_t svld1sb_gather_s32offset_s32(svbool_t, int8_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32offset_u32)))
-svuint32_t svld1sb_gather_u32offset_u32(svbool_t, int8_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32offset_s32)))
-svint32_t svld1sb_gather_u32offset_s32(svbool_t, int8_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s64offset_u64)))
-svuint64_t svld1sb_gather_s64offset_u64(svbool_t, int8_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s64offset_s64)))
-svint64_t svld1sb_gather_s64offset_s64(svbool_t, int8_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64offset_u64)))
-svuint64_t svld1sb_gather_u64offset_u64(svbool_t, int8_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64offset_s64)))
-svint64_t svld1sb_gather_u64offset_s64(svbool_t, int8_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_vnum_u32)))
-svuint32_t svld1sb_vnum_u32(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_vnum_u64)))
-svuint64_t svld1sb_vnum_u64(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_vnum_u16)))
-svuint16_t svld1sb_vnum_u16(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_vnum_s32)))
-svint32_t svld1sb_vnum_s32(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_vnum_s64)))
-svint64_t svld1sb_vnum_s64(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_vnum_s16)))
-svint16_t svld1sb_vnum_s16(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_u32)))
-svuint32_t svld1sb_u32(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_u64)))
-svuint64_t svld1sb_u64(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_u16)))
-svuint16_t svld1sb_u16(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_s32)))
-svint32_t svld1sb_s32(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_s64)))
-svint64_t svld1sb_s64(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_s16)))
-svint16_t svld1sb_s16(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_index_u32)))
-svuint32_t svld1sh_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_index_u64)))
-svuint64_t svld1sh_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_index_s32)))
-svint32_t svld1sh_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_index_s64)))
-svint64_t svld1sh_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_offset_u32)))
-svuint32_t svld1sh_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_offset_u64)))
-svuint64_t svld1sh_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_offset_s32)))
-svint32_t svld1sh_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_offset_s64)))
-svint64_t svld1sh_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_u32)))
-svuint32_t svld1sh_gather_u32base_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_u64)))
-svuint64_t svld1sh_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_s32)))
-svint32_t svld1sh_gather_u32base_s32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_s64)))
-svint64_t svld1sh_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32index_u32)))
-svuint32_t svld1sh_gather_s32index_u32(svbool_t, int16_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32index_s32)))
-svint32_t svld1sh_gather_s32index_s32(svbool_t, int16_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32index_u32)))
-svuint32_t svld1sh_gather_u32index_u32(svbool_t, int16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32index_s32)))
-svint32_t svld1sh_gather_u32index_s32(svbool_t, int16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64index_u64)))
-svuint64_t svld1sh_gather_s64index_u64(svbool_t, int16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64index_s64)))
-svint64_t svld1sh_gather_s64index_s64(svbool_t, int16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64index_u64)))
-svuint64_t svld1sh_gather_u64index_u64(svbool_t, int16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64index_s64)))
-svint64_t svld1sh_gather_u64index_s64(svbool_t, int16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32offset_u32)))
-svuint32_t svld1sh_gather_s32offset_u32(svbool_t, int16_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32offset_s32)))
-svint32_t svld1sh_gather_s32offset_s32(svbool_t, int16_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32offset_u32)))
-svuint32_t svld1sh_gather_u32offset_u32(svbool_t, int16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32offset_s32)))
-svint32_t svld1sh_gather_u32offset_s32(svbool_t, int16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64offset_u64)))
-svuint64_t svld1sh_gather_s64offset_u64(svbool_t, int16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64offset_s64)))
-svint64_t svld1sh_gather_s64offset_s64(svbool_t, int16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64offset_u64)))
-svuint64_t svld1sh_gather_u64offset_u64(svbool_t, int16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64offset_s64)))
-svint64_t svld1sh_gather_u64offset_s64(svbool_t, int16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_vnum_u32)))
-svuint32_t svld1sh_vnum_u32(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_vnum_u64)))
-svuint64_t svld1sh_vnum_u64(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_vnum_s32)))
-svint32_t svld1sh_vnum_s32(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_vnum_s64)))
-svint64_t svld1sh_vnum_s64(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_u32)))
-svuint32_t svld1sh_u32(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_u64)))
-svuint64_t svld1sh_u64(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_s32)))
-svint32_t svld1sh_s32(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_s64)))
-svint64_t svld1sh_s64(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_index_u64)))
-svuint64_t svld1sw_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_index_s64)))
-svint64_t svld1sw_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_offset_u64)))
-svuint64_t svld1sw_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_offset_s64)))
-svint64_t svld1sw_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_u64)))
-svuint64_t svld1sw_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_s64)))
-svint64_t svld1sw_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64index_u64)))
-svuint64_t svld1sw_gather_s64index_u64(svbool_t, int32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64index_s64)))
-svint64_t svld1sw_gather_s64index_s64(svbool_t, int32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64index_u64)))
-svuint64_t svld1sw_gather_u64index_u64(svbool_t, int32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64index_s64)))
-svint64_t svld1sw_gather_u64index_s64(svbool_t, int32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64offset_u64)))
-svuint64_t svld1sw_gather_s64offset_u64(svbool_t, int32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64offset_s64)))
-svint64_t svld1sw_gather_s64offset_s64(svbool_t, int32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64offset_u64)))
-svuint64_t svld1sw_gather_u64offset_u64(svbool_t, int32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64offset_s64)))
-svint64_t svld1sw_gather_u64offset_s64(svbool_t, int32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_vnum_u64)))
-svuint64_t svld1sw_vnum_u64(svbool_t, int32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_vnum_s64)))
-svint64_t svld1sw_vnum_s64(svbool_t, int32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_u64)))
-svuint64_t svld1sw_u64(svbool_t, int32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_s64)))
-svint64_t svld1sw_s64(svbool_t, int32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_offset_u32)))
-svuint32_t svld1ub_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_offset_u64)))
-svuint64_t svld1ub_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_offset_s32)))
-svint32_t svld1ub_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_offset_s64)))
-svint64_t svld1ub_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_u32)))
-svuint32_t svld1ub_gather_u32base_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_u64)))
-svuint64_t svld1ub_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_s32)))
-svint32_t svld1ub_gather_u32base_s32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_s64)))
-svint64_t svld1ub_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s32offset_u32)))
-svuint32_t svld1ub_gather_s32offset_u32(svbool_t, uint8_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s32offset_s32)))
-svint32_t svld1ub_gather_s32offset_s32(svbool_t, uint8_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32offset_u32)))
-svuint32_t svld1ub_gather_u32offset_u32(svbool_t, uint8_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32offset_s32)))
-svint32_t svld1ub_gather_u32offset_s32(svbool_t, uint8_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s64offset_u64)))
-svuint64_t svld1ub_gather_s64offset_u64(svbool_t, uint8_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s64offset_s64)))
-svint64_t svld1ub_gather_s64offset_s64(svbool_t, uint8_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64offset_u64)))
-svuint64_t svld1ub_gather_u64offset_u64(svbool_t, uint8_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64offset_s64)))
-svint64_t svld1ub_gather_u64offset_s64(svbool_t, uint8_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_vnum_u32)))
-svuint32_t svld1ub_vnum_u32(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_vnum_u64)))
-svuint64_t svld1ub_vnum_u64(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_vnum_u16)))
-svuint16_t svld1ub_vnum_u16(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_vnum_s32)))
-svint32_t svld1ub_vnum_s32(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_vnum_s64)))
-svint64_t svld1ub_vnum_s64(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_vnum_s16)))
-svint16_t svld1ub_vnum_s16(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_u32)))
-svuint32_t svld1ub_u32(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_u64)))
-svuint64_t svld1ub_u64(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_u16)))
-svuint16_t svld1ub_u16(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_s32)))
-svint32_t svld1ub_s32(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_s64)))
-svint64_t svld1ub_s64(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_s16)))
-svint16_t svld1ub_s16(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_index_u32)))
-svuint32_t svld1uh_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_index_u64)))
-svuint64_t svld1uh_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_index_s32)))
-svint32_t svld1uh_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_index_s64)))
-svint64_t svld1uh_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_offset_u32)))
-svuint32_t svld1uh_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_offset_u64)))
-svuint64_t svld1uh_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_offset_s32)))
-svint32_t svld1uh_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_offset_s64)))
-svint64_t svld1uh_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_u32)))
-svuint32_t svld1uh_gather_u32base_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_u64)))
-svuint64_t svld1uh_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_s32)))
-svint32_t svld1uh_gather_u32base_s32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_s64)))
-svint64_t svld1uh_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32index_u32)))
-svuint32_t svld1uh_gather_s32index_u32(svbool_t, uint16_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32index_s32)))
-svint32_t svld1uh_gather_s32index_s32(svbool_t, uint16_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32index_u32)))
-svuint32_t svld1uh_gather_u32index_u32(svbool_t, uint16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32index_s32)))
-svint32_t svld1uh_gather_u32index_s32(svbool_t, uint16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64index_u64)))
-svuint64_t svld1uh_gather_s64index_u64(svbool_t, uint16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64index_s64)))
-svint64_t svld1uh_gather_s64index_s64(svbool_t, uint16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64index_u64)))
-svuint64_t svld1uh_gather_u64index_u64(svbool_t, uint16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64index_s64)))
-svint64_t svld1uh_gather_u64index_s64(svbool_t, uint16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32offset_u32)))
-svuint32_t svld1uh_gather_s32offset_u32(svbool_t, uint16_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32offset_s32)))
-svint32_t svld1uh_gather_s32offset_s32(svbool_t, uint16_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32offset_u32)))
-svuint32_t svld1uh_gather_u32offset_u32(svbool_t, uint16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32offset_s32)))
-svint32_t svld1uh_gather_u32offset_s32(svbool_t, uint16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64offset_u64)))
-svuint64_t svld1uh_gather_s64offset_u64(svbool_t, uint16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64offset_s64)))
-svint64_t svld1uh_gather_s64offset_s64(svbool_t, uint16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64offset_u64)))
-svuint64_t svld1uh_gather_u64offset_u64(svbool_t, uint16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64offset_s64)))
-svint64_t svld1uh_gather_u64offset_s64(svbool_t, uint16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_vnum_u32)))
-svuint32_t svld1uh_vnum_u32(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_vnum_u64)))
-svuint64_t svld1uh_vnum_u64(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_vnum_s32)))
-svint32_t svld1uh_vnum_s32(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_vnum_s64)))
-svint64_t svld1uh_vnum_s64(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_u32)))
-svuint32_t svld1uh_u32(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_u64)))
-svuint64_t svld1uh_u64(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_s32)))
-svint32_t svld1uh_s32(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_s64)))
-svint64_t svld1uh_s64(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_index_u64)))
-svuint64_t svld1uw_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_index_s64)))
-svint64_t svld1uw_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_offset_u64)))
-svuint64_t svld1uw_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_offset_s64)))
-svint64_t svld1uw_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_u64)))
-svuint64_t svld1uw_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_s64)))
-svint64_t svld1uw_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64index_u64)))
-svuint64_t svld1uw_gather_s64index_u64(svbool_t, uint32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64index_s64)))
-svint64_t svld1uw_gather_s64index_s64(svbool_t, uint32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64index_u64)))
-svuint64_t svld1uw_gather_u64index_u64(svbool_t, uint32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64index_s64)))
-svint64_t svld1uw_gather_u64index_s64(svbool_t, uint32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64offset_u64)))
-svuint64_t svld1uw_gather_s64offset_u64(svbool_t, uint32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64offset_s64)))
-svint64_t svld1uw_gather_s64offset_s64(svbool_t, uint32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64offset_u64)))
-svuint64_t svld1uw_gather_u64offset_u64(svbool_t, uint32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64offset_s64)))
-svint64_t svld1uw_gather_u64offset_s64(svbool_t, uint32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_vnum_u64)))
-svuint64_t svld1uw_vnum_u64(svbool_t, uint32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_vnum_s64)))
-svint64_t svld1uw_vnum_s64(svbool_t, uint32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_u64)))
-svuint64_t svld1uw_u64(svbool_t, uint32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_s64)))
-svint64_t svld1uw_s64(svbool_t, uint32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u8)))
-svuint8x2_t svld2_u8(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u32)))
-svuint32x2_t svld2_u32(svbool_t, uint32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u64)))
-svuint64x2_t svld2_u64(svbool_t, uint64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u16)))
-svuint16x2_t svld2_u16(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s8)))
-svint8x2_t svld2_s8(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_f64)))
-svfloat64x2_t svld2_f64(svbool_t, float64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_f32)))
-svfloat32x2_t svld2_f32(svbool_t, float32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_f16)))
-svfloat16x2_t svld2_f16(svbool_t, float16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s32)))
-svint32x2_t svld2_s32(svbool_t, int32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s64)))
-svint64x2_t svld2_s64(svbool_t, int64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s16)))
-svint16x2_t svld2_s16(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u8)))
-svuint8x2_t svld2_vnum_u8(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u32)))
-svuint32x2_t svld2_vnum_u32(svbool_t, uint32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u64)))
-svuint64x2_t svld2_vnum_u64(svbool_t, uint64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u16)))
-svuint16x2_t svld2_vnum_u16(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s8)))
-svint8x2_t svld2_vnum_s8(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_f64)))
-svfloat64x2_t svld2_vnum_f64(svbool_t, float64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_f32)))
-svfloat32x2_t svld2_vnum_f32(svbool_t, float32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_f16)))
-svfloat16x2_t svld2_vnum_f16(svbool_t, float16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s32)))
-svint32x2_t svld2_vnum_s32(svbool_t, int32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s64)))
-svint64x2_t svld2_vnum_s64(svbool_t, int64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s16)))
-svint16x2_t svld2_vnum_s16(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u8)))
-svuint8x3_t svld3_u8(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u32)))
-svuint32x3_t svld3_u32(svbool_t, uint32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u64)))
-svuint64x3_t svld3_u64(svbool_t, uint64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u16)))
-svuint16x3_t svld3_u16(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s8)))
-svint8x3_t svld3_s8(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_f64)))
-svfloat64x3_t svld3_f64(svbool_t, float64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_f32)))
-svfloat32x3_t svld3_f32(svbool_t, float32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_f16)))
-svfloat16x3_t svld3_f16(svbool_t, float16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s32)))
-svint32x3_t svld3_s32(svbool_t, int32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s64)))
-svint64x3_t svld3_s64(svbool_t, int64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s16)))
-svint16x3_t svld3_s16(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u8)))
-svuint8x3_t svld3_vnum_u8(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u32)))
-svuint32x3_t svld3_vnum_u32(svbool_t, uint32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u64)))
-svuint64x3_t svld3_vnum_u64(svbool_t, uint64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u16)))
-svuint16x3_t svld3_vnum_u16(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s8)))
-svint8x3_t svld3_vnum_s8(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_f64)))
-svfloat64x3_t svld3_vnum_f64(svbool_t, float64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_f32)))
-svfloat32x3_t svld3_vnum_f32(svbool_t, float32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_f16)))
-svfloat16x3_t svld3_vnum_f16(svbool_t, float16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s32)))
-svint32x3_t svld3_vnum_s32(svbool_t, int32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s64)))
-svint64x3_t svld3_vnum_s64(svbool_t, int64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s16)))
-svint16x3_t svld3_vnum_s16(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u8)))
-svuint8x4_t svld4_u8(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u32)))
-svuint32x4_t svld4_u32(svbool_t, uint32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u64)))
-svuint64x4_t svld4_u64(svbool_t, uint64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u16)))
-svuint16x4_t svld4_u16(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s8)))
-svint8x4_t svld4_s8(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_f64)))
-svfloat64x4_t svld4_f64(svbool_t, float64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_f32)))
-svfloat32x4_t svld4_f32(svbool_t, float32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_f16)))
-svfloat16x4_t svld4_f16(svbool_t, float16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s32)))
-svint32x4_t svld4_s32(svbool_t, int32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s64)))
-svint64x4_t svld4_s64(svbool_t, int64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s16)))
-svint16x4_t svld4_s16(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u8)))
-svuint8x4_t svld4_vnum_u8(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u32)))
-svuint32x4_t svld4_vnum_u32(svbool_t, uint32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u64)))
-svuint64x4_t svld4_vnum_u64(svbool_t, uint64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u16)))
-svuint16x4_t svld4_vnum_u16(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s8)))
-svint8x4_t svld4_vnum_s8(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_f64)))
-svfloat64x4_t svld4_vnum_f64(svbool_t, float64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_f32)))
-svfloat32x4_t svld4_vnum_f32(svbool_t, float32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_f16)))
-svfloat16x4_t svld4_vnum_f16(svbool_t, float16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s32)))
-svint32x4_t svld4_vnum_s32(svbool_t, int32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s64)))
-svint64x4_t svld4_vnum_s64(svbool_t, int64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s16)))
-svint16x4_t svld4_vnum_s16(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u8)))
-svuint8_t svldff1_u8(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u32)))
-svuint32_t svldff1_u32(svbool_t, uint32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u64)))
-svuint64_t svldff1_u64(svbool_t, uint64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u16)))
-svuint16_t svldff1_u16(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s8)))
-svint8_t svldff1_s8(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_f64)))
-svfloat64_t svldff1_f64(svbool_t, float64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_f32)))
-svfloat32_t svldff1_f32(svbool_t, float32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_f16)))
-svfloat16_t svldff1_f16(svbool_t, float16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s32)))
-svint32_t svldff1_s32(svbool_t, int32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s64)))
-svint64_t svldff1_s64(svbool_t, int64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s16)))
-svint16_t svldff1_s16(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_index_u32)))
-svuint32_t svldff1_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_index_u64)))
-svuint64_t svldff1_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_index_f64)))
-svfloat64_t svldff1_gather_u64base_index_f64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_index_f32)))
-svfloat32_t svldff1_gather_u32base_index_f32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_index_s32)))
-svint32_t svldff1_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_index_s64)))
-svint64_t svldff1_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_offset_u32)))
-svuint32_t svldff1_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_offset_u64)))
-svuint64_t svldff1_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_offset_f64)))
-svfloat64_t svldff1_gather_u64base_offset_f64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_offset_f32)))
-svfloat32_t svldff1_gather_u32base_offset_f32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_offset_s32)))
-svint32_t svldff1_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_offset_s64)))
-svint64_t svldff1_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_u32)))
-svuint32_t svldff1_gather_u32base_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_u64)))
-svuint64_t svldff1_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_f64)))
-svfloat64_t svldff1_gather_u64base_f64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_f32)))
-svfloat32_t svldff1_gather_u32base_f32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_s32)))
-svint32_t svldff1_gather_u32base_s32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_s64)))
-svint64_t svldff1_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32index_u32)))
-svuint32_t svldff1_gather_s32index_u32(svbool_t, uint32_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32index_f32)))
-svfloat32_t svldff1_gather_s32index_f32(svbool_t, float32_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32index_s32)))
-svint32_t svldff1_gather_s32index_s32(svbool_t, int32_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32index_u32)))
-svuint32_t svldff1_gather_u32index_u32(svbool_t, uint32_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32index_f32)))
-svfloat32_t svldff1_gather_u32index_f32(svbool_t, float32_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32index_s32)))
-svint32_t svldff1_gather_u32index_s32(svbool_t, int32_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64index_u64)))
-svuint64_t svldff1_gather_s64index_u64(svbool_t, uint64_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64index_f64)))
-svfloat64_t svldff1_gather_s64index_f64(svbool_t, float64_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64index_s64)))
-svint64_t svldff1_gather_s64index_s64(svbool_t, int64_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64index_u64)))
-svuint64_t svldff1_gather_u64index_u64(svbool_t, uint64_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64index_f64)))
-svfloat64_t svldff1_gather_u64index_f64(svbool_t, float64_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64index_s64)))
-svint64_t svldff1_gather_u64index_s64(svbool_t, int64_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32offset_u32)))
-svuint32_t svldff1_gather_s32offset_u32(svbool_t, uint32_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32offset_f32)))
-svfloat32_t svldff1_gather_s32offset_f32(svbool_t, float32_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32offset_s32)))
-svint32_t svldff1_gather_s32offset_s32(svbool_t, int32_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32offset_u32)))
-svuint32_t svldff1_gather_u32offset_u32(svbool_t, uint32_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32offset_f32)))
-svfloat32_t svldff1_gather_u32offset_f32(svbool_t, float32_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32offset_s32)))
-svint32_t svldff1_gather_u32offset_s32(svbool_t, int32_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64offset_u64)))
-svuint64_t svldff1_gather_s64offset_u64(svbool_t, uint64_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64offset_f64)))
-svfloat64_t svldff1_gather_s64offset_f64(svbool_t, float64_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64offset_s64)))
-svint64_t svldff1_gather_s64offset_s64(svbool_t, int64_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64offset_u64)))
-svuint64_t svldff1_gather_u64offset_u64(svbool_t, uint64_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64offset_f64)))
-svfloat64_t svldff1_gather_u64offset_f64(svbool_t, float64_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64offset_s64)))
-svint64_t svldff1_gather_u64offset_s64(svbool_t, int64_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u8)))
-svuint8_t svldff1_vnum_u8(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u32)))
-svuint32_t svldff1_vnum_u32(svbool_t, uint32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u64)))
-svuint64_t svldff1_vnum_u64(svbool_t, uint64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u16)))
-svuint16_t svldff1_vnum_u16(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s8)))
-svint8_t svldff1_vnum_s8(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_f64)))
-svfloat64_t svldff1_vnum_f64(svbool_t, float64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_f32)))
-svfloat32_t svldff1_vnum_f32(svbool_t, float32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_f16)))
-svfloat16_t svldff1_vnum_f16(svbool_t, float16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s32)))
-svint32_t svldff1_vnum_s32(svbool_t, int32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s64)))
-svint64_t svldff1_vnum_s64(svbool_t, int64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s16)))
-svint16_t svldff1_vnum_s16(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_offset_u32)))
-svuint32_t svldff1sb_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_offset_u64)))
-svuint64_t svldff1sb_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_offset_s32)))
-svint32_t svldff1sb_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_offset_s64)))
-svint64_t svldff1sb_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_u32)))
-svuint32_t svldff1sb_gather_u32base_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_u64)))
-svuint64_t svldff1sb_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_s32)))
-svint32_t svldff1sb_gather_u32base_s32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_s64)))
-svint64_t svldff1sb_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s32offset_u32)))
-svuint32_t svldff1sb_gather_s32offset_u32(svbool_t, int8_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s32offset_s32)))
-svint32_t svldff1sb_gather_s32offset_s32(svbool_t, int8_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32offset_u32)))
-svuint32_t svldff1sb_gather_u32offset_u32(svbool_t, int8_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32offset_s32)))
-svint32_t svldff1sb_gather_u32offset_s32(svbool_t, int8_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s64offset_u64)))
-svuint64_t svldff1sb_gather_s64offset_u64(svbool_t, int8_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s64offset_s64)))
-svint64_t svldff1sb_gather_s64offset_s64(svbool_t, int8_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64offset_u64)))
-svuint64_t svldff1sb_gather_u64offset_u64(svbool_t, int8_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64offset_s64)))
-svint64_t svldff1sb_gather_u64offset_s64(svbool_t, int8_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_vnum_u32)))
-svuint32_t svldff1sb_vnum_u32(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_vnum_u64)))
-svuint64_t svldff1sb_vnum_u64(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_vnum_u16)))
-svuint16_t svldff1sb_vnum_u16(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_vnum_s32)))
-svint32_t svldff1sb_vnum_s32(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_vnum_s64)))
-svint64_t svldff1sb_vnum_s64(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_vnum_s16)))
-svint16_t svldff1sb_vnum_s16(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_u32)))
-svuint32_t svldff1sb_u32(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_u64)))
-svuint64_t svldff1sb_u64(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_u16)))
-svuint16_t svldff1sb_u16(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_s32)))
-svint32_t svldff1sb_s32(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_s64)))
-svint64_t svldff1sb_s64(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_s16)))
-svint16_t svldff1sb_s16(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_index_u32)))
-svuint32_t svldff1sh_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_index_u64)))
-svuint64_t svldff1sh_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_index_s32)))
-svint32_t svldff1sh_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_index_s64)))
-svint64_t svldff1sh_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_offset_u32)))
-svuint32_t svldff1sh_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_offset_u64)))
-svuint64_t svldff1sh_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_offset_s32)))
-svint32_t svldff1sh_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_offset_s64)))
-svint64_t svldff1sh_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_u32)))
-svuint32_t svldff1sh_gather_u32base_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_u64)))
-svuint64_t svldff1sh_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_s32)))
-svint32_t svldff1sh_gather_u32base_s32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_s64)))
-svint64_t svldff1sh_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32index_u32)))
-svuint32_t svldff1sh_gather_s32index_u32(svbool_t, int16_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32index_s32)))
-svint32_t svldff1sh_gather_s32index_s32(svbool_t, int16_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32index_u32)))
-svuint32_t svldff1sh_gather_u32index_u32(svbool_t, int16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32index_s32)))
-svint32_t svldff1sh_gather_u32index_s32(svbool_t, int16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64index_u64)))
-svuint64_t svldff1sh_gather_s64index_u64(svbool_t, int16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64index_s64)))
-svint64_t svldff1sh_gather_s64index_s64(svbool_t, int16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64index_u64)))
-svuint64_t svldff1sh_gather_u64index_u64(svbool_t, int16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64index_s64)))
-svint64_t svldff1sh_gather_u64index_s64(svbool_t, int16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32offset_u32)))
-svuint32_t svldff1sh_gather_s32offset_u32(svbool_t, int16_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32offset_s32)))
-svint32_t svldff1sh_gather_s32offset_s32(svbool_t, int16_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32offset_u32)))
-svuint32_t svldff1sh_gather_u32offset_u32(svbool_t, int16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32offset_s32)))
-svint32_t svldff1sh_gather_u32offset_s32(svbool_t, int16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64offset_u64)))
-svuint64_t svldff1sh_gather_s64offset_u64(svbool_t, int16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64offset_s64)))
-svint64_t svldff1sh_gather_s64offset_s64(svbool_t, int16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64offset_u64)))
-svuint64_t svldff1sh_gather_u64offset_u64(svbool_t, int16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64offset_s64)))
-svint64_t svldff1sh_gather_u64offset_s64(svbool_t, int16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_vnum_u32)))
-svuint32_t svldff1sh_vnum_u32(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_vnum_u64)))
-svuint64_t svldff1sh_vnum_u64(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_vnum_s32)))
-svint32_t svldff1sh_vnum_s32(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_vnum_s64)))
-svint64_t svldff1sh_vnum_s64(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_u32)))
-svuint32_t svldff1sh_u32(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_u64)))
-svuint64_t svldff1sh_u64(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_s32)))
-svint32_t svldff1sh_s32(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_s64)))
-svint64_t svldff1sh_s64(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_index_u64)))
-svuint64_t svldff1sw_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_index_s64)))
-svint64_t svldff1sw_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_offset_u64)))
-svuint64_t svldff1sw_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_offset_s64)))
-svint64_t svldff1sw_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_u64)))
-svuint64_t svldff1sw_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_s64)))
-svint64_t svldff1sw_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64index_u64)))
-svuint64_t svldff1sw_gather_s64index_u64(svbool_t, int32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64index_s64)))
-svint64_t svldff1sw_gather_s64index_s64(svbool_t, int32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64index_u64)))
-svuint64_t svldff1sw_gather_u64index_u64(svbool_t, int32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64index_s64)))
-svint64_t svldff1sw_gather_u64index_s64(svbool_t, int32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64offset_u64)))
-svuint64_t svldff1sw_gather_s64offset_u64(svbool_t, int32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64offset_s64)))
-svint64_t svldff1sw_gather_s64offset_s64(svbool_t, int32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64offset_u64)))
-svuint64_t svldff1sw_gather_u64offset_u64(svbool_t, int32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64offset_s64)))
-svint64_t svldff1sw_gather_u64offset_s64(svbool_t, int32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_vnum_u64)))
-svuint64_t svldff1sw_vnum_u64(svbool_t, int32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_vnum_s64)))
-svint64_t svldff1sw_vnum_s64(svbool_t, int32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_u64)))
-svuint64_t svldff1sw_u64(svbool_t, int32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_s64)))
-svint64_t svldff1sw_s64(svbool_t, int32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_offset_u32)))
-svuint32_t svldff1ub_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_offset_u64)))
-svuint64_t svldff1ub_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_offset_s32)))
-svint32_t svldff1ub_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_offset_s64)))
-svint64_t svldff1ub_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_u32)))
-svuint32_t svldff1ub_gather_u32base_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_u64)))
-svuint64_t svldff1ub_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_s32)))
-svint32_t svldff1ub_gather_u32base_s32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_s64)))
-svint64_t svldff1ub_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s32offset_u32)))
-svuint32_t svldff1ub_gather_s32offset_u32(svbool_t, uint8_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s32offset_s32)))
-svint32_t svldff1ub_gather_s32offset_s32(svbool_t, uint8_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32offset_u32)))
-svuint32_t svldff1ub_gather_u32offset_u32(svbool_t, uint8_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32offset_s32)))
-svint32_t svldff1ub_gather_u32offset_s32(svbool_t, uint8_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s64offset_u64)))
-svuint64_t svldff1ub_gather_s64offset_u64(svbool_t, uint8_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s64offset_s64)))
-svint64_t svldff1ub_gather_s64offset_s64(svbool_t, uint8_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64offset_u64)))
-svuint64_t svldff1ub_gather_u64offset_u64(svbool_t, uint8_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64offset_s64)))
-svint64_t svldff1ub_gather_u64offset_s64(svbool_t, uint8_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_vnum_u32)))
-svuint32_t svldff1ub_vnum_u32(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_vnum_u64)))
-svuint64_t svldff1ub_vnum_u64(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_vnum_u16)))
-svuint16_t svldff1ub_vnum_u16(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_vnum_s32)))
-svint32_t svldff1ub_vnum_s32(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_vnum_s64)))
-svint64_t svldff1ub_vnum_s64(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_vnum_s16)))
-svint16_t svldff1ub_vnum_s16(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_u32)))
-svuint32_t svldff1ub_u32(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_u64)))
-svuint64_t svldff1ub_u64(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_u16)))
-svuint16_t svldff1ub_u16(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_s32)))
-svint32_t svldff1ub_s32(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_s64)))
-svint64_t svldff1ub_s64(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_s16)))
-svint16_t svldff1ub_s16(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_index_u32)))
-svuint32_t svldff1uh_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_index_u64)))
-svuint64_t svldff1uh_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_index_s32)))
-svint32_t svldff1uh_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_index_s64)))
-svint64_t svldff1uh_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_offset_u32)))
-svuint32_t svldff1uh_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_offset_u64)))
-svuint64_t svldff1uh_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_offset_s32)))
-svint32_t svldff1uh_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_offset_s64)))
-svint64_t svldff1uh_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_u32)))
-svuint32_t svldff1uh_gather_u32base_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_u64)))
-svuint64_t svldff1uh_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_s32)))
-svint32_t svldff1uh_gather_u32base_s32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_s64)))
-svint64_t svldff1uh_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32index_u32)))
-svuint32_t svldff1uh_gather_s32index_u32(svbool_t, uint16_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32index_s32)))
-svint32_t svldff1uh_gather_s32index_s32(svbool_t, uint16_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32index_u32)))
-svuint32_t svldff1uh_gather_u32index_u32(svbool_t, uint16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32index_s32)))
-svint32_t svldff1uh_gather_u32index_s32(svbool_t, uint16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64index_u64)))
-svuint64_t svldff1uh_gather_s64index_u64(svbool_t, uint16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64index_s64)))
-svint64_t svldff1uh_gather_s64index_s64(svbool_t, uint16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64index_u64)))
-svuint64_t svldff1uh_gather_u64index_u64(svbool_t, uint16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64index_s64)))
-svint64_t svldff1uh_gather_u64index_s64(svbool_t, uint16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32offset_u32)))
-svuint32_t svldff1uh_gather_s32offset_u32(svbool_t, uint16_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32offset_s32)))
-svint32_t svldff1uh_gather_s32offset_s32(svbool_t, uint16_t const *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32offset_u32)))
-svuint32_t svldff1uh_gather_u32offset_u32(svbool_t, uint16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32offset_s32)))
-svint32_t svldff1uh_gather_u32offset_s32(svbool_t, uint16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64offset_u64)))
-svuint64_t svldff1uh_gather_s64offset_u64(svbool_t, uint16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64offset_s64)))
-svint64_t svldff1uh_gather_s64offset_s64(svbool_t, uint16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64offset_u64)))
-svuint64_t svldff1uh_gather_u64offset_u64(svbool_t, uint16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64offset_s64)))
-svint64_t svldff1uh_gather_u64offset_s64(svbool_t, uint16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_vnum_u32)))
-svuint32_t svldff1uh_vnum_u32(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_vnum_u64)))
-svuint64_t svldff1uh_vnum_u64(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_vnum_s32)))
-svint32_t svldff1uh_vnum_s32(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_vnum_s64)))
-svint64_t svldff1uh_vnum_s64(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_u32)))
-svuint32_t svldff1uh_u32(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_u64)))
-svuint64_t svldff1uh_u64(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_s32)))
-svint32_t svldff1uh_s32(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_s64)))
-svint64_t svldff1uh_s64(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_index_u64)))
-svuint64_t svldff1uw_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_index_s64)))
-svint64_t svldff1uw_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_offset_u64)))
-svuint64_t svldff1uw_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_offset_s64)))
-svint64_t svldff1uw_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_u64)))
-svuint64_t svldff1uw_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_s64)))
-svint64_t svldff1uw_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64index_u64)))
-svuint64_t svldff1uw_gather_s64index_u64(svbool_t, uint32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64index_s64)))
-svint64_t svldff1uw_gather_s64index_s64(svbool_t, uint32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64index_u64)))
-svuint64_t svldff1uw_gather_u64index_u64(svbool_t, uint32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64index_s64)))
-svint64_t svldff1uw_gather_u64index_s64(svbool_t, uint32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64offset_u64)))
-svuint64_t svldff1uw_gather_s64offset_u64(svbool_t, uint32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64offset_s64)))
-svint64_t svldff1uw_gather_s64offset_s64(svbool_t, uint32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64offset_u64)))
-svuint64_t svldff1uw_gather_u64offset_u64(svbool_t, uint32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64offset_s64)))
-svint64_t svldff1uw_gather_u64offset_s64(svbool_t, uint32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_vnum_u64)))
-svuint64_t svldff1uw_vnum_u64(svbool_t, uint32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_vnum_s64)))
-svint64_t svldff1uw_vnum_s64(svbool_t, uint32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_u64)))
-svuint64_t svldff1uw_u64(svbool_t, uint32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_s64)))
-svint64_t svldff1uw_s64(svbool_t, uint32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u8)))
-svuint8_t svldnf1_u8(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u32)))
-svuint32_t svldnf1_u32(svbool_t, uint32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u64)))
-svuint64_t svldnf1_u64(svbool_t, uint64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u16)))
-svuint16_t svldnf1_u16(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s8)))
-svint8_t svldnf1_s8(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_f64)))
-svfloat64_t svldnf1_f64(svbool_t, float64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_f32)))
-svfloat32_t svldnf1_f32(svbool_t, float32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_f16)))
-svfloat16_t svldnf1_f16(svbool_t, float16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s32)))
-svint32_t svldnf1_s32(svbool_t, int32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s64)))
-svint64_t svldnf1_s64(svbool_t, int64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s16)))
-svint16_t svldnf1_s16(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u8)))
-svuint8_t svldnf1_vnum_u8(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u32)))
-svuint32_t svldnf1_vnum_u32(svbool_t, uint32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u64)))
-svuint64_t svldnf1_vnum_u64(svbool_t, uint64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u16)))
-svuint16_t svldnf1_vnum_u16(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s8)))
-svint8_t svldnf1_vnum_s8(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_f64)))
-svfloat64_t svldnf1_vnum_f64(svbool_t, float64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_f32)))
-svfloat32_t svldnf1_vnum_f32(svbool_t, float32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_f16)))
-svfloat16_t svldnf1_vnum_f16(svbool_t, float16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s32)))
-svint32_t svldnf1_vnum_s32(svbool_t, int32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s64)))
-svint64_t svldnf1_vnum_s64(svbool_t, int64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s16)))
-svint16_t svldnf1_vnum_s16(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_vnum_u32)))
-svuint32_t svldnf1sb_vnum_u32(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_vnum_u64)))
-svuint64_t svldnf1sb_vnum_u64(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_vnum_u16)))
-svuint16_t svldnf1sb_vnum_u16(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_vnum_s32)))
-svint32_t svldnf1sb_vnum_s32(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_vnum_s64)))
-svint64_t svldnf1sb_vnum_s64(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_vnum_s16)))
-svint16_t svldnf1sb_vnum_s16(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_u32)))
-svuint32_t svldnf1sb_u32(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_u64)))
-svuint64_t svldnf1sb_u64(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_u16)))
-svuint16_t svldnf1sb_u16(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_s32)))
-svint32_t svldnf1sb_s32(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_s64)))
-svint64_t svldnf1sb_s64(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_s16)))
-svint16_t svldnf1sb_s16(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_vnum_u32)))
-svuint32_t svldnf1sh_vnum_u32(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_vnum_u64)))
-svuint64_t svldnf1sh_vnum_u64(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_vnum_s32)))
-svint32_t svldnf1sh_vnum_s32(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_vnum_s64)))
-svint64_t svldnf1sh_vnum_s64(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_u32)))
-svuint32_t svldnf1sh_u32(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_u64)))
-svuint64_t svldnf1sh_u64(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_s32)))
-svint32_t svldnf1sh_s32(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_s64)))
-svint64_t svldnf1sh_s64(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sw_vnum_u64)))
-svuint64_t svldnf1sw_vnum_u64(svbool_t, int32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sw_vnum_s64)))
-svint64_t svldnf1sw_vnum_s64(svbool_t, int32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sw_u64)))
-svuint64_t svldnf1sw_u64(svbool_t, int32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sw_s64)))
-svint64_t svldnf1sw_s64(svbool_t, int32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_vnum_u32)))
-svuint32_t svldnf1ub_vnum_u32(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_vnum_u64)))
-svuint64_t svldnf1ub_vnum_u64(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_vnum_u16)))
-svuint16_t svldnf1ub_vnum_u16(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_vnum_s32)))
-svint32_t svldnf1ub_vnum_s32(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_vnum_s64)))
-svint64_t svldnf1ub_vnum_s64(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_vnum_s16)))
-svint16_t svldnf1ub_vnum_s16(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_u32)))
-svuint32_t svldnf1ub_u32(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_u64)))
-svuint64_t svldnf1ub_u64(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_u16)))
-svuint16_t svldnf1ub_u16(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_s32)))
-svint32_t svldnf1ub_s32(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_s64)))
-svint64_t svldnf1ub_s64(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_s16)))
-svint16_t svldnf1ub_s16(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_vnum_u32)))
-svuint32_t svldnf1uh_vnum_u32(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_vnum_u64)))
-svuint64_t svldnf1uh_vnum_u64(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_vnum_s32)))
-svint32_t svldnf1uh_vnum_s32(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_vnum_s64)))
-svint64_t svldnf1uh_vnum_s64(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_u32)))
-svuint32_t svldnf1uh_u32(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_u64)))
-svuint64_t svldnf1uh_u64(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_s32)))
-svint32_t svldnf1uh_s32(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_s64)))
-svint64_t svldnf1uh_s64(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uw_vnum_u64)))
-svuint64_t svldnf1uw_vnum_u64(svbool_t, uint32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uw_vnum_s64)))
-svint64_t svldnf1uw_vnum_s64(svbool_t, uint32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uw_u64)))
-svuint64_t svldnf1uw_u64(svbool_t, uint32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uw_s64)))
-svint64_t svldnf1uw_s64(svbool_t, uint32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u8)))
-svuint8_t svldnt1_u8(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u32)))
-svuint32_t svldnt1_u32(svbool_t, uint32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u64)))
-svuint64_t svldnt1_u64(svbool_t, uint64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u16)))
-svuint16_t svldnt1_u16(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s8)))
-svint8_t svldnt1_s8(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f64)))
-svfloat64_t svldnt1_f64(svbool_t, float64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f32)))
-svfloat32_t svldnt1_f32(svbool_t, float32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f16)))
-svfloat16_t svldnt1_f16(svbool_t, float16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s32)))
-svint32_t svldnt1_s32(svbool_t, int32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s64)))
-svint64_t svldnt1_s64(svbool_t, int64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s16)))
-svint16_t svldnt1_s16(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u8)))
-svuint8_t svldnt1_vnum_u8(svbool_t, uint8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u32)))
-svuint32_t svldnt1_vnum_u32(svbool_t, uint32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u64)))
-svuint64_t svldnt1_vnum_u64(svbool_t, uint64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u16)))
-svuint16_t svldnt1_vnum_u16(svbool_t, uint16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s8)))
-svint8_t svldnt1_vnum_s8(svbool_t, int8_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f64)))
-svfloat64_t svldnt1_vnum_f64(svbool_t, float64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f32)))
-svfloat32_t svldnt1_vnum_f32(svbool_t, float32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f16)))
-svfloat16_t svldnt1_vnum_f16(svbool_t, float16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s32)))
-svint32_t svldnt1_vnum_s32(svbool_t, int32_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s64)))
-svint64_t svldnt1_vnum_s64(svbool_t, int64_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s16)))
-svint16_t svldnt1_vnum_s16(svbool_t, int16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u8)))
-uint64_t svlen_u8(svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u32)))
-uint64_t svlen_u32(svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u64)))
-uint64_t svlen_u64(svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u16)))
-uint64_t svlen_u16(svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s8)))
-uint64_t svlen_s8(svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_f64)))
-uint64_t svlen_f64(svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_f32)))
-uint64_t svlen_f32(svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_f16)))
-uint64_t svlen_f16(svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s32)))
-uint64_t svlen_s32(svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s64)))
-uint64_t svlen_s64(svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s16)))
-uint64_t svlen_s16(svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u8_m)))
-svuint8_t svlsl_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u32_m)))
-svuint32_t svlsl_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u64_m)))
-svuint64_t svlsl_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u16_m)))
-svuint16_t svlsl_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s8_m)))
-svint8_t svlsl_n_s8_m(svbool_t, svint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s32_m)))
-svint32_t svlsl_n_s32_m(svbool_t, svint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s64_m)))
-svint64_t svlsl_n_s64_m(svbool_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s16_m)))
-svint16_t svlsl_n_s16_m(svbool_t, svint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u8_x)))
-svuint8_t svlsl_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u32_x)))
-svuint32_t svlsl_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u64_x)))
-svuint64_t svlsl_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u16_x)))
-svuint16_t svlsl_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s8_x)))
-svint8_t svlsl_n_s8_x(svbool_t, svint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s32_x)))
-svint32_t svlsl_n_s32_x(svbool_t, svint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s64_x)))
-svint64_t svlsl_n_s64_x(svbool_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s16_x)))
-svint16_t svlsl_n_s16_x(svbool_t, svint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u8_z)))
-svuint8_t svlsl_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u32_z)))
-svuint32_t svlsl_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u64_z)))
-svuint64_t svlsl_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u16_z)))
-svuint16_t svlsl_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s8_z)))
-svint8_t svlsl_n_s8_z(svbool_t, svint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s32_z)))
-svint32_t svlsl_n_s32_z(svbool_t, svint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s64_z)))
-svint64_t svlsl_n_s64_z(svbool_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s16_z)))
-svint16_t svlsl_n_s16_z(svbool_t, svint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u8_m)))
-svuint8_t svlsl_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u32_m)))
-svuint32_t svlsl_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u64_m)))
-svuint64_t svlsl_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u16_m)))
-svuint16_t svlsl_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s8_m)))
-svint8_t svlsl_s8_m(svbool_t, svint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s32_m)))
-svint32_t svlsl_s32_m(svbool_t, svint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s64_m)))
-svint64_t svlsl_s64_m(svbool_t, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s16_m)))
-svint16_t svlsl_s16_m(svbool_t, svint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u8_x)))
-svuint8_t svlsl_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u32_x)))
-svuint32_t svlsl_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u64_x)))
-svuint64_t svlsl_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u16_x)))
-svuint16_t svlsl_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s8_x)))
-svint8_t svlsl_s8_x(svbool_t, svint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s32_x)))
-svint32_t svlsl_s32_x(svbool_t, svint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s64_x)))
-svint64_t svlsl_s64_x(svbool_t, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s16_x)))
-svint16_t svlsl_s16_x(svbool_t, svint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u8_z)))
-svuint8_t svlsl_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u32_z)))
-svuint32_t svlsl_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u64_z)))
-svuint64_t svlsl_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u16_z)))
-svuint16_t svlsl_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s8_z)))
-svint8_t svlsl_s8_z(svbool_t, svint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s32_z)))
-svint32_t svlsl_s32_z(svbool_t, svint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s64_z)))
-svint64_t svlsl_s64_z(svbool_t, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s16_z)))
-svint16_t svlsl_s16_z(svbool_t, svint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u8_m)))
-svuint8_t svlsl_wide_n_u8_m(svbool_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u32_m)))
-svuint32_t svlsl_wide_n_u32_m(svbool_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u16_m)))
-svuint16_t svlsl_wide_n_u16_m(svbool_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s8_m)))
-svint8_t svlsl_wide_n_s8_m(svbool_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s32_m)))
-svint32_t svlsl_wide_n_s32_m(svbool_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s16_m)))
-svint16_t svlsl_wide_n_s16_m(svbool_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u8_x)))
-svuint8_t svlsl_wide_n_u8_x(svbool_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u32_x)))
-svuint32_t svlsl_wide_n_u32_x(svbool_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u16_x)))
-svuint16_t svlsl_wide_n_u16_x(svbool_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s8_x)))
-svint8_t svlsl_wide_n_s8_x(svbool_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s32_x)))
-svint32_t svlsl_wide_n_s32_x(svbool_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s16_x)))
-svint16_t svlsl_wide_n_s16_x(svbool_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u8_z)))
-svuint8_t svlsl_wide_n_u8_z(svbool_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u32_z)))
-svuint32_t svlsl_wide_n_u32_z(svbool_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u16_z)))
-svuint16_t svlsl_wide_n_u16_z(svbool_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s8_z)))
-svint8_t svlsl_wide_n_s8_z(svbool_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s32_z)))
-svint32_t svlsl_wide_n_s32_z(svbool_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s16_z)))
-svint16_t svlsl_wide_n_s16_z(svbool_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u8_m)))
-svuint8_t svlsl_wide_u8_m(svbool_t, svuint8_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u32_m)))
-svuint32_t svlsl_wide_u32_m(svbool_t, svuint32_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u16_m)))
-svuint16_t svlsl_wide_u16_m(svbool_t, svuint16_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s8_m)))
-svint8_t svlsl_wide_s8_m(svbool_t, svint8_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s32_m)))
-svint32_t svlsl_wide_s32_m(svbool_t, svint32_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s16_m)))
-svint16_t svlsl_wide_s16_m(svbool_t, svint16_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u8_x)))
-svuint8_t svlsl_wide_u8_x(svbool_t, svuint8_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u32_x)))
-svuint32_t svlsl_wide_u32_x(svbool_t, svuint32_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u16_x)))
-svuint16_t svlsl_wide_u16_x(svbool_t, svuint16_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s8_x)))
-svint8_t svlsl_wide_s8_x(svbool_t, svint8_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s32_x)))
-svint32_t svlsl_wide_s32_x(svbool_t, svint32_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s16_x)))
-svint16_t svlsl_wide_s16_x(svbool_t, svint16_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u8_z)))
-svuint8_t svlsl_wide_u8_z(svbool_t, svuint8_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u32_z)))
-svuint32_t svlsl_wide_u32_z(svbool_t, svuint32_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u16_z)))
-svuint16_t svlsl_wide_u16_z(svbool_t, svuint16_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s8_z)))
-svint8_t svlsl_wide_s8_z(svbool_t, svint8_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s32_z)))
-svint32_t svlsl_wide_s32_z(svbool_t, svint32_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s16_z)))
-svint16_t svlsl_wide_s16_z(svbool_t, svint16_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u8_m)))
-svuint8_t svlsr_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u32_m)))
-svuint32_t svlsr_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u64_m)))
-svuint64_t svlsr_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u16_m)))
-svuint16_t svlsr_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u8_x)))
-svuint8_t svlsr_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u32_x)))
-svuint32_t svlsr_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u64_x)))
-svuint64_t svlsr_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u16_x)))
-svuint16_t svlsr_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u8_z)))
-svuint8_t svlsr_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u32_z)))
-svuint32_t svlsr_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u64_z)))
-svuint64_t svlsr_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u16_z)))
-svuint16_t svlsr_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u8_m)))
-svuint8_t svlsr_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u32_m)))
-svuint32_t svlsr_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u64_m)))
-svuint64_t svlsr_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u16_m)))
-svuint16_t svlsr_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u8_x)))
-svuint8_t svlsr_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u32_x)))
-svuint32_t svlsr_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u64_x)))
-svuint64_t svlsr_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u16_x)))
-svuint16_t svlsr_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u8_z)))
-svuint8_t svlsr_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u32_z)))
-svuint32_t svlsr_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u64_z)))
-svuint64_t svlsr_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u16_z)))
-svuint16_t svlsr_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u8_m)))
-svuint8_t svlsr_wide_n_u8_m(svbool_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u32_m)))
-svuint32_t svlsr_wide_n_u32_m(svbool_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u16_m)))
-svuint16_t svlsr_wide_n_u16_m(svbool_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u8_x)))
-svuint8_t svlsr_wide_n_u8_x(svbool_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u32_x)))
-svuint32_t svlsr_wide_n_u32_x(svbool_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u16_x)))
-svuint16_t svlsr_wide_n_u16_x(svbool_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u8_z)))
-svuint8_t svlsr_wide_n_u8_z(svbool_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u32_z)))
-svuint32_t svlsr_wide_n_u32_z(svbool_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u16_z)))
-svuint16_t svlsr_wide_n_u16_z(svbool_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u8_m)))
-svuint8_t svlsr_wide_u8_m(svbool_t, svuint8_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u32_m)))
-svuint32_t svlsr_wide_u32_m(svbool_t, svuint32_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u16_m)))
-svuint16_t svlsr_wide_u16_m(svbool_t, svuint16_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u8_x)))
-svuint8_t svlsr_wide_u8_x(svbool_t, svuint8_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u32_x)))
-svuint32_t svlsr_wide_u32_x(svbool_t, svuint32_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u16_x)))
-svuint16_t svlsr_wide_u16_x(svbool_t, svuint16_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u8_z)))
-svuint8_t svlsr_wide_u8_z(svbool_t, svuint8_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u32_z)))
-svuint32_t svlsr_wide_u32_z(svbool_t, svuint32_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u16_z)))
-svuint16_t svlsr_wide_u16_z(svbool_t, svuint16_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f64_m)))
-svfloat64_t svmad_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f32_m)))
-svfloat32_t svmad_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f16_m)))
-svfloat16_t svmad_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f64_x)))
-svfloat64_t svmad_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f32_x)))
-svfloat32_t svmad_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f16_x)))
-svfloat16_t svmad_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f64_z)))
-svfloat64_t svmad_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f32_z)))
-svfloat32_t svmad_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f16_z)))
-svfloat16_t svmad_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u8_m)))
-svuint8_t svmad_n_u8_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u32_m)))
-svuint32_t svmad_n_u32_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u64_m)))
-svuint64_t svmad_n_u64_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u16_m)))
-svuint16_t svmad_n_u16_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s8_m)))
-svint8_t svmad_n_s8_m(svbool_t, svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s32_m)))
-svint32_t svmad_n_s32_m(svbool_t, svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s64_m)))
-svint64_t svmad_n_s64_m(svbool_t, svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s16_m)))
-svint16_t svmad_n_s16_m(svbool_t, svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u8_x)))
-svuint8_t svmad_n_u8_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u32_x)))
-svuint32_t svmad_n_u32_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u64_x)))
-svuint64_t svmad_n_u64_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u16_x)))
-svuint16_t svmad_n_u16_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s8_x)))
-svint8_t svmad_n_s8_x(svbool_t, svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s32_x)))
-svint32_t svmad_n_s32_x(svbool_t, svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s64_x)))
-svint64_t svmad_n_s64_x(svbool_t, svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s16_x)))
-svint16_t svmad_n_s16_x(svbool_t, svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u8_z)))
-svuint8_t svmad_n_u8_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u32_z)))
-svuint32_t svmad_n_u32_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u64_z)))
-svuint64_t svmad_n_u64_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u16_z)))
-svuint16_t svmad_n_u16_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s8_z)))
-svint8_t svmad_n_s8_z(svbool_t, svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s32_z)))
-svint32_t svmad_n_s32_z(svbool_t, svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s64_z)))
-svint64_t svmad_n_s64_z(svbool_t, svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s16_z)))
-svint16_t svmad_n_s16_z(svbool_t, svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f64_m)))
-svfloat64_t svmad_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f32_m)))
-svfloat32_t svmad_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f16_m)))
-svfloat16_t svmad_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f64_x)))
-svfloat64_t svmad_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f32_x)))
-svfloat32_t svmad_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f16_x)))
-svfloat16_t svmad_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f64_z)))
-svfloat64_t svmad_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f32_z)))
-svfloat32_t svmad_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f16_z)))
-svfloat16_t svmad_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u8_m)))
-svuint8_t svmad_u8_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u32_m)))
-svuint32_t svmad_u32_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u64_m)))
-svuint64_t svmad_u64_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u16_m)))
-svuint16_t svmad_u16_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s8_m)))
-svint8_t svmad_s8_m(svbool_t, svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s32_m)))
-svint32_t svmad_s32_m(svbool_t, svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s64_m)))
-svint64_t svmad_s64_m(svbool_t, svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s16_m)))
-svint16_t svmad_s16_m(svbool_t, svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u8_x)))
-svuint8_t svmad_u8_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u32_x)))
-svuint32_t svmad_u32_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u64_x)))
-svuint64_t svmad_u64_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u16_x)))
-svuint16_t svmad_u16_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s8_x)))
-svint8_t svmad_s8_x(svbool_t, svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s32_x)))
-svint32_t svmad_s32_x(svbool_t, svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s64_x)))
-svint64_t svmad_s64_x(svbool_t, svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s16_x)))
-svint16_t svmad_s16_x(svbool_t, svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u8_z)))
-svuint8_t svmad_u8_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u32_z)))
-svuint32_t svmad_u32_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u64_z)))
-svuint64_t svmad_u64_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u16_z)))
-svuint16_t svmad_u16_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s8_z)))
-svint8_t svmad_s8_z(svbool_t, svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s32_z)))
-svint32_t svmad_s32_z(svbool_t, svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s64_z)))
-svint64_t svmad_s64_z(svbool_t, svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s16_z)))
-svint16_t svmad_s16_z(svbool_t, svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f64_m)))
-svfloat64_t svmax_n_f64_m(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f32_m)))
-svfloat32_t svmax_n_f32_m(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f16_m)))
-svfloat16_t svmax_n_f16_m(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f64_x)))
-svfloat64_t svmax_n_f64_x(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f32_x)))
-svfloat32_t svmax_n_f32_x(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f16_x)))
-svfloat16_t svmax_n_f16_x(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f64_z)))
-svfloat64_t svmax_n_f64_z(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f32_z)))
-svfloat32_t svmax_n_f32_z(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f16_z)))
-svfloat16_t svmax_n_f16_z(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s8_m)))
-svint8_t svmax_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s32_m)))
-svint32_t svmax_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s64_m)))
-svint64_t svmax_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s16_m)))
-svint16_t svmax_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s8_x)))
-svint8_t svmax_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s32_x)))
-svint32_t svmax_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s64_x)))
-svint64_t svmax_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s16_x)))
-svint16_t svmax_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s8_z)))
-svint8_t svmax_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s32_z)))
-svint32_t svmax_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s64_z)))
-svint64_t svmax_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s16_z)))
-svint16_t svmax_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u8_m)))
-svuint8_t svmax_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u32_m)))
-svuint32_t svmax_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u64_m)))
-svuint64_t svmax_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u16_m)))
-svuint16_t svmax_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u8_x)))
-svuint8_t svmax_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u32_x)))
-svuint32_t svmax_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u64_x)))
-svuint64_t svmax_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u16_x)))
-svuint16_t svmax_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u8_z)))
-svuint8_t svmax_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u32_z)))
-svuint32_t svmax_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u64_z)))
-svuint64_t svmax_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u16_z)))
-svuint16_t svmax_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_m)))
-svfloat64_t svmax_f64_m(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_m)))
-svfloat32_t svmax_f32_m(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_m)))
-svfloat16_t svmax_f16_m(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_x)))
-svfloat64_t svmax_f64_x(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_x)))
-svfloat32_t svmax_f32_x(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_x)))
-svfloat16_t svmax_f16_x(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_z)))
-svfloat64_t svmax_f64_z(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_z)))
-svfloat32_t svmax_f32_z(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_z)))
-svfloat16_t svmax_f16_z(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_m)))
-svint8_t svmax_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_m)))
-svint32_t svmax_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_m)))
-svint64_t svmax_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_m)))
-svint16_t svmax_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_x)))
-svint8_t svmax_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_x)))
-svint32_t svmax_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_x)))
-svint64_t svmax_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_x)))
-svint16_t svmax_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_z)))
-svint8_t svmax_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_z)))
-svint32_t svmax_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_z)))
-svint64_t svmax_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_z)))
-svint16_t svmax_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_m)))
-svuint8_t svmax_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_m)))
-svuint32_t svmax_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_m)))
-svuint64_t svmax_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_m)))
-svuint16_t svmax_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_x)))
-svuint8_t svmax_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_x)))
-svuint32_t svmax_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_x)))
-svuint64_t svmax_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_x)))
-svuint16_t svmax_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_z)))
-svuint8_t svmax_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_z)))
-svuint32_t svmax_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_z)))
-svuint64_t svmax_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_z)))
-svuint16_t svmax_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f64_m)))
-svfloat64_t svmaxnm_n_f64_m(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f32_m)))
-svfloat32_t svmaxnm_n_f32_m(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f16_m)))
-svfloat16_t svmaxnm_n_f16_m(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f64_x)))
-svfloat64_t svmaxnm_n_f64_x(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f32_x)))
-svfloat32_t svmaxnm_n_f32_x(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f16_x)))
-svfloat16_t svmaxnm_n_f16_x(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f64_z)))
-svfloat64_t svmaxnm_n_f64_z(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f32_z)))
-svfloat32_t svmaxnm_n_f32_z(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f16_z)))
-svfloat16_t svmaxnm_n_f16_z(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_m)))
-svfloat64_t svmaxnm_f64_m(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_m)))
-svfloat32_t svmaxnm_f32_m(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_m)))
-svfloat16_t svmaxnm_f16_m(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_x)))
-svfloat64_t svmaxnm_f64_x(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_x)))
-svfloat32_t svmaxnm_f32_x(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x)))
-svfloat16_t svmaxnm_f16_x(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_z)))
-svfloat64_t svmaxnm_f64_z(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_z)))
-svfloat32_t svmaxnm_f32_z(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_z)))
-svfloat16_t svmaxnm_f16_z(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmv_f64)))
-float64_t svmaxnmv_f64(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmv_f32)))
-float32_t svmaxnmv_f32(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmv_f16)))
-float16_t svmaxnmv_f16(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_f64)))
-float64_t svmaxv_f64(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_f32)))
-float32_t svmaxv_f32(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_f16)))
-float16_t svmaxv_f16(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s8)))
-int8_t svmaxv_s8(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s32)))
-int32_t svmaxv_s32(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s64)))
-int64_t svmaxv_s64(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s16)))
-int16_t svmaxv_s16(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u8)))
-uint8_t svmaxv_u8(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u32)))
-uint32_t svmaxv_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u64)))
-uint64_t svmaxv_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u16)))
-uint16_t svmaxv_u16(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f64_m)))
-svfloat64_t svmin_n_f64_m(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f32_m)))
-svfloat32_t svmin_n_f32_m(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f16_m)))
-svfloat16_t svmin_n_f16_m(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f64_x)))
-svfloat64_t svmin_n_f64_x(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f32_x)))
-svfloat32_t svmin_n_f32_x(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f16_x)))
-svfloat16_t svmin_n_f16_x(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f64_z)))
-svfloat64_t svmin_n_f64_z(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f32_z)))
-svfloat32_t svmin_n_f32_z(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f16_z)))
-svfloat16_t svmin_n_f16_z(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s8_m)))
-svint8_t svmin_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s32_m)))
-svint32_t svmin_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s64_m)))
-svint64_t svmin_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s16_m)))
-svint16_t svmin_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s8_x)))
-svint8_t svmin_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s32_x)))
-svint32_t svmin_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s64_x)))
-svint64_t svmin_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s16_x)))
-svint16_t svmin_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s8_z)))
-svint8_t svmin_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s32_z)))
-svint32_t svmin_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s64_z)))
-svint64_t svmin_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s16_z)))
-svint16_t svmin_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u8_m)))
-svuint8_t svmin_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u32_m)))
-svuint32_t svmin_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u64_m)))
-svuint64_t svmin_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u16_m)))
-svuint16_t svmin_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u8_x)))
-svuint8_t svmin_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u32_x)))
-svuint32_t svmin_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u64_x)))
-svuint64_t svmin_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u16_x)))
-svuint16_t svmin_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u8_z)))
-svuint8_t svmin_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u32_z)))
-svuint32_t svmin_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u64_z)))
-svuint64_t svmin_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u16_z)))
-svuint16_t svmin_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_m)))
-svfloat64_t svmin_f64_m(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_m)))
-svfloat32_t svmin_f32_m(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_m)))
-svfloat16_t svmin_f16_m(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_x)))
-svfloat64_t svmin_f64_x(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_x)))
-svfloat32_t svmin_f32_x(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_x)))
-svfloat16_t svmin_f16_x(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_z)))
-svfloat64_t svmin_f64_z(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_z)))
-svfloat32_t svmin_f32_z(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_z)))
-svfloat16_t svmin_f16_z(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_m)))
-svint8_t svmin_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_m)))
-svint32_t svmin_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_m)))
-svint64_t svmin_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_m)))
-svint16_t svmin_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_x)))
-svint8_t svmin_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_x)))
-svint32_t svmin_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_x)))
-svint64_t svmin_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_x)))
-svint16_t svmin_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_z)))
-svint8_t svmin_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_z)))
-svint32_t svmin_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_z)))
-svint64_t svmin_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_z)))
-svint16_t svmin_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_m)))
-svuint8_t svmin_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_m)))
-svuint32_t svmin_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_m)))
-svuint64_t svmin_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_m)))
-svuint16_t svmin_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_x)))
-svuint8_t svmin_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_x)))
-svuint32_t svmin_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_x)))
-svuint64_t svmin_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_x)))
-svuint16_t svmin_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_z)))
-svuint8_t svmin_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_z)))
-svuint32_t svmin_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_z)))
-svuint64_t svmin_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_z)))
-svuint16_t svmin_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f64_m)))
-svfloat64_t svminnm_n_f64_m(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f32_m)))
-svfloat32_t svminnm_n_f32_m(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f16_m)))
-svfloat16_t svminnm_n_f16_m(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f64_x)))
-svfloat64_t svminnm_n_f64_x(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f32_x)))
-svfloat32_t svminnm_n_f32_x(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f16_x)))
-svfloat16_t svminnm_n_f16_x(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f64_z)))
-svfloat64_t svminnm_n_f64_z(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f32_z)))
-svfloat32_t svminnm_n_f32_z(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f16_z)))
-svfloat16_t svminnm_n_f16_z(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_m)))
-svfloat64_t svminnm_f64_m(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_m)))
-svfloat32_t svminnm_f32_m(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_m)))
-svfloat16_t svminnm_f16_m(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_x)))
-svfloat64_t svminnm_f64_x(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_x)))
-svfloat32_t svminnm_f32_x(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_x)))
-svfloat16_t svminnm_f16_x(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_z)))
-svfloat64_t svminnm_f64_z(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_z)))
-svfloat32_t svminnm_f32_z(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_z)))
-svfloat16_t svminnm_f16_z(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmv_f64)))
-float64_t svminnmv_f64(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmv_f32)))
-float32_t svminnmv_f32(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmv_f16)))
-float16_t svminnmv_f16(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_f64)))
-float64_t svminv_f64(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_f32)))
-float32_t svminv_f32(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_f16)))
-float16_t svminv_f16(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s8)))
-int8_t svminv_s8(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s32)))
-int32_t svminv_s32(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s64)))
-int64_t svminv_s64(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s16)))
-int16_t svminv_s16(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u8)))
-uint8_t svminv_u8(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u32)))
-uint32_t svminv_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u64)))
-uint64_t svminv_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u16)))
-uint16_t svminv_u16(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f64_m)))
-svfloat64_t svmla_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f32_m)))
-svfloat32_t svmla_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f16_m)))
-svfloat16_t svmla_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f64_x)))
-svfloat64_t svmla_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f32_x)))
-svfloat32_t svmla_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f16_x)))
-svfloat16_t svmla_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f64_z)))
-svfloat64_t svmla_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f32_z)))
-svfloat32_t svmla_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f16_z)))
-svfloat16_t svmla_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u8_m)))
-svuint8_t svmla_n_u8_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u32_m)))
-svuint32_t svmla_n_u32_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u64_m)))
-svuint64_t svmla_n_u64_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u16_m)))
-svuint16_t svmla_n_u16_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s8_m)))
-svint8_t svmla_n_s8_m(svbool_t, svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s32_m)))
-svint32_t svmla_n_s32_m(svbool_t, svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s64_m)))
-svint64_t svmla_n_s64_m(svbool_t, svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s16_m)))
-svint16_t svmla_n_s16_m(svbool_t, svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u8_x)))
-svuint8_t svmla_n_u8_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u32_x)))
-svuint32_t svmla_n_u32_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u64_x)))
-svuint64_t svmla_n_u64_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u16_x)))
-svuint16_t svmla_n_u16_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s8_x)))
-svint8_t svmla_n_s8_x(svbool_t, svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s32_x)))
-svint32_t svmla_n_s32_x(svbool_t, svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s64_x)))
-svint64_t svmla_n_s64_x(svbool_t, svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s16_x)))
-svint16_t svmla_n_s16_x(svbool_t, svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u8_z)))
-svuint8_t svmla_n_u8_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u32_z)))
-svuint32_t svmla_n_u32_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u64_z)))
-svuint64_t svmla_n_u64_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u16_z)))
-svuint16_t svmla_n_u16_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s8_z)))
-svint8_t svmla_n_s8_z(svbool_t, svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s32_z)))
-svint32_t svmla_n_s32_z(svbool_t, svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s64_z)))
-svint64_t svmla_n_s64_z(svbool_t, svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s16_z)))
-svint16_t svmla_n_s16_z(svbool_t, svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f64_m)))
-svfloat64_t svmla_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f32_m)))
-svfloat32_t svmla_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f16_m)))
-svfloat16_t svmla_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f64_x)))
-svfloat64_t svmla_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f32_x)))
-svfloat32_t svmla_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f16_x)))
-svfloat16_t svmla_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f64_z)))
-svfloat64_t svmla_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f32_z)))
-svfloat32_t svmla_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f16_z)))
-svfloat16_t svmla_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u8_m)))
-svuint8_t svmla_u8_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u32_m)))
-svuint32_t svmla_u32_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u64_m)))
-svuint64_t svmla_u64_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u16_m)))
-svuint16_t svmla_u16_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s8_m)))
-svint8_t svmla_s8_m(svbool_t, svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s32_m)))
-svint32_t svmla_s32_m(svbool_t, svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s64_m)))
-svint64_t svmla_s64_m(svbool_t, svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s16_m)))
-svint16_t svmla_s16_m(svbool_t, svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u8_x)))
-svuint8_t svmla_u8_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u32_x)))
-svuint32_t svmla_u32_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u64_x)))
-svuint64_t svmla_u64_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u16_x)))
-svuint16_t svmla_u16_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s8_x)))
-svint8_t svmla_s8_x(svbool_t, svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s32_x)))
-svint32_t svmla_s32_x(svbool_t, svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s64_x)))
-svint64_t svmla_s64_x(svbool_t, svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s16_x)))
-svint16_t svmla_s16_x(svbool_t, svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u8_z)))
-svuint8_t svmla_u8_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u32_z)))
-svuint32_t svmla_u32_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u64_z)))
-svuint64_t svmla_u64_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u16_z)))
-svuint16_t svmla_u16_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s8_z)))
-svint8_t svmla_s8_z(svbool_t, svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s32_z)))
-svint32_t svmla_s32_z(svbool_t, svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s64_z)))
-svint64_t svmla_s64_z(svbool_t, svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s16_z)))
-svint16_t svmla_s16_z(svbool_t, svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_f64)))
-svfloat64_t svmla_lane_f64(svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_f32)))
-svfloat32_t svmla_lane_f32(svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_f16)))
-svfloat16_t svmla_lane_f16(svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f64_m)))
-svfloat64_t svmls_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f32_m)))
-svfloat32_t svmls_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f16_m)))
-svfloat16_t svmls_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f64_x)))
-svfloat64_t svmls_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f32_x)))
-svfloat32_t svmls_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f16_x)))
-svfloat16_t svmls_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f64_z)))
-svfloat64_t svmls_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f32_z)))
-svfloat32_t svmls_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f16_z)))
-svfloat16_t svmls_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u8_m)))
-svuint8_t svmls_n_u8_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u32_m)))
-svuint32_t svmls_n_u32_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u64_m)))
-svuint64_t svmls_n_u64_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u16_m)))
-svuint16_t svmls_n_u16_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s8_m)))
-svint8_t svmls_n_s8_m(svbool_t, svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s32_m)))
-svint32_t svmls_n_s32_m(svbool_t, svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s64_m)))
-svint64_t svmls_n_s64_m(svbool_t, svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s16_m)))
-svint16_t svmls_n_s16_m(svbool_t, svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u8_x)))
-svuint8_t svmls_n_u8_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u32_x)))
-svuint32_t svmls_n_u32_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u64_x)))
-svuint64_t svmls_n_u64_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u16_x)))
-svuint16_t svmls_n_u16_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s8_x)))
-svint8_t svmls_n_s8_x(svbool_t, svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s32_x)))
-svint32_t svmls_n_s32_x(svbool_t, svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s64_x)))
-svint64_t svmls_n_s64_x(svbool_t, svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s16_x)))
-svint16_t svmls_n_s16_x(svbool_t, svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u8_z)))
-svuint8_t svmls_n_u8_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u32_z)))
-svuint32_t svmls_n_u32_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u64_z)))
-svuint64_t svmls_n_u64_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u16_z)))
-svuint16_t svmls_n_u16_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s8_z)))
-svint8_t svmls_n_s8_z(svbool_t, svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s32_z)))
-svint32_t svmls_n_s32_z(svbool_t, svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s64_z)))
-svint64_t svmls_n_s64_z(svbool_t, svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s16_z)))
-svint16_t svmls_n_s16_z(svbool_t, svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f64_m)))
-svfloat64_t svmls_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f32_m)))
-svfloat32_t svmls_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f16_m)))
-svfloat16_t svmls_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f64_x)))
-svfloat64_t svmls_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f32_x)))
-svfloat32_t svmls_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f16_x)))
-svfloat16_t svmls_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f64_z)))
-svfloat64_t svmls_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f32_z)))
-svfloat32_t svmls_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f16_z)))
-svfloat16_t svmls_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u8_m)))
-svuint8_t svmls_u8_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u32_m)))
-svuint32_t svmls_u32_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u64_m)))
-svuint64_t svmls_u64_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u16_m)))
-svuint16_t svmls_u16_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s8_m)))
-svint8_t svmls_s8_m(svbool_t, svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s32_m)))
-svint32_t svmls_s32_m(svbool_t, svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s64_m)))
-svint64_t svmls_s64_m(svbool_t, svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s16_m)))
-svint16_t svmls_s16_m(svbool_t, svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u8_x)))
-svuint8_t svmls_u8_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u32_x)))
-svuint32_t svmls_u32_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u64_x)))
-svuint64_t svmls_u64_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u16_x)))
-svuint16_t svmls_u16_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s8_x)))
-svint8_t svmls_s8_x(svbool_t, svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s32_x)))
-svint32_t svmls_s32_x(svbool_t, svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s64_x)))
-svint64_t svmls_s64_x(svbool_t, svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s16_x)))
-svint16_t svmls_s16_x(svbool_t, svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u8_z)))
-svuint8_t svmls_u8_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u32_z)))
-svuint32_t svmls_u32_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u64_z)))
-svuint64_t svmls_u64_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u16_z)))
-svuint16_t svmls_u16_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s8_z)))
-svint8_t svmls_s8_z(svbool_t, svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s32_z)))
-svint32_t svmls_s32_z(svbool_t, svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s64_z)))
-svint64_t svmls_s64_z(svbool_t, svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s16_z)))
-svint16_t svmls_s16_z(svbool_t, svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_f64)))
-svfloat64_t svmls_lane_f64(svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_f32)))
-svfloat32_t svmls_lane_f32(svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_f16)))
-svfloat16_t svmls_lane_f16(svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmov_b_z)))
-svbool_t svmov_b_z(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f64_m)))
-svfloat64_t svmsb_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f32_m)))
-svfloat32_t svmsb_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f16_m)))
-svfloat16_t svmsb_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f64_x)))
-svfloat64_t svmsb_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f32_x)))
-svfloat32_t svmsb_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f16_x)))
-svfloat16_t svmsb_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f64_z)))
-svfloat64_t svmsb_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f32_z)))
-svfloat32_t svmsb_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f16_z)))
-svfloat16_t svmsb_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u8_m)))
-svuint8_t svmsb_n_u8_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u32_m)))
-svuint32_t svmsb_n_u32_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u64_m)))
-svuint64_t svmsb_n_u64_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u16_m)))
-svuint16_t svmsb_n_u16_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s8_m)))
-svint8_t svmsb_n_s8_m(svbool_t, svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s32_m)))
-svint32_t svmsb_n_s32_m(svbool_t, svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s64_m)))
-svint64_t svmsb_n_s64_m(svbool_t, svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s16_m)))
-svint16_t svmsb_n_s16_m(svbool_t, svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u8_x)))
-svuint8_t svmsb_n_u8_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u32_x)))
-svuint32_t svmsb_n_u32_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u64_x)))
-svuint64_t svmsb_n_u64_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u16_x)))
-svuint16_t svmsb_n_u16_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s8_x)))
-svint8_t svmsb_n_s8_x(svbool_t, svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s32_x)))
-svint32_t svmsb_n_s32_x(svbool_t, svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s64_x)))
-svint64_t svmsb_n_s64_x(svbool_t, svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s16_x)))
-svint16_t svmsb_n_s16_x(svbool_t, svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u8_z)))
-svuint8_t svmsb_n_u8_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u32_z)))
-svuint32_t svmsb_n_u32_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u64_z)))
-svuint64_t svmsb_n_u64_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u16_z)))
-svuint16_t svmsb_n_u16_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s8_z)))
-svint8_t svmsb_n_s8_z(svbool_t, svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s32_z)))
-svint32_t svmsb_n_s32_z(svbool_t, svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s64_z)))
-svint64_t svmsb_n_s64_z(svbool_t, svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s16_z)))
-svint16_t svmsb_n_s16_z(svbool_t, svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f64_m)))
-svfloat64_t svmsb_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f32_m)))
-svfloat32_t svmsb_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f16_m)))
-svfloat16_t svmsb_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f64_x)))
-svfloat64_t svmsb_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f32_x)))
-svfloat32_t svmsb_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f16_x)))
-svfloat16_t svmsb_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f64_z)))
-svfloat64_t svmsb_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f32_z)))
-svfloat32_t svmsb_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f16_z)))
-svfloat16_t svmsb_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u8_m)))
-svuint8_t svmsb_u8_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u32_m)))
-svuint32_t svmsb_u32_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u64_m)))
-svuint64_t svmsb_u64_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u16_m)))
-svuint16_t svmsb_u16_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s8_m)))
-svint8_t svmsb_s8_m(svbool_t, svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s32_m)))
-svint32_t svmsb_s32_m(svbool_t, svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s64_m)))
-svint64_t svmsb_s64_m(svbool_t, svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s16_m)))
-svint16_t svmsb_s16_m(svbool_t, svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u8_x)))
-svuint8_t svmsb_u8_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u32_x)))
-svuint32_t svmsb_u32_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u64_x)))
-svuint64_t svmsb_u64_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u16_x)))
-svuint16_t svmsb_u16_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s8_x)))
-svint8_t svmsb_s8_x(svbool_t, svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s32_x)))
-svint32_t svmsb_s32_x(svbool_t, svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s64_x)))
-svint64_t svmsb_s64_x(svbool_t, svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s16_x)))
-svint16_t svmsb_s16_x(svbool_t, svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u8_z)))
-svuint8_t svmsb_u8_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u32_z)))
-svuint32_t svmsb_u32_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u64_z)))
-svuint64_t svmsb_u64_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u16_z)))
-svuint16_t svmsb_u16_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s8_z)))
-svint8_t svmsb_s8_z(svbool_t, svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s32_z)))
-svint32_t svmsb_s32_z(svbool_t, svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s64_z)))
-svint64_t svmsb_s64_z(svbool_t, svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s16_z)))
-svint16_t svmsb_s16_z(svbool_t, svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f64_m)))
-svfloat64_t svmul_n_f64_m(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f32_m)))
-svfloat32_t svmul_n_f32_m(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f16_m)))
-svfloat16_t svmul_n_f16_m(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f64_x)))
-svfloat64_t svmul_n_f64_x(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f32_x)))
-svfloat32_t svmul_n_f32_x(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f16_x)))
-svfloat16_t svmul_n_f16_x(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f64_z)))
-svfloat64_t svmul_n_f64_z(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f32_z)))
-svfloat32_t svmul_n_f32_z(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f16_z)))
-svfloat16_t svmul_n_f16_z(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u8_m)))
-svuint8_t svmul_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u32_m)))
-svuint32_t svmul_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u64_m)))
-svuint64_t svmul_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u16_m)))
-svuint16_t svmul_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s8_m)))
-svint8_t svmul_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s32_m)))
-svint32_t svmul_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s64_m)))
-svint64_t svmul_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s16_m)))
-svint16_t svmul_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u8_x)))
-svuint8_t svmul_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u32_x)))
-svuint32_t svmul_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u64_x)))
-svuint64_t svmul_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u16_x)))
-svuint16_t svmul_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s8_x)))
-svint8_t svmul_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s32_x)))
-svint32_t svmul_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s64_x)))
-svint64_t svmul_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s16_x)))
-svint16_t svmul_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u8_z)))
-svuint8_t svmul_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u32_z)))
-svuint32_t svmul_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u64_z)))
-svuint64_t svmul_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u16_z)))
-svuint16_t svmul_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s8_z)))
-svint8_t svmul_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s32_z)))
-svint32_t svmul_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s64_z)))
-svint64_t svmul_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s16_z)))
-svint16_t svmul_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f64_m)))
-svfloat64_t svmul_f64_m(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f32_m)))
-svfloat32_t svmul_f32_m(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f16_m)))
-svfloat16_t svmul_f16_m(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f64_x)))
-svfloat64_t svmul_f64_x(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f32_x)))
-svfloat32_t svmul_f32_x(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f16_x)))
-svfloat16_t svmul_f16_x(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f64_z)))
-svfloat64_t svmul_f64_z(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f32_z)))
-svfloat32_t svmul_f32_z(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f16_z)))
-svfloat16_t svmul_f16_z(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u8_m)))
-svuint8_t svmul_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u32_m)))
-svuint32_t svmul_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u64_m)))
-svuint64_t svmul_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u16_m)))
-svuint16_t svmul_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s8_m)))
-svint8_t svmul_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s32_m)))
-svint32_t svmul_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s64_m)))
-svint64_t svmul_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s16_m)))
-svint16_t svmul_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u8_x)))
-svuint8_t svmul_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u32_x)))
-svuint32_t svmul_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u64_x)))
-svuint64_t svmul_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u16_x)))
-svuint16_t svmul_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s8_x)))
-svint8_t svmul_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s32_x)))
-svint32_t svmul_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s64_x)))
-svint64_t svmul_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s16_x)))
-svint16_t svmul_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u8_z)))
-svuint8_t svmul_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u32_z)))
-svuint32_t svmul_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u64_z)))
-svuint64_t svmul_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u16_z)))
-svuint16_t svmul_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s8_z)))
-svint8_t svmul_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s32_z)))
-svint32_t svmul_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s64_z)))
-svint64_t svmul_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s16_z)))
-svint16_t svmul_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_f64)))
-svfloat64_t svmul_lane_f64(svfloat64_t, svfloat64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_f32)))
-svfloat32_t svmul_lane_f32(svfloat32_t, svfloat32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_f16)))
-svfloat16_t svmul_lane_f16(svfloat16_t, svfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s8_m)))
-svint8_t svmulh_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s32_m)))
-svint32_t svmulh_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s64_m)))
-svint64_t svmulh_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s16_m)))
-svint16_t svmulh_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s8_x)))
-svint8_t svmulh_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s32_x)))
-svint32_t svmulh_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s64_x)))
-svint64_t svmulh_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s16_x)))
-svint16_t svmulh_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s8_z)))
-svint8_t svmulh_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s32_z)))
-svint32_t svmulh_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s64_z)))
-svint64_t svmulh_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s16_z)))
-svint16_t svmulh_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u8_m)))
-svuint8_t svmulh_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u32_m)))
-svuint32_t svmulh_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u64_m)))
-svuint64_t svmulh_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u16_m)))
-svuint16_t svmulh_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u8_x)))
-svuint8_t svmulh_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u32_x)))
-svuint32_t svmulh_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u64_x)))
-svuint64_t svmulh_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u16_x)))
-svuint16_t svmulh_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u8_z)))
-svuint8_t svmulh_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u32_z)))
-svuint32_t svmulh_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u64_z)))
-svuint64_t svmulh_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u16_z)))
-svuint16_t svmulh_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s8_m)))
-svint8_t svmulh_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s32_m)))
-svint32_t svmulh_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s64_m)))
-svint64_t svmulh_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s16_m)))
-svint16_t svmulh_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s8_x)))
-svint8_t svmulh_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s32_x)))
-svint32_t svmulh_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s64_x)))
-svint64_t svmulh_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s16_x)))
-svint16_t svmulh_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s8_z)))
-svint8_t svmulh_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s32_z)))
-svint32_t svmulh_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s64_z)))
-svint64_t svmulh_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s16_z)))
-svint16_t svmulh_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u8_m)))
-svuint8_t svmulh_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u32_m)))
-svuint32_t svmulh_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u64_m)))
-svuint64_t svmulh_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u16_m)))
-svuint16_t svmulh_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u8_x)))
-svuint8_t svmulh_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u32_x)))
-svuint32_t svmulh_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u64_x)))
-svuint64_t svmulh_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u16_x)))
-svuint16_t svmulh_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u8_z)))
-svuint8_t svmulh_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u32_z)))
-svuint32_t svmulh_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u64_z)))
-svuint64_t svmulh_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u16_z)))
-svuint16_t svmulh_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f64_m)))
-svfloat64_t svmulx_n_f64_m(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f32_m)))
-svfloat32_t svmulx_n_f32_m(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f16_m)))
-svfloat16_t svmulx_n_f16_m(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f64_x)))
-svfloat64_t svmulx_n_f64_x(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f32_x)))
-svfloat32_t svmulx_n_f32_x(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f16_x)))
-svfloat16_t svmulx_n_f16_x(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f64_z)))
-svfloat64_t svmulx_n_f64_z(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f32_z)))
-svfloat32_t svmulx_n_f32_z(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f16_z)))
-svfloat16_t svmulx_n_f16_z(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f64_m)))
-svfloat64_t svmulx_f64_m(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f32_m)))
-svfloat32_t svmulx_f32_m(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f16_m)))
-svfloat16_t svmulx_f16_m(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f64_x)))
-svfloat64_t svmulx_f64_x(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f32_x)))
-svfloat32_t svmulx_f32_x(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f16_x)))
-svfloat16_t svmulx_f16_x(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f64_z)))
-svfloat64_t svmulx_f64_z(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f32_z)))
-svfloat32_t svmulx_f32_z(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f16_z)))
-svfloat16_t svmulx_f16_z(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnand_b_z)))
-svbool_t svnand_b_z(svbool_t, svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f64_m)))
-svfloat64_t svneg_f64_m(svfloat64_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f32_m)))
-svfloat32_t svneg_f32_m(svfloat32_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f16_m)))
-svfloat16_t svneg_f16_m(svfloat16_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f64_x)))
-svfloat64_t svneg_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f32_x)))
-svfloat32_t svneg_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f16_x)))
-svfloat16_t svneg_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f64_z)))
-svfloat64_t svneg_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f32_z)))
-svfloat32_t svneg_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f16_z)))
-svfloat16_t svneg_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s8_m)))
-svint8_t svneg_s8_m(svint8_t, svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s32_m)))
-svint32_t svneg_s32_m(svint32_t, svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s64_m)))
-svint64_t svneg_s64_m(svint64_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s16_m)))
-svint16_t svneg_s16_m(svint16_t, svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s8_x)))
-svint8_t svneg_s8_x(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s32_x)))
-svint32_t svneg_s32_x(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s64_x)))
-svint64_t svneg_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s16_x)))
-svint16_t svneg_s16_x(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s8_z)))
-svint8_t svneg_s8_z(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s32_z)))
-svint32_t svneg_s32_z(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s64_z)))
-svint64_t svneg_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s16_z)))
-svint16_t svneg_s16_z(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f64_m)))
-svfloat64_t svnmad_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f32_m)))
-svfloat32_t svnmad_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f16_m)))
-svfloat16_t svnmad_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f64_x)))
-svfloat64_t svnmad_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f32_x)))
-svfloat32_t svnmad_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f16_x)))
-svfloat16_t svnmad_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f64_z)))
-svfloat64_t svnmad_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f32_z)))
-svfloat32_t svnmad_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f16_z)))
-svfloat16_t svnmad_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f64_m)))
-svfloat64_t svnmad_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f32_m)))
-svfloat32_t svnmad_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f16_m)))
-svfloat16_t svnmad_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f64_x)))
-svfloat64_t svnmad_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f32_x)))
-svfloat32_t svnmad_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f16_x)))
-svfloat16_t svnmad_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f64_z)))
-svfloat64_t svnmad_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f32_z)))
-svfloat32_t svnmad_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f16_z)))
-svfloat16_t svnmad_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f64_m)))
-svfloat64_t svnmla_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f32_m)))
-svfloat32_t svnmla_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f16_m)))
-svfloat16_t svnmla_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f64_x)))
-svfloat64_t svnmla_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f32_x)))
-svfloat32_t svnmla_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f16_x)))
-svfloat16_t svnmla_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f64_z)))
-svfloat64_t svnmla_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f32_z)))
-svfloat32_t svnmla_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f16_z)))
-svfloat16_t svnmla_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f64_m)))
-svfloat64_t svnmla_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f32_m)))
-svfloat32_t svnmla_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f16_m)))
-svfloat16_t svnmla_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f64_x)))
-svfloat64_t svnmla_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f32_x)))
-svfloat32_t svnmla_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f16_x)))
-svfloat16_t svnmla_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f64_z)))
-svfloat64_t svnmla_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f32_z)))
-svfloat32_t svnmla_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f16_z)))
-svfloat16_t svnmla_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f64_m)))
-svfloat64_t svnmls_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f32_m)))
-svfloat32_t svnmls_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f16_m)))
-svfloat16_t svnmls_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f64_x)))
-svfloat64_t svnmls_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f32_x)))
-svfloat32_t svnmls_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f16_x)))
-svfloat16_t svnmls_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f64_z)))
-svfloat64_t svnmls_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f32_z)))
-svfloat32_t svnmls_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f16_z)))
-svfloat16_t svnmls_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f64_m)))
-svfloat64_t svnmls_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f32_m)))
-svfloat32_t svnmls_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f16_m)))
-svfloat16_t svnmls_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f64_x)))
-svfloat64_t svnmls_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f32_x)))
-svfloat32_t svnmls_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f16_x)))
-svfloat16_t svnmls_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f64_z)))
-svfloat64_t svnmls_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f32_z)))
-svfloat32_t svnmls_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f16_z)))
-svfloat16_t svnmls_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f64_m)))
-svfloat64_t svnmsb_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f32_m)))
-svfloat32_t svnmsb_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f16_m)))
-svfloat16_t svnmsb_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f64_x)))
-svfloat64_t svnmsb_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f32_x)))
-svfloat32_t svnmsb_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f16_x)))
-svfloat16_t svnmsb_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f64_z)))
-svfloat64_t svnmsb_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f32_z)))
-svfloat32_t svnmsb_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f16_z)))
-svfloat16_t svnmsb_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f64_m)))
-svfloat64_t svnmsb_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f32_m)))
-svfloat32_t svnmsb_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f16_m)))
-svfloat16_t svnmsb_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f64_x)))
-svfloat64_t svnmsb_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f32_x)))
-svfloat32_t svnmsb_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f16_x)))
-svfloat16_t svnmsb_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f64_z)))
-svfloat64_t svnmsb_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f32_z)))
-svfloat32_t svnmsb_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f16_z)))
-svfloat16_t svnmsb_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnor_b_z)))
-svbool_t svnor_b_z(svbool_t, svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_b_z)))
-svbool_t svnot_b_z(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u8_m)))
-svuint8_t svnot_u8_m(svuint8_t, svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u32_m)))
-svuint32_t svnot_u32_m(svuint32_t, svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u64_m)))
-svuint64_t svnot_u64_m(svuint64_t, svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u16_m)))
-svuint16_t svnot_u16_m(svuint16_t, svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s8_m)))
-svint8_t svnot_s8_m(svint8_t, svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s32_m)))
-svint32_t svnot_s32_m(svint32_t, svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s64_m)))
-svint64_t svnot_s64_m(svint64_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s16_m)))
-svint16_t svnot_s16_m(svint16_t, svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u8_x)))
-svuint8_t svnot_u8_x(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u32_x)))
-svuint32_t svnot_u32_x(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u64_x)))
-svuint64_t svnot_u64_x(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u16_x)))
-svuint16_t svnot_u16_x(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s8_x)))
-svint8_t svnot_s8_x(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s32_x)))
-svint32_t svnot_s32_x(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s64_x)))
-svint64_t svnot_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s16_x)))
-svint16_t svnot_s16_x(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u8_z)))
-svuint8_t svnot_u8_z(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u32_z)))
-svuint32_t svnot_u32_z(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u64_z)))
-svuint64_t svnot_u64_z(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u16_z)))
-svuint16_t svnot_u16_z(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s8_z)))
-svint8_t svnot_s8_z(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s32_z)))
-svint32_t svnot_s32_z(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s64_z)))
-svint64_t svnot_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s16_z)))
-svint16_t svnot_s16_z(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorn_b_z)))
-svbool_t svorn_b_z(svbool_t, svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_b_z)))
-svbool_t svorr_b_z(svbool_t, svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u8_m)))
-svuint8_t svorr_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u32_m)))
-svuint32_t svorr_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u64_m)))
-svuint64_t svorr_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u16_m)))
-svuint16_t svorr_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s8_m)))
-svint8_t svorr_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s32_m)))
-svint32_t svorr_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s64_m)))
-svint64_t svorr_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s16_m)))
-svint16_t svorr_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u8_x)))
-svuint8_t svorr_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u32_x)))
-svuint32_t svorr_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u64_x)))
-svuint64_t svorr_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u16_x)))
-svuint16_t svorr_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s8_x)))
-svint8_t svorr_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s32_x)))
-svint32_t svorr_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s64_x)))
-svint64_t svorr_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s16_x)))
-svint16_t svorr_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u8_z)))
-svuint8_t svorr_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u32_z)))
-svuint32_t svorr_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u64_z)))
-svuint64_t svorr_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u16_z)))
-svuint16_t svorr_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s8_z)))
-svint8_t svorr_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s32_z)))
-svint32_t svorr_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s64_z)))
-svint64_t svorr_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s16_z)))
-svint16_t svorr_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u8_m)))
-svuint8_t svorr_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u32_m)))
-svuint32_t svorr_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u64_m)))
-svuint64_t svorr_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u16_m)))
-svuint16_t svorr_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s8_m)))
-svint8_t svorr_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s32_m)))
-svint32_t svorr_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s64_m)))
-svint64_t svorr_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s16_m)))
-svint16_t svorr_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u8_x)))
-svuint8_t svorr_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u32_x)))
-svuint32_t svorr_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u64_x)))
-svuint64_t svorr_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u16_x)))
-svuint16_t svorr_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s8_x)))
-svint8_t svorr_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s32_x)))
-svint32_t svorr_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s64_x)))
-svint64_t svorr_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s16_x)))
-svint16_t svorr_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u8_z)))
-svuint8_t svorr_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u32_z)))
-svuint32_t svorr_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u64_z)))
-svuint64_t svorr_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u16_z)))
-svuint16_t svorr_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s8_z)))
-svint8_t svorr_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s32_z)))
-svint32_t svorr_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s64_z)))
-svint64_t svorr_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s16_z)))
-svint16_t svorr_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u8)))
-uint8_t svorv_u8(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u32)))
-uint32_t svorv_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u64)))
-uint64_t svorv_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u16)))
-uint16_t svorv_u16(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s8)))
-int8_t svorv_s8(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s32)))
-int32_t svorv_s32(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s64)))
-int64_t svorv_s64(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s16)))
-int16_t svorv_s16(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpfalse_b)))
-svbool_t svpfalse_b(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpfirst_b)))
-svbool_t svpfirst_b(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpnext_b8)))
-svbool_t svpnext_b8(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpnext_b32)))
-svbool_t svpnext_b32(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpnext_b64)))
-svbool_t svpnext_b64(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpnext_b16)))
-svbool_t svpnext_b16(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb)))
-void svprfb(svbool_t, void const *, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u32base)))
-void svprfb_gather_u32base(svbool_t, svuint32_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u64base)))
-void svprfb_gather_u64base(svbool_t, svuint64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u32base_offset)))
-void svprfb_gather_u32base_offset(svbool_t, svuint32_t, int64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u64base_offset)))
-void svprfb_gather_u64base_offset(svbool_t, svuint64_t, int64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_s32offset)))
-void svprfb_gather_s32offset(svbool_t, void const *, svint32_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u32offset)))
-void svprfb_gather_u32offset(svbool_t, void const *, svuint32_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_s64offset)))
-void svprfb_gather_s64offset(svbool_t, void const *, svint64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u64offset)))
-void svprfb_gather_u64offset(svbool_t, void const *, svuint64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_vnum)))
-void svprfb_vnum(svbool_t, void const *, int64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd)))
-void svprfd(svbool_t, void const *, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u32base)))
-void svprfd_gather_u32base(svbool_t, svuint32_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u64base)))
-void svprfd_gather_u64base(svbool_t, svuint64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u32base_index)))
-void svprfd_gather_u32base_index(svbool_t, svuint32_t, int64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u64base_index)))
-void svprfd_gather_u64base_index(svbool_t, svuint64_t, int64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_s32index)))
-void svprfd_gather_s32index(svbool_t, void const *, svint32_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u32index)))
-void svprfd_gather_u32index(svbool_t, void const *, svuint32_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_s64index)))
-void svprfd_gather_s64index(svbool_t, void const *, svint64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u64index)))
-void svprfd_gather_u64index(svbool_t, void const *, svuint64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_vnum)))
-void svprfd_vnum(svbool_t, void const *, int64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh)))
-void svprfh(svbool_t, void const *, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u32base)))
-void svprfh_gather_u32base(svbool_t, svuint32_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u64base)))
-void svprfh_gather_u64base(svbool_t, svuint64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u32base_index)))
-void svprfh_gather_u32base_index(svbool_t, svuint32_t, int64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u64base_index)))
-void svprfh_gather_u64base_index(svbool_t, svuint64_t, int64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_s32index)))
-void svprfh_gather_s32index(svbool_t, void const *, svint32_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u32index)))
-void svprfh_gather_u32index(svbool_t, void const *, svuint32_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_s64index)))
-void svprfh_gather_s64index(svbool_t, void const *, svint64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u64index)))
-void svprfh_gather_u64index(svbool_t, void const *, svuint64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_vnum)))
-void svprfh_vnum(svbool_t, void const *, int64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw)))
-void svprfw(svbool_t, void const *, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u32base)))
-void svprfw_gather_u32base(svbool_t, svuint32_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u64base)))
-void svprfw_gather_u64base(svbool_t, svuint64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u32base_index)))
-void svprfw_gather_u32base_index(svbool_t, svuint32_t, int64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u64base_index)))
-void svprfw_gather_u64base_index(svbool_t, svuint64_t, int64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_s32index)))
-void svprfw_gather_s32index(svbool_t, void const *, svint32_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u32index)))
-void svprfw_gather_u32index(svbool_t, void const *, svuint32_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_s64index)))
-void svprfw_gather_s64index(svbool_t, void const *, svint64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u64index)))
-void svprfw_gather_u64index(svbool_t, void const *, svuint64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_vnum)))
-void svprfw_vnum(svbool_t, void const *, int64_t, enum svprfop);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptest_any)))
-bool svptest_any(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptest_first)))
-bool svptest_first(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptest_last)))
-bool svptest_last(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_pat_b8)))
-svbool_t svptrue_pat_b8(enum svpattern);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_pat_b32)))
-svbool_t svptrue_pat_b32(enum svpattern);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_pat_b64)))
-svbool_t svptrue_pat_b64(enum svpattern);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_pat_b16)))
-svbool_t svptrue_pat_b16(enum svpattern);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_b8)))
-svbool_t svptrue_b8(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_b32)))
-svbool_t svptrue_b32(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_b64)))
-svbool_t svptrue_b64(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_b16)))
-svbool_t svptrue_b16(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8)))
-svint8_t svqadd_n_s8(svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32)))
-svint32_t svqadd_n_s32(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64)))
-svint64_t svqadd_n_s64(svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16)))
-svint16_t svqadd_n_s16(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8)))
-svuint8_t svqadd_n_u8(svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32)))
-svuint32_t svqadd_n_u32(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64)))
-svuint64_t svqadd_n_u64(svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16)))
-svuint16_t svqadd_n_u16(svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8)))
-svint8_t svqadd_s8(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32)))
-svint32_t svqadd_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64)))
-svint64_t svqadd_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16)))
-svint16_t svqadd_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8)))
-svuint8_t svqadd_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32)))
-svuint32_t svqadd_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64)))
-svuint64_t svqadd_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16)))
-svuint16_t svqadd_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_s32)))
-int32_t svqdecb_n_s32(int32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_s64)))
-int64_t svqdecb_n_s64(int64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_u32)))
-uint32_t svqdecb_n_u32(uint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_u64)))
-uint64_t svqdecb_n_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_s32)))
-int32_t svqdecb_pat_n_s32(int32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_s64)))
-int64_t svqdecb_pat_n_s64(int64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_u32)))
-uint32_t svqdecb_pat_n_u32(uint32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_u64)))
-uint64_t svqdecb_pat_n_u64(uint64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_s32)))
-int32_t svqdecd_n_s32(int32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_s64)))
-int64_t svqdecd_n_s64(int64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_u32)))
-uint32_t svqdecd_n_u32(uint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_u64)))
-uint64_t svqdecd_n_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_s64)))
-svint64_t svqdecd_s64(svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_u64)))
-svuint64_t svqdecd_u64(svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_s32)))
-int32_t svqdecd_pat_n_s32(int32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_s64)))
-int64_t svqdecd_pat_n_s64(int64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_u32)))
-uint32_t svqdecd_pat_n_u32(uint32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_u64)))
-uint64_t svqdecd_pat_n_u64(uint64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_s64)))
-svint64_t svqdecd_pat_s64(svint64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_u64)))
-svuint64_t svqdecd_pat_u64(svuint64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_s32)))
-int32_t svqdech_n_s32(int32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_s64)))
-int64_t svqdech_n_s64(int64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_u32)))
-uint32_t svqdech_n_u32(uint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_u64)))
-uint64_t svqdech_n_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_s16)))
-svint16_t svqdech_s16(svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_u16)))
-svuint16_t svqdech_u16(svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_s32)))
-int32_t svqdech_pat_n_s32(int32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_s64)))
-int64_t svqdech_pat_n_s64(int64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_u32)))
-uint32_t svqdech_pat_n_u32(uint32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_u64)))
-uint64_t svqdech_pat_n_u64(uint64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_s16)))
-svint16_t svqdech_pat_s16(svint16_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_u16)))
-svuint16_t svqdech_pat_u16(svuint16_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b8)))
-int32_t svqdecp_n_s32_b8(int32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b32)))
-int32_t svqdecp_n_s32_b32(int32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b64)))
-int32_t svqdecp_n_s32_b64(int32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b16)))
-int32_t svqdecp_n_s32_b16(int32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b8)))
-int64_t svqdecp_n_s64_b8(int64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b32)))
-int64_t svqdecp_n_s64_b32(int64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b64)))
-int64_t svqdecp_n_s64_b64(int64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b16)))
-int64_t svqdecp_n_s64_b16(int64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b8)))
-uint32_t svqdecp_n_u32_b8(uint32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b32)))
-uint32_t svqdecp_n_u32_b32(uint32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b64)))
-uint32_t svqdecp_n_u32_b64(uint32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b16)))
-uint32_t svqdecp_n_u32_b16(uint32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b8)))
-uint64_t svqdecp_n_u64_b8(uint64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b32)))
-uint64_t svqdecp_n_u64_b32(uint64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b64)))
-uint64_t svqdecp_n_u64_b64(uint64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b16)))
-uint64_t svqdecp_n_u64_b16(uint64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_s32)))
-svint32_t svqdecp_s32(svint32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_s64)))
-svint64_t svqdecp_s64(svint64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_s16)))
-svint16_t svqdecp_s16(svint16_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_u32)))
-svuint32_t svqdecp_u32(svuint32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_u64)))
-svuint64_t svqdecp_u64(svuint64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_u16)))
-svuint16_t svqdecp_u16(svuint16_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_s32)))
-int32_t svqdecw_n_s32(int32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_s64)))
-int64_t svqdecw_n_s64(int64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_u32)))
-uint32_t svqdecw_n_u32(uint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_u64)))
-uint64_t svqdecw_n_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_s32)))
-svint32_t svqdecw_s32(svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_u32)))
-svuint32_t svqdecw_u32(svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_s32)))
-int32_t svqdecw_pat_n_s32(int32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_s64)))
-int64_t svqdecw_pat_n_s64(int64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_u32)))
-uint32_t svqdecw_pat_n_u32(uint32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_u64)))
-uint64_t svqdecw_pat_n_u64(uint64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_s32)))
-svint32_t svqdecw_pat_s32(svint32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_u32)))
-svuint32_t svqdecw_pat_u32(svuint32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_s32)))
-int32_t svqincb_n_s32(int32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_s64)))
-int64_t svqincb_n_s64(int64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_u32)))
-uint32_t svqincb_n_u32(uint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_u64)))
-uint64_t svqincb_n_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_s32)))
-int32_t svqincb_pat_n_s32(int32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_s64)))
-int64_t svqincb_pat_n_s64(int64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_u32)))
-uint32_t svqincb_pat_n_u32(uint32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_u64)))
-uint64_t svqincb_pat_n_u64(uint64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_s32)))
-int32_t svqincd_n_s32(int32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_s64)))
-int64_t svqincd_n_s64(int64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_u32)))
-uint32_t svqincd_n_u32(uint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_u64)))
-uint64_t svqincd_n_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_s64)))
-svint64_t svqincd_s64(svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_u64)))
-svuint64_t svqincd_u64(svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_s32)))
-int32_t svqincd_pat_n_s32(int32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_s64)))
-int64_t svqincd_pat_n_s64(int64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_u32)))
-uint32_t svqincd_pat_n_u32(uint32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_u64)))
-uint64_t svqincd_pat_n_u64(uint64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_s64)))
-svint64_t svqincd_pat_s64(svint64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_u64)))
-svuint64_t svqincd_pat_u64(svuint64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_s32)))
-int32_t svqinch_n_s32(int32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_s64)))
-int64_t svqinch_n_s64(int64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_u32)))
-uint32_t svqinch_n_u32(uint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_u64)))
-uint64_t svqinch_n_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_s16)))
-svint16_t svqinch_s16(svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_u16)))
-svuint16_t svqinch_u16(svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_s32)))
-int32_t svqinch_pat_n_s32(int32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_s64)))
-int64_t svqinch_pat_n_s64(int64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_u32)))
-uint32_t svqinch_pat_n_u32(uint32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_u64)))
-uint64_t svqinch_pat_n_u64(uint64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_s16)))
-svint16_t svqinch_pat_s16(svint16_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_u16)))
-svuint16_t svqinch_pat_u16(svuint16_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b8)))
-int32_t svqincp_n_s32_b8(int32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b32)))
-int32_t svqincp_n_s32_b32(int32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b64)))
-int32_t svqincp_n_s32_b64(int32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b16)))
-int32_t svqincp_n_s32_b16(int32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b8)))
-int64_t svqincp_n_s64_b8(int64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b32)))
-int64_t svqincp_n_s64_b32(int64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b64)))
-int64_t svqincp_n_s64_b64(int64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b16)))
-int64_t svqincp_n_s64_b16(int64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b8)))
-uint32_t svqincp_n_u32_b8(uint32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b32)))
-uint32_t svqincp_n_u32_b32(uint32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b64)))
-uint32_t svqincp_n_u32_b64(uint32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b16)))
-uint32_t svqincp_n_u32_b16(uint32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b8)))
-uint64_t svqincp_n_u64_b8(uint64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b32)))
-uint64_t svqincp_n_u64_b32(uint64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b64)))
-uint64_t svqincp_n_u64_b64(uint64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b16)))
-uint64_t svqincp_n_u64_b16(uint64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_s32)))
-svint32_t svqincp_s32(svint32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_s64)))
-svint64_t svqincp_s64(svint64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_s16)))
-svint16_t svqincp_s16(svint16_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_u32)))
-svuint32_t svqincp_u32(svuint32_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_u64)))
-svuint64_t svqincp_u64(svuint64_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_u16)))
-svuint16_t svqincp_u16(svuint16_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_s32)))
-int32_t svqincw_n_s32(int32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_s64)))
-int64_t svqincw_n_s64(int64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_u32)))
-uint32_t svqincw_n_u32(uint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_u64)))
-uint64_t svqincw_n_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_s32)))
-svint32_t svqincw_s32(svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_u32)))
-svuint32_t svqincw_u32(svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_s32)))
-int32_t svqincw_pat_n_s32(int32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_s64)))
-int64_t svqincw_pat_n_s64(int64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_u32)))
-uint32_t svqincw_pat_n_u32(uint32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_u64)))
-uint64_t svqincw_pat_n_u64(uint64_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_s32)))
-svint32_t svqincw_pat_s32(svint32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_u32)))
-svuint32_t svqincw_pat_u32(svuint32_t, enum svpattern, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8)))
-svint8_t svqsub_n_s8(svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32)))
-svint32_t svqsub_n_s32(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64)))
-svint64_t svqsub_n_s64(svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16)))
-svint16_t svqsub_n_s16(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8)))
-svuint8_t svqsub_n_u8(svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32)))
-svuint32_t svqsub_n_u32(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64)))
-svuint64_t svqsub_n_u64(svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16)))
-svuint16_t svqsub_n_u16(svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8)))
-svint8_t svqsub_s8(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32)))
-svint32_t svqsub_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64)))
-svint64_t svqsub_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16)))
-svint16_t svqsub_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8)))
-svuint8_t svqsub_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32)))
-svuint32_t svqsub_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64)))
-svuint64_t svqsub_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16)))
-svuint16_t svqsub_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u8_m)))
-svuint8_t svrbit_u8_m(svuint8_t, svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u32_m)))
-svuint32_t svrbit_u32_m(svuint32_t, svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u64_m)))
-svuint64_t svrbit_u64_m(svuint64_t, svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u16_m)))
-svuint16_t svrbit_u16_m(svuint16_t, svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s8_m)))
-svint8_t svrbit_s8_m(svint8_t, svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s32_m)))
-svint32_t svrbit_s32_m(svint32_t, svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s64_m)))
-svint64_t svrbit_s64_m(svint64_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s16_m)))
-svint16_t svrbit_s16_m(svint16_t, svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u8_x)))
-svuint8_t svrbit_u8_x(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u32_x)))
-svuint32_t svrbit_u32_x(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u64_x)))
-svuint64_t svrbit_u64_x(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u16_x)))
-svuint16_t svrbit_u16_x(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s8_x)))
-svint8_t svrbit_s8_x(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s32_x)))
-svint32_t svrbit_s32_x(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s64_x)))
-svint64_t svrbit_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s16_x)))
-svint16_t svrbit_s16_x(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u8_z)))
-svuint8_t svrbit_u8_z(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u32_z)))
-svuint32_t svrbit_u32_z(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u64_z)))
-svuint64_t svrbit_u64_z(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u16_z)))
-svuint16_t svrbit_u16_z(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s8_z)))
-svint8_t svrbit_s8_z(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s32_z)))
-svint32_t svrbit_s32_z(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s64_z)))
-svint64_t svrbit_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s16_z)))
-svint16_t svrbit_s16_z(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrdffr)))
-svbool_t svrdffr(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrdffr_z)))
-svbool_t svrdffr_z(svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_f64)))
-svfloat64_t svrecpe_f64(svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_f32)))
-svfloat32_t svrecpe_f32(svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_f16)))
-svfloat16_t svrecpe_f16(svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecps_f64)))
-svfloat64_t svrecps_f64(svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecps_f32)))
-svfloat32_t svrecps_f32(svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecps_f16)))
-svfloat16_t svrecps_f16(svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f64_m)))
-svfloat64_t svrecpx_f64_m(svfloat64_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f32_m)))
-svfloat32_t svrecpx_f32_m(svfloat32_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f16_m)))
-svfloat16_t svrecpx_f16_m(svfloat16_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f64_x)))
-svfloat64_t svrecpx_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f32_x)))
-svfloat32_t svrecpx_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f16_x)))
-svfloat16_t svrecpx_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f64_z)))
-svfloat64_t svrecpx_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f32_z)))
-svfloat32_t svrecpx_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f16_z)))
-svfloat16_t svrecpx_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u8)))
-svuint8_t svrev_u8(svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u32)))
-svuint32_t svrev_u32(svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u64)))
-svuint64_t svrev_u64(svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u16)))
-svuint16_t svrev_u16(svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s8)))
-svint8_t svrev_s8(svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_f64)))
-svfloat64_t svrev_f64(svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_f32)))
-svfloat32_t svrev_f32(svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_f16)))
-svfloat16_t svrev_f16(svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s32)))
-svint32_t svrev_s32(svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s64)))
-svint64_t svrev_s64(svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s16)))
-svint16_t svrev_s16(svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_b16)))
-svbool_t svrev_b16(svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_b32)))
-svbool_t svrev_b32(svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_b64)))
-svbool_t svrev_b64(svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_b8)))
-svbool_t svrev_b8(svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u32_m)))
-svuint32_t svrevb_u32_m(svuint32_t, svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u64_m)))
-svuint64_t svrevb_u64_m(svuint64_t, svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u16_m)))
-svuint16_t svrevb_u16_m(svuint16_t, svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s32_m)))
-svint32_t svrevb_s32_m(svint32_t, svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s64_m)))
-svint64_t svrevb_s64_m(svint64_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s16_m)))
-svint16_t svrevb_s16_m(svint16_t, svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u32_x)))
-svuint32_t svrevb_u32_x(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u64_x)))
-svuint64_t svrevb_u64_x(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u16_x)))
-svuint16_t svrevb_u16_x(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s32_x)))
-svint32_t svrevb_s32_x(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s64_x)))
-svint64_t svrevb_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s16_x)))
-svint16_t svrevb_s16_x(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u32_z)))
-svuint32_t svrevb_u32_z(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u64_z)))
-svuint64_t svrevb_u64_z(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u16_z)))
-svuint16_t svrevb_u16_z(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s32_z)))
-svint32_t svrevb_s32_z(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s64_z)))
-svint64_t svrevb_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s16_z)))
-svint16_t svrevb_s16_z(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_m)))
-svuint32_t svrevh_u32_m(svuint32_t, svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u64_m)))
-svuint64_t svrevh_u64_m(svuint64_t, svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s32_m)))
-svint32_t svrevh_s32_m(svint32_t, svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s64_m)))
-svint64_t svrevh_s64_m(svint64_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_x)))
-svuint32_t svrevh_u32_x(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u64_x)))
-svuint64_t svrevh_u64_x(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s32_x)))
-svint32_t svrevh_s32_x(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s64_x)))
-svint64_t svrevh_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_z)))
-svuint32_t svrevh_u32_z(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u64_z)))
-svuint64_t svrevh_u64_z(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s32_z)))
-svint32_t svrevh_s32_z(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s64_z)))
-svint64_t svrevh_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_m)))
-svuint64_t svrevw_u64_m(svuint64_t, svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_s64_m)))
-svint64_t svrevw_s64_m(svint64_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_x)))
-svuint64_t svrevw_u64_x(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_s64_x)))
-svint64_t svrevw_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_z)))
-svuint64_t svrevw_u64_z(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_s64_z)))
-svint64_t svrevw_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f64_m)))
-svfloat64_t svrinta_f64_m(svfloat64_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_m)))
-svfloat32_t svrinta_f32_m(svfloat32_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f16_m)))
-svfloat16_t svrinta_f16_m(svfloat16_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f64_x)))
-svfloat64_t svrinta_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_x)))
-svfloat32_t svrinta_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f16_x)))
-svfloat16_t svrinta_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f64_z)))
-svfloat64_t svrinta_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_z)))
-svfloat32_t svrinta_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f16_z)))
-svfloat16_t svrinta_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f64_m)))
-svfloat64_t svrinti_f64_m(svfloat64_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f32_m)))
-svfloat32_t svrinti_f32_m(svfloat32_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f16_m)))
-svfloat16_t svrinti_f16_m(svfloat16_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f64_x)))
-svfloat64_t svrinti_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f32_x)))
-svfloat32_t svrinti_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f16_x)))
-svfloat16_t svrinti_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f64_z)))
-svfloat64_t svrinti_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f32_z)))
-svfloat32_t svrinti_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f16_z)))
-svfloat16_t svrinti_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f64_m)))
-svfloat64_t svrintm_f64_m(svfloat64_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_m)))
-svfloat32_t svrintm_f32_m(svfloat32_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f16_m)))
-svfloat16_t svrintm_f16_m(svfloat16_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f64_x)))
-svfloat64_t svrintm_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_x)))
-svfloat32_t svrintm_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f16_x)))
-svfloat16_t svrintm_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f64_z)))
-svfloat64_t svrintm_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_z)))
-svfloat32_t svrintm_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f16_z)))
-svfloat16_t svrintm_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f64_m)))
-svfloat64_t svrintn_f64_m(svfloat64_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_m)))
-svfloat32_t svrintn_f32_m(svfloat32_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f16_m)))
-svfloat16_t svrintn_f16_m(svfloat16_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f64_x)))
-svfloat64_t svrintn_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_x)))
-svfloat32_t svrintn_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f16_x)))
-svfloat16_t svrintn_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f64_z)))
-svfloat64_t svrintn_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_z)))
-svfloat32_t svrintn_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f16_z)))
-svfloat16_t svrintn_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f64_m)))
-svfloat64_t svrintp_f64_m(svfloat64_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_m)))
-svfloat32_t svrintp_f32_m(svfloat32_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f16_m)))
-svfloat16_t svrintp_f16_m(svfloat16_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f64_x)))
-svfloat64_t svrintp_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_x)))
-svfloat32_t svrintp_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f16_x)))
-svfloat16_t svrintp_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f64_z)))
-svfloat64_t svrintp_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_z)))
-svfloat32_t svrintp_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f16_z)))
-svfloat16_t svrintp_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f64_m)))
-svfloat64_t svrintx_f64_m(svfloat64_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f32_m)))
-svfloat32_t svrintx_f32_m(svfloat32_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f16_m)))
-svfloat16_t svrintx_f16_m(svfloat16_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f64_x)))
-svfloat64_t svrintx_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f32_x)))
-svfloat32_t svrintx_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f16_x)))
-svfloat16_t svrintx_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f64_z)))
-svfloat64_t svrintx_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f32_z)))
-svfloat32_t svrintx_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f16_z)))
-svfloat16_t svrintx_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f64_m)))
-svfloat64_t svrintz_f64_m(svfloat64_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f32_m)))
-svfloat32_t svrintz_f32_m(svfloat32_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f16_m)))
-svfloat16_t svrintz_f16_m(svfloat16_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f64_x)))
-svfloat64_t svrintz_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f32_x)))
-svfloat32_t svrintz_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f16_x)))
-svfloat16_t svrintz_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f64_z)))
-svfloat64_t svrintz_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f32_z)))
-svfloat32_t svrintz_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f16_z)))
-svfloat16_t svrintz_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_f64)))
-svfloat64_t svrsqrte_f64(svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_f32)))
-svfloat32_t svrsqrte_f32(svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_f16)))
-svfloat16_t svrsqrte_f16(svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrts_f64)))
-svfloat64_t svrsqrts_f64(svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrts_f32)))
-svfloat32_t svrsqrts_f32(svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrts_f16)))
-svfloat16_t svrsqrts_f16(svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f64_m)))
-svfloat64_t svscale_n_f64_m(svbool_t, svfloat64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f32_m)))
-svfloat32_t svscale_n_f32_m(svbool_t, svfloat32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f16_m)))
-svfloat16_t svscale_n_f16_m(svbool_t, svfloat16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f64_x)))
-svfloat64_t svscale_n_f64_x(svbool_t, svfloat64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f32_x)))
-svfloat32_t svscale_n_f32_x(svbool_t, svfloat32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f16_x)))
-svfloat16_t svscale_n_f16_x(svbool_t, svfloat16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f64_z)))
-svfloat64_t svscale_n_f64_z(svbool_t, svfloat64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f32_z)))
-svfloat32_t svscale_n_f32_z(svbool_t, svfloat32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f16_z)))
-svfloat16_t svscale_n_f16_z(svbool_t, svfloat16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f64_m)))
-svfloat64_t svscale_f64_m(svbool_t, svfloat64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f32_m)))
-svfloat32_t svscale_f32_m(svbool_t, svfloat32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f16_m)))
-svfloat16_t svscale_f16_m(svbool_t, svfloat16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f64_x)))
-svfloat64_t svscale_f64_x(svbool_t, svfloat64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f32_x)))
-svfloat32_t svscale_f32_x(svbool_t, svfloat32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f16_x)))
-svfloat16_t svscale_f16_x(svbool_t, svfloat16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f64_z)))
-svfloat64_t svscale_f64_z(svbool_t, svfloat64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f32_z)))
-svfloat32_t svscale_f32_z(svbool_t, svfloat32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f16_z)))
-svfloat16_t svscale_f16_z(svbool_t, svfloat16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_b)))
-svbool_t svsel_b(svbool_t, svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8)))
-svuint8_t svsel_u8(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u32)))
-svuint32_t svsel_u32(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u64)))
-svuint64_t svsel_u64(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u16)))
-svuint16_t svsel_u16(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s8)))
-svint8_t svsel_s8(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f64)))
-svfloat64_t svsel_f64(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f32)))
-svfloat32_t svsel_f32(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16)))
-svfloat16_t svsel_f16(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s32)))
-svint32_t svsel_s32(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s64)))
-svint64_t svsel_s64(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s16)))
-svint16_t svsel_s16(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u8)))
-svuint8x2_t svset2_u8(svuint8x2_t, uint64_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u32)))
-svuint32x2_t svset2_u32(svuint32x2_t, uint64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u64)))
-svuint64x2_t svset2_u64(svuint64x2_t, uint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u16)))
-svuint16x2_t svset2_u16(svuint16x2_t, uint64_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s8)))
-svint8x2_t svset2_s8(svint8x2_t, uint64_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_f64)))
-svfloat64x2_t svset2_f64(svfloat64x2_t, uint64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_f32)))
-svfloat32x2_t svset2_f32(svfloat32x2_t, uint64_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_f16)))
-svfloat16x2_t svset2_f16(svfloat16x2_t, uint64_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s32)))
-svint32x2_t svset2_s32(svint32x2_t, uint64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s64)))
-svint64x2_t svset2_s64(svint64x2_t, uint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s16)))
-svint16x2_t svset2_s16(svint16x2_t, uint64_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u8)))
-svuint8x3_t svset3_u8(svuint8x3_t, uint64_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u32)))
-svuint32x3_t svset3_u32(svuint32x3_t, uint64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u64)))
-svuint64x3_t svset3_u64(svuint64x3_t, uint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u16)))
-svuint16x3_t svset3_u16(svuint16x3_t, uint64_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s8)))
-svint8x3_t svset3_s8(svint8x3_t, uint64_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_f64)))
-svfloat64x3_t svset3_f64(svfloat64x3_t, uint64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_f32)))
-svfloat32x3_t svset3_f32(svfloat32x3_t, uint64_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_f16)))
-svfloat16x3_t svset3_f16(svfloat16x3_t, uint64_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s32)))
-svint32x3_t svset3_s32(svint32x3_t, uint64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s64)))
-svint64x3_t svset3_s64(svint64x3_t, uint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s16)))
-svint16x3_t svset3_s16(svint16x3_t, uint64_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u8)))
-svuint8x4_t svset4_u8(svuint8x4_t, uint64_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u32)))
-svuint32x4_t svset4_u32(svuint32x4_t, uint64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u64)))
-svuint64x4_t svset4_u64(svuint64x4_t, uint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u16)))
-svuint16x4_t svset4_u16(svuint16x4_t, uint64_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s8)))
-svint8x4_t svset4_s8(svint8x4_t, uint64_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_f64)))
-svfloat64x4_t svset4_f64(svfloat64x4_t, uint64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_f32)))
-svfloat32x4_t svset4_f32(svfloat32x4_t, uint64_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_f16)))
-svfloat16x4_t svset4_f16(svfloat16x4_t, uint64_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s32)))
-svint32x4_t svset4_s32(svint32x4_t, uint64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s64)))
-svint64x4_t svset4_s64(svint64x4_t, uint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s16)))
-svint16x4_t svset4_s16(svint16x4_t, uint64_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsetffr)))
-void svsetffr(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u8)))
-svuint8_t svsplice_u8(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u32)))
-svuint32_t svsplice_u32(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u64)))
-svuint64_t svsplice_u64(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u16)))
-svuint16_t svsplice_u16(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s8)))
-svint8_t svsplice_s8(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_f64)))
-svfloat64_t svsplice_f64(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_f32)))
-svfloat32_t svsplice_f32(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_f16)))
-svfloat16_t svsplice_f16(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s32)))
-svint32_t svsplice_s32(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s64)))
-svint64_t svsplice_s64(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s16)))
-svint16_t svsplice_s16(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f64_m)))
-svfloat64_t svsqrt_f64_m(svfloat64_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f32_m)))
-svfloat32_t svsqrt_f32_m(svfloat32_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f16_m)))
-svfloat16_t svsqrt_f16_m(svfloat16_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f64_x)))
-svfloat64_t svsqrt_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f32_x)))
-svfloat32_t svsqrt_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f16_x)))
-svfloat16_t svsqrt_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f64_z)))
-svfloat64_t svsqrt_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f32_z)))
-svfloat32_t svsqrt_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f16_z)))
-svfloat16_t svsqrt_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u8)))
-void svst1_u8(svbool_t, uint8_t *, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u32)))
-void svst1_u32(svbool_t, uint32_t *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u64)))
-void svst1_u64(svbool_t, uint64_t *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u16)))
-void svst1_u16(svbool_t, uint16_t *, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s8)))
-void svst1_s8(svbool_t, int8_t *, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f64)))
-void svst1_f64(svbool_t, float64_t *, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f32)))
-void svst1_f32(svbool_t, float32_t *, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f16)))
-void svst1_f16(svbool_t, float16_t *, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s32)))
-void svst1_s32(svbool_t, int32_t *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s64)))
-void svst1_s64(svbool_t, int64_t *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s16)))
-void svst1_s16(svbool_t, int16_t *, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_index_u32)))
-void svst1_scatter_u32base_index_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_index_u64)))
-void svst1_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_index_f64)))
-void svst1_scatter_u64base_index_f64(svbool_t, svuint64_t, int64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_index_f32)))
-void svst1_scatter_u32base_index_f32(svbool_t, svuint32_t, int64_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_index_s32)))
-void svst1_scatter_u32base_index_s32(svbool_t, svuint32_t, int64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_index_s64)))
-void svst1_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_offset_u32)))
-void svst1_scatter_u32base_offset_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_offset_u64)))
-void svst1_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_offset_f64)))
-void svst1_scatter_u64base_offset_f64(svbool_t, svuint64_t, int64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_offset_f32)))
-void svst1_scatter_u32base_offset_f32(svbool_t, svuint32_t, int64_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_offset_s32)))
-void svst1_scatter_u32base_offset_s32(svbool_t, svuint32_t, int64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_offset_s64)))
-void svst1_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_u32)))
-void svst1_scatter_u32base_u32(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_u64)))
-void svst1_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_f64)))
-void svst1_scatter_u64base_f64(svbool_t, svuint64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_f32)))
-void svst1_scatter_u32base_f32(svbool_t, svuint32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_s32)))
-void svst1_scatter_u32base_s32(svbool_t, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_s64)))
-void svst1_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32index_u32)))
-void svst1_scatter_s32index_u32(svbool_t, uint32_t *, svint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32index_f32)))
-void svst1_scatter_s32index_f32(svbool_t, float32_t *, svint32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32index_s32)))
-void svst1_scatter_s32index_s32(svbool_t, int32_t *, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32index_u32)))
-void svst1_scatter_u32index_u32(svbool_t, uint32_t *, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32index_f32)))
-void svst1_scatter_u32index_f32(svbool_t, float32_t *, svuint32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32index_s32)))
-void svst1_scatter_u32index_s32(svbool_t, int32_t *, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64index_u64)))
-void svst1_scatter_s64index_u64(svbool_t, uint64_t *, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64index_f64)))
-void svst1_scatter_s64index_f64(svbool_t, float64_t *, svint64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64index_s64)))
-void svst1_scatter_s64index_s64(svbool_t, int64_t *, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64index_u64)))
-void svst1_scatter_u64index_u64(svbool_t, uint64_t *, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64index_f64)))
-void svst1_scatter_u64index_f64(svbool_t, float64_t *, svuint64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64index_s64)))
-void svst1_scatter_u64index_s64(svbool_t, int64_t *, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32offset_u32)))
-void svst1_scatter_s32offset_u32(svbool_t, uint32_t *, svint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32offset_f32)))
-void svst1_scatter_s32offset_f32(svbool_t, float32_t *, svint32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32offset_s32)))
-void svst1_scatter_s32offset_s32(svbool_t, int32_t *, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32offset_u32)))
-void svst1_scatter_u32offset_u32(svbool_t, uint32_t *, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32offset_f32)))
-void svst1_scatter_u32offset_f32(svbool_t, float32_t *, svuint32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32offset_s32)))
-void svst1_scatter_u32offset_s32(svbool_t, int32_t *, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64offset_u64)))
-void svst1_scatter_s64offset_u64(svbool_t, uint64_t *, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64offset_f64)))
-void svst1_scatter_s64offset_f64(svbool_t, float64_t *, svint64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64offset_s64)))
-void svst1_scatter_s64offset_s64(svbool_t, int64_t *, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64offset_u64)))
-void svst1_scatter_u64offset_u64(svbool_t, uint64_t *, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64offset_f64)))
-void svst1_scatter_u64offset_f64(svbool_t, float64_t *, svuint64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64offset_s64)))
-void svst1_scatter_u64offset_s64(svbool_t, int64_t *, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u8)))
-void svst1_vnum_u8(svbool_t, uint8_t *, int64_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u32)))
-void svst1_vnum_u32(svbool_t, uint32_t *, int64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u64)))
-void svst1_vnum_u64(svbool_t, uint64_t *, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u16)))
-void svst1_vnum_u16(svbool_t, uint16_t *, int64_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s8)))
-void svst1_vnum_s8(svbool_t, int8_t *, int64_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f64)))
-void svst1_vnum_f64(svbool_t, float64_t *, int64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f32)))
-void svst1_vnum_f32(svbool_t, float32_t *, int64_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f16)))
-void svst1_vnum_f16(svbool_t, float16_t *, int64_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s32)))
-void svst1_vnum_s32(svbool_t, int32_t *, int64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s64)))
-void svst1_vnum_s64(svbool_t, int64_t *, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s16)))
-void svst1_vnum_s16(svbool_t, int16_t *, int64_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_s32)))
-void svst1b_s32(svbool_t, int8_t *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_s64)))
-void svst1b_s64(svbool_t, int8_t *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_s16)))
-void svst1b_s16(svbool_t, int8_t *, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_u32)))
-void svst1b_u32(svbool_t, uint8_t *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_u64)))
-void svst1b_u64(svbool_t, uint8_t *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_u16)))
-void svst1b_u16(svbool_t, uint8_t *, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_offset_u32)))
-void svst1b_scatter_u32base_offset_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_offset_u64)))
-void svst1b_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_offset_s32)))
-void svst1b_scatter_u32base_offset_s32(svbool_t, svuint32_t, int64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_offset_s64)))
-void svst1b_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_u32)))
-void svst1b_scatter_u32base_u32(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_u64)))
-void svst1b_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_s32)))
-void svst1b_scatter_u32base_s32(svbool_t, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_s64)))
-void svst1b_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s32offset_s32)))
-void svst1b_scatter_s32offset_s32(svbool_t, int8_t *, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s32offset_u32)))
-void svst1b_scatter_s32offset_u32(svbool_t, uint8_t *, svint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32offset_s32)))
-void svst1b_scatter_u32offset_s32(svbool_t, int8_t *, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32offset_u32)))
-void svst1b_scatter_u32offset_u32(svbool_t, uint8_t *, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s64offset_s64)))
-void svst1b_scatter_s64offset_s64(svbool_t, int8_t *, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s64offset_u64)))
-void svst1b_scatter_s64offset_u64(svbool_t, uint8_t *, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64offset_s64)))
-void svst1b_scatter_u64offset_s64(svbool_t, int8_t *, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64offset_u64)))
-void svst1b_scatter_u64offset_u64(svbool_t, uint8_t *, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_s32)))
-void svst1b_vnum_s32(svbool_t, int8_t *, int64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_s64)))
-void svst1b_vnum_s64(svbool_t, int8_t *, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_s16)))
-void svst1b_vnum_s16(svbool_t, int8_t *, int64_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_u32)))
-void svst1b_vnum_u32(svbool_t, uint8_t *, int64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_u64)))
-void svst1b_vnum_u64(svbool_t, uint8_t *, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_u16)))
-void svst1b_vnum_u16(svbool_t, uint8_t *, int64_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_s32)))
-void svst1h_s32(svbool_t, int16_t *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_s64)))
-void svst1h_s64(svbool_t, int16_t *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_u32)))
-void svst1h_u32(svbool_t, uint16_t *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_u64)))
-void svst1h_u64(svbool_t, uint16_t *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_index_u32)))
-void svst1h_scatter_u32base_index_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_index_u64)))
-void svst1h_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_index_s32)))
-void svst1h_scatter_u32base_index_s32(svbool_t, svuint32_t, int64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_index_s64)))
-void svst1h_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_offset_u32)))
-void svst1h_scatter_u32base_offset_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_offset_u64)))
-void svst1h_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_offset_s32)))
-void svst1h_scatter_u32base_offset_s32(svbool_t, svuint32_t, int64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_offset_s64)))
-void svst1h_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_u32)))
-void svst1h_scatter_u32base_u32(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_u64)))
-void svst1h_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_s32)))
-void svst1h_scatter_u32base_s32(svbool_t, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_s64)))
-void svst1h_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32index_s32)))
-void svst1h_scatter_s32index_s32(svbool_t, int16_t *, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32index_u32)))
-void svst1h_scatter_s32index_u32(svbool_t, uint16_t *, svint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32index_s32)))
-void svst1h_scatter_u32index_s32(svbool_t, int16_t *, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32index_u32)))
-void svst1h_scatter_u32index_u32(svbool_t, uint16_t *, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64index_s64)))
-void svst1h_scatter_s64index_s64(svbool_t, int16_t *, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64index_u64)))
-void svst1h_scatter_s64index_u64(svbool_t, uint16_t *, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64index_s64)))
-void svst1h_scatter_u64index_s64(svbool_t, int16_t *, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64index_u64)))
-void svst1h_scatter_u64index_u64(svbool_t, uint16_t *, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32offset_s32)))
-void svst1h_scatter_s32offset_s32(svbool_t, int16_t *, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32offset_u32)))
-void svst1h_scatter_s32offset_u32(svbool_t, uint16_t *, svint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32offset_s32)))
-void svst1h_scatter_u32offset_s32(svbool_t, int16_t *, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32offset_u32)))
-void svst1h_scatter_u32offset_u32(svbool_t, uint16_t *, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64offset_s64)))
-void svst1h_scatter_s64offset_s64(svbool_t, int16_t *, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64offset_u64)))
-void svst1h_scatter_s64offset_u64(svbool_t, uint16_t *, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64offset_s64)))
-void svst1h_scatter_u64offset_s64(svbool_t, int16_t *, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64offset_u64)))
-void svst1h_scatter_u64offset_u64(svbool_t, uint16_t *, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_s32)))
-void svst1h_vnum_s32(svbool_t, int16_t *, int64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_s64)))
-void svst1h_vnum_s64(svbool_t, int16_t *, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_u32)))
-void svst1h_vnum_u32(svbool_t, uint16_t *, int64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_u64)))
-void svst1h_vnum_u64(svbool_t, uint16_t *, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_s64)))
-void svst1w_s64(svbool_t, int32_t *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_u64)))
-void svst1w_u64(svbool_t, uint32_t *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_index_u64)))
-void svst1w_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_index_s64)))
-void svst1w_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_offset_u64)))
-void svst1w_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_offset_s64)))
-void svst1w_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_u64)))
-void svst1w_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_s64)))
-void svst1w_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64index_s64)))
-void svst1w_scatter_s64index_s64(svbool_t, int32_t *, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64index_u64)))
-void svst1w_scatter_s64index_u64(svbool_t, uint32_t *, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64index_s64)))
-void svst1w_scatter_u64index_s64(svbool_t, int32_t *, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64index_u64)))
-void svst1w_scatter_u64index_u64(svbool_t, uint32_t *, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64offset_s64)))
-void svst1w_scatter_s64offset_s64(svbool_t, int32_t *, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64offset_u64)))
-void svst1w_scatter_s64offset_u64(svbool_t, uint32_t *, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64offset_s64)))
-void svst1w_scatter_u64offset_s64(svbool_t, int32_t *, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64offset_u64)))
-void svst1w_scatter_u64offset_u64(svbool_t, uint32_t *, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_vnum_s64)))
-void svst1w_vnum_s64(svbool_t, int32_t *, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_vnum_u64)))
-void svst1w_vnum_u64(svbool_t, uint32_t *, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u8)))
-void svst2_u8(svbool_t, uint8_t *, svuint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u32)))
-void svst2_u32(svbool_t, uint32_t *, svuint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u64)))
-void svst2_u64(svbool_t, uint64_t *, svuint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u16)))
-void svst2_u16(svbool_t, uint16_t *, svuint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s8)))
-void svst2_s8(svbool_t, int8_t *, svint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_f64)))
-void svst2_f64(svbool_t, float64_t *, svfloat64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_f32)))
-void svst2_f32(svbool_t, float32_t *, svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_f16)))
-void svst2_f16(svbool_t, float16_t *, svfloat16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s32)))
-void svst2_s32(svbool_t, int32_t *, svint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s64)))
-void svst2_s64(svbool_t, int64_t *, svint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s16)))
-void svst2_s16(svbool_t, int16_t *, svint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u8)))
-void svst2_vnum_u8(svbool_t, uint8_t *, int64_t, svuint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u32)))
-void svst2_vnum_u32(svbool_t, uint32_t *, int64_t, svuint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u64)))
-void svst2_vnum_u64(svbool_t, uint64_t *, int64_t, svuint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u16)))
-void svst2_vnum_u16(svbool_t, uint16_t *, int64_t, svuint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s8)))
-void svst2_vnum_s8(svbool_t, int8_t *, int64_t, svint8x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_f64)))
-void svst2_vnum_f64(svbool_t, float64_t *, int64_t, svfloat64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_f32)))
-void svst2_vnum_f32(svbool_t, float32_t *, int64_t, svfloat32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_f16)))
-void svst2_vnum_f16(svbool_t, float16_t *, int64_t, svfloat16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s32)))
-void svst2_vnum_s32(svbool_t, int32_t *, int64_t, svint32x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s64)))
-void svst2_vnum_s64(svbool_t, int64_t *, int64_t, svint64x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s16)))
-void svst2_vnum_s16(svbool_t, int16_t *, int64_t, svint16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u8)))
-void svst3_u8(svbool_t, uint8_t *, svuint8x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u32)))
-void svst3_u32(svbool_t, uint32_t *, svuint32x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u64)))
-void svst3_u64(svbool_t, uint64_t *, svuint64x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u16)))
-void svst3_u16(svbool_t, uint16_t *, svuint16x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s8)))
-void svst3_s8(svbool_t, int8_t *, svint8x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_f64)))
-void svst3_f64(svbool_t, float64_t *, svfloat64x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_f32)))
-void svst3_f32(svbool_t, float32_t *, svfloat32x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_f16)))
-void svst3_f16(svbool_t, float16_t *, svfloat16x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s32)))
-void svst3_s32(svbool_t, int32_t *, svint32x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s64)))
-void svst3_s64(svbool_t, int64_t *, svint64x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s16)))
-void svst3_s16(svbool_t, int16_t *, svint16x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u8)))
-void svst3_vnum_u8(svbool_t, uint8_t *, int64_t, svuint8x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u32)))
-void svst3_vnum_u32(svbool_t, uint32_t *, int64_t, svuint32x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u64)))
-void svst3_vnum_u64(svbool_t, uint64_t *, int64_t, svuint64x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u16)))
-void svst3_vnum_u16(svbool_t, uint16_t *, int64_t, svuint16x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s8)))
-void svst3_vnum_s8(svbool_t, int8_t *, int64_t, svint8x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_f64)))
-void svst3_vnum_f64(svbool_t, float64_t *, int64_t, svfloat64x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_f32)))
-void svst3_vnum_f32(svbool_t, float32_t *, int64_t, svfloat32x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_f16)))
-void svst3_vnum_f16(svbool_t, float16_t *, int64_t, svfloat16x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s32)))
-void svst3_vnum_s32(svbool_t, int32_t *, int64_t, svint32x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s64)))
-void svst3_vnum_s64(svbool_t, int64_t *, int64_t, svint64x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s16)))
-void svst3_vnum_s16(svbool_t, int16_t *, int64_t, svint16x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u8)))
-void svst4_u8(svbool_t, uint8_t *, svuint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u32)))
-void svst4_u32(svbool_t, uint32_t *, svuint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u64)))
-void svst4_u64(svbool_t, uint64_t *, svuint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u16)))
-void svst4_u16(svbool_t, uint16_t *, svuint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s8)))
-void svst4_s8(svbool_t, int8_t *, svint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_f64)))
-void svst4_f64(svbool_t, float64_t *, svfloat64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_f32)))
-void svst4_f32(svbool_t, float32_t *, svfloat32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_f16)))
-void svst4_f16(svbool_t, float16_t *, svfloat16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s32)))
-void svst4_s32(svbool_t, int32_t *, svint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s64)))
-void svst4_s64(svbool_t, int64_t *, svint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s16)))
-void svst4_s16(svbool_t, int16_t *, svint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u8)))
-void svst4_vnum_u8(svbool_t, uint8_t *, int64_t, svuint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u32)))
-void svst4_vnum_u32(svbool_t, uint32_t *, int64_t, svuint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u64)))
-void svst4_vnum_u64(svbool_t, uint64_t *, int64_t, svuint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u16)))
-void svst4_vnum_u16(svbool_t, uint16_t *, int64_t, svuint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s8)))
-void svst4_vnum_s8(svbool_t, int8_t *, int64_t, svint8x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_f64)))
-void svst4_vnum_f64(svbool_t, float64_t *, int64_t, svfloat64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_f32)))
-void svst4_vnum_f32(svbool_t, float32_t *, int64_t, svfloat32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_f16)))
-void svst4_vnum_f16(svbool_t, float16_t *, int64_t, svfloat16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s32)))
-void svst4_vnum_s32(svbool_t, int32_t *, int64_t, svint32x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s64)))
-void svst4_vnum_s64(svbool_t, int64_t *, int64_t, svint64x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s16)))
-void svst4_vnum_s16(svbool_t, int16_t *, int64_t, svint16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u8)))
-void svstnt1_u8(svbool_t, uint8_t *, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u32)))
-void svstnt1_u32(svbool_t, uint32_t *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u64)))
-void svstnt1_u64(svbool_t, uint64_t *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u16)))
-void svstnt1_u16(svbool_t, uint16_t *, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s8)))
-void svstnt1_s8(svbool_t, int8_t *, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f64)))
-void svstnt1_f64(svbool_t, float64_t *, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f32)))
-void svstnt1_f32(svbool_t, float32_t *, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f16)))
-void svstnt1_f16(svbool_t, float16_t *, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s32)))
-void svstnt1_s32(svbool_t, int32_t *, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s64)))
-void svstnt1_s64(svbool_t, int64_t *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s16)))
-void svstnt1_s16(svbool_t, int16_t *, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u8)))
-void svstnt1_vnum_u8(svbool_t, uint8_t *, int64_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u32)))
-void svstnt1_vnum_u32(svbool_t, uint32_t *, int64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u64)))
-void svstnt1_vnum_u64(svbool_t, uint64_t *, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u16)))
-void svstnt1_vnum_u16(svbool_t, uint16_t *, int64_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s8)))
-void svstnt1_vnum_s8(svbool_t, int8_t *, int64_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f64)))
-void svstnt1_vnum_f64(svbool_t, float64_t *, int64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f32)))
-void svstnt1_vnum_f32(svbool_t, float32_t *, int64_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f16)))
-void svstnt1_vnum_f16(svbool_t, float16_t *, int64_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s32)))
-void svstnt1_vnum_s32(svbool_t, int32_t *, int64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s64)))
-void svstnt1_vnum_s64(svbool_t, int64_t *, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s16)))
-void svstnt1_vnum_s16(svbool_t, int16_t *, int64_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f64_m)))
-svfloat64_t svsub_n_f64_m(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f32_m)))
-svfloat32_t svsub_n_f32_m(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f16_m)))
-svfloat16_t svsub_n_f16_m(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f64_x)))
-svfloat64_t svsub_n_f64_x(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f32_x)))
-svfloat32_t svsub_n_f32_x(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f16_x)))
-svfloat16_t svsub_n_f16_x(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f64_z)))
-svfloat64_t svsub_n_f64_z(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f32_z)))
-svfloat32_t svsub_n_f32_z(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f16_z)))
-svfloat16_t svsub_n_f16_z(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u8_m)))
-svuint8_t svsub_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u32_m)))
-svuint32_t svsub_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u64_m)))
-svuint64_t svsub_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u16_m)))
-svuint16_t svsub_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s8_m)))
-svint8_t svsub_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s32_m)))
-svint32_t svsub_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s64_m)))
-svint64_t svsub_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s16_m)))
-svint16_t svsub_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u8_x)))
-svuint8_t svsub_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u32_x)))
-svuint32_t svsub_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u64_x)))
-svuint64_t svsub_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u16_x)))
-svuint16_t svsub_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s8_x)))
-svint8_t svsub_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s32_x)))
-svint32_t svsub_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s64_x)))
-svint64_t svsub_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s16_x)))
-svint16_t svsub_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u8_z)))
-svuint8_t svsub_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u32_z)))
-svuint32_t svsub_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u64_z)))
-svuint64_t svsub_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u16_z)))
-svuint16_t svsub_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s8_z)))
-svint8_t svsub_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s32_z)))
-svint32_t svsub_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s64_z)))
-svint64_t svsub_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s16_z)))
-svint16_t svsub_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f64_m)))
-svfloat64_t svsub_f64_m(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f32_m)))
-svfloat32_t svsub_f32_m(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f16_m)))
-svfloat16_t svsub_f16_m(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f64_x)))
-svfloat64_t svsub_f64_x(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f32_x)))
-svfloat32_t svsub_f32_x(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f16_x)))
-svfloat16_t svsub_f16_x(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f64_z)))
-svfloat64_t svsub_f64_z(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f32_z)))
-svfloat32_t svsub_f32_z(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f16_z)))
-svfloat16_t svsub_f16_z(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u8_m)))
-svuint8_t svsub_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u32_m)))
-svuint32_t svsub_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u64_m)))
-svuint64_t svsub_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u16_m)))
-svuint16_t svsub_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s8_m)))
-svint8_t svsub_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s32_m)))
-svint32_t svsub_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s64_m)))
-svint64_t svsub_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s16_m)))
-svint16_t svsub_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u8_x)))
-svuint8_t svsub_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u32_x)))
-svuint32_t svsub_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u64_x)))
-svuint64_t svsub_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u16_x)))
-svuint16_t svsub_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s8_x)))
-svint8_t svsub_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s32_x)))
-svint32_t svsub_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s64_x)))
-svint64_t svsub_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s16_x)))
-svint16_t svsub_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u8_z)))
-svuint8_t svsub_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u32_z)))
-svuint32_t svsub_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u64_z)))
-svuint64_t svsub_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u16_z)))
-svuint16_t svsub_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s8_z)))
-svint8_t svsub_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s32_z)))
-svint32_t svsub_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s64_z)))
-svint64_t svsub_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s16_z)))
-svint16_t svsub_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f64_m)))
-svfloat64_t svsubr_n_f64_m(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f32_m)))
-svfloat32_t svsubr_n_f32_m(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f16_m)))
-svfloat16_t svsubr_n_f16_m(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f64_x)))
-svfloat64_t svsubr_n_f64_x(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f32_x)))
-svfloat32_t svsubr_n_f32_x(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f16_x)))
-svfloat16_t svsubr_n_f16_x(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f64_z)))
-svfloat64_t svsubr_n_f64_z(svbool_t, svfloat64_t, float64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f32_z)))
-svfloat32_t svsubr_n_f32_z(svbool_t, svfloat32_t, float32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f16_z)))
-svfloat16_t svsubr_n_f16_z(svbool_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u8_m)))
-svuint8_t svsubr_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u32_m)))
-svuint32_t svsubr_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u64_m)))
-svuint64_t svsubr_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u16_m)))
-svuint16_t svsubr_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s8_m)))
-svint8_t svsubr_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s32_m)))
-svint32_t svsubr_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s64_m)))
-svint64_t svsubr_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s16_m)))
-svint16_t svsubr_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u8_x)))
-svuint8_t svsubr_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u32_x)))
-svuint32_t svsubr_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u64_x)))
-svuint64_t svsubr_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u16_x)))
-svuint16_t svsubr_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s8_x)))
-svint8_t svsubr_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s32_x)))
-svint32_t svsubr_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s64_x)))
-svint64_t svsubr_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s16_x)))
-svint16_t svsubr_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u8_z)))
-svuint8_t svsubr_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u32_z)))
-svuint32_t svsubr_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u64_z)))
-svuint64_t svsubr_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u16_z)))
-svuint16_t svsubr_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s8_z)))
-svint8_t svsubr_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s32_z)))
-svint32_t svsubr_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s64_z)))
-svint64_t svsubr_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s16_z)))
-svint16_t svsubr_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f64_m)))
-svfloat64_t svsubr_f64_m(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f32_m)))
-svfloat32_t svsubr_f32_m(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f16_m)))
-svfloat16_t svsubr_f16_m(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f64_x)))
-svfloat64_t svsubr_f64_x(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f32_x)))
-svfloat32_t svsubr_f32_x(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f16_x)))
-svfloat16_t svsubr_f16_x(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f64_z)))
-svfloat64_t svsubr_f64_z(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f32_z)))
-svfloat32_t svsubr_f32_z(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f16_z)))
-svfloat16_t svsubr_f16_z(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u8_m)))
-svuint8_t svsubr_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u32_m)))
-svuint32_t svsubr_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u64_m)))
-svuint64_t svsubr_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u16_m)))
-svuint16_t svsubr_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s8_m)))
-svint8_t svsubr_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s32_m)))
-svint32_t svsubr_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s64_m)))
-svint64_t svsubr_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s16_m)))
-svint16_t svsubr_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u8_x)))
-svuint8_t svsubr_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u32_x)))
-svuint32_t svsubr_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u64_x)))
-svuint64_t svsubr_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u16_x)))
-svuint16_t svsubr_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s8_x)))
-svint8_t svsubr_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s32_x)))
-svint32_t svsubr_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s64_x)))
-svint64_t svsubr_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s16_x)))
-svint16_t svsubr_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u8_z)))
-svuint8_t svsubr_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u32_z)))
-svuint32_t svsubr_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u64_z)))
-svuint64_t svsubr_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u16_z)))
-svuint16_t svsubr_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s8_z)))
-svint8_t svsubr_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s32_z)))
-svint32_t svsubr_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s64_z)))
-svint64_t svsubr_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s16_z)))
-svint16_t svsubr_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u8)))
-svuint8_t svtbl_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u32)))
-svuint32_t svtbl_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u64)))
-svuint64_t svtbl_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u16)))
-svuint16_t svtbl_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s8)))
-svint8_t svtbl_s8(svint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_f64)))
-svfloat64_t svtbl_f64(svfloat64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_f32)))
-svfloat32_t svtbl_f32(svfloat32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_f16)))
-svfloat16_t svtbl_f16(svfloat16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s32)))
-svint32_t svtbl_s32(svint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s64)))
-svint64_t svtbl_s64(svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s16)))
-svint16_t svtbl_s16(svint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtmad_f64)))
-svfloat64_t svtmad_f64(svfloat64_t, svfloat64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtmad_f32)))
-svfloat32_t svtmad_f32(svfloat32_t, svfloat32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtmad_f16)))
-svfloat16_t svtmad_f16(svfloat16_t, svfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u8)))
-svuint8_t svtrn1_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u32)))
-svuint32_t svtrn1_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u64)))
-svuint64_t svtrn1_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u16)))
-svuint16_t svtrn1_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s8)))
-svint8_t svtrn1_s8(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_f64)))
-svfloat64_t svtrn1_f64(svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_f32)))
-svfloat32_t svtrn1_f32(svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_f16)))
-svfloat16_t svtrn1_f16(svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s32)))
-svint32_t svtrn1_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s64)))
-svint64_t svtrn1_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s16)))
-svint16_t svtrn1_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_b16)))
-svbool_t svtrn1_b16(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_b32)))
-svbool_t svtrn1_b32(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_b64)))
-svbool_t svtrn1_b64(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_b8)))
-svbool_t svtrn1_b8(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u8)))
-svuint8_t svtrn2_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u32)))
-svuint32_t svtrn2_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u64)))
-svuint64_t svtrn2_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u16)))
-svuint16_t svtrn2_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s8)))
-svint8_t svtrn2_s8(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_f64)))
-svfloat64_t svtrn2_f64(svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_f32)))
-svfloat32_t svtrn2_f32(svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_f16)))
-svfloat16_t svtrn2_f16(svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s32)))
-svint32_t svtrn2_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s64)))
-svint64_t svtrn2_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s16)))
-svint16_t svtrn2_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_b16)))
-svbool_t svtrn2_b16(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_b32)))
-svbool_t svtrn2_b32(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_b64)))
-svbool_t svtrn2_b64(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_b8)))
-svbool_t svtrn2_b8(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtsmul_f64)))
-svfloat64_t svtsmul_f64(svfloat64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtsmul_f32)))
-svfloat32_t svtsmul_f32(svfloat32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtsmul_f16)))
-svfloat16_t svtsmul_f16(svfloat16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtssel_f64)))
-svfloat64_t svtssel_f64(svfloat64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtssel_f32)))
-svfloat32_t svtssel_f32(svfloat32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtssel_f16)))
-svfloat16_t svtssel_f16(svfloat16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_u8)))
-svuint8x2_t svundef2_u8(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_u32)))
-svuint32x2_t svundef2_u32(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_u64)))
-svuint64x2_t svundef2_u64(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_u16)))
-svuint16x2_t svundef2_u16(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_s8)))
-svint8x2_t svundef2_s8(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_f64)))
-svfloat64x2_t svundef2_f64(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_f32)))
-svfloat32x2_t svundef2_f32(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_f16)))
-svfloat16x2_t svundef2_f16(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_s32)))
-svint32x2_t svundef2_s32(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_s64)))
-svint64x2_t svundef2_s64(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_s16)))
-svint16x2_t svundef2_s16(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_u8)))
-svuint8x3_t svundef3_u8(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_u32)))
-svuint32x3_t svundef3_u32(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_u64)))
-svuint64x3_t svundef3_u64(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_u16)))
-svuint16x3_t svundef3_u16(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_s8)))
-svint8x3_t svundef3_s8(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_f64)))
-svfloat64x3_t svundef3_f64(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_f32)))
-svfloat32x3_t svundef3_f32(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_f16)))
-svfloat16x3_t svundef3_f16(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_s32)))
-svint32x3_t svundef3_s32(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_s64)))
-svint64x3_t svundef3_s64(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_s16)))
-svint16x3_t svundef3_s16(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_u8)))
-svuint8x4_t svundef4_u8(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_u32)))
-svuint32x4_t svundef4_u32(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_u64)))
-svuint64x4_t svundef4_u64(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_u16)))
-svuint16x4_t svundef4_u16(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_s8)))
-svint8x4_t svundef4_s8(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_f64)))
-svfloat64x4_t svundef4_f64(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_f32)))
-svfloat32x4_t svundef4_f32(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_f16)))
-svfloat16x4_t svundef4_f16(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_s32)))
-svint32x4_t svundef4_s32(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_s64)))
-svint64x4_t svundef4_s64(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_s16)))
-svint16x4_t svundef4_s16(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_u8)))
-svuint8_t svundef_u8(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_u32)))
-svuint32_t svundef_u32(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_u64)))
-svuint64_t svundef_u64(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_u16)))
-svuint16_t svundef_u16(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_s8)))
-svint8_t svundef_s8(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_f64)))
-svfloat64_t svundef_f64(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_f32)))
-svfloat32_t svundef_f32(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_f16)))
-svfloat16_t svundef_f16(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_s32)))
-svint32_t svundef_s32(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_s64)))
-svint64_t svundef_s64(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_s16)))
-svint16_t svundef_s16(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_b)))
-svbool_t svunpkhi_b(svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_s32)))
-svint32_t svunpkhi_s32(svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_s64)))
-svint64_t svunpkhi_s64(svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_s16)))
-svint16_t svunpkhi_s16(svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_u32)))
-svuint32_t svunpkhi_u32(svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_u64)))
-svuint64_t svunpkhi_u64(svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_u16)))
-svuint16_t svunpkhi_u16(svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_b)))
-svbool_t svunpklo_b(svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_s32)))
-svint32_t svunpklo_s32(svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_s64)))
-svint64_t svunpklo_s64(svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_s16)))
-svint16_t svunpklo_s16(svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_u32)))
-svuint32_t svunpklo_u32(svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_u64)))
-svuint64_t svunpklo_u64(svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_u16)))
-svuint16_t svunpklo_u16(svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u8)))
-svuint8_t svuzp1_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u32)))
-svuint32_t svuzp1_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u64)))
-svuint64_t svuzp1_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u16)))
-svuint16_t svuzp1_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s8)))
-svint8_t svuzp1_s8(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_f64)))
-svfloat64_t svuzp1_f64(svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_f32)))
-svfloat32_t svuzp1_f32(svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_f16)))
-svfloat16_t svuzp1_f16(svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s32)))
-svint32_t svuzp1_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s64)))
-svint64_t svuzp1_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s16)))
-svint16_t svuzp1_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_b16)))
-svbool_t svuzp1_b16(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_b32)))
-svbool_t svuzp1_b32(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_b64)))
-svbool_t svuzp1_b64(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_b8)))
-svbool_t svuzp1_b8(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u8)))
-svuint8_t svuzp2_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u32)))
-svuint32_t svuzp2_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u64)))
-svuint64_t svuzp2_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u16)))
-svuint16_t svuzp2_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s8)))
-svint8_t svuzp2_s8(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_f64)))
-svfloat64_t svuzp2_f64(svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_f32)))
-svfloat32_t svuzp2_f32(svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_f16)))
-svfloat16_t svuzp2_f16(svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s32)))
-svint32_t svuzp2_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s64)))
-svint64_t svuzp2_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s16)))
-svint16_t svuzp2_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_b16)))
-svbool_t svuzp2_b16(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_b32)))
-svbool_t svuzp2_b32(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_b64)))
-svbool_t svuzp2_b64(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_b8)))
-svbool_t svuzp2_b8(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_s32)))
-svbool_t svwhilele_b8_s32(int32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_s32)))
-svbool_t svwhilele_b32_s32(int32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_s32)))
-svbool_t svwhilele_b64_s32(int32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_s32)))
-svbool_t svwhilele_b16_s32(int32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_s64)))
-svbool_t svwhilele_b8_s64(int64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_s64)))
-svbool_t svwhilele_b32_s64(int64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_s64)))
-svbool_t svwhilele_b64_s64(int64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_s64)))
-svbool_t svwhilele_b16_s64(int64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_u32)))
-svbool_t svwhilele_b8_u32(uint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_u32)))
-svbool_t svwhilele_b32_u32(uint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_u32)))
-svbool_t svwhilele_b64_u32(uint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_u32)))
-svbool_t svwhilele_b16_u32(uint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_u64)))
-svbool_t svwhilele_b8_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_u64)))
-svbool_t svwhilele_b32_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_u64)))
-svbool_t svwhilele_b64_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_u64)))
-svbool_t svwhilele_b16_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_u32)))
-svbool_t svwhilelt_b8_u32(uint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_u32)))
-svbool_t svwhilelt_b32_u32(uint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_u32)))
-svbool_t svwhilelt_b64_u32(uint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_u32)))
-svbool_t svwhilelt_b16_u32(uint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_u64)))
-svbool_t svwhilelt_b8_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_u64)))
-svbool_t svwhilelt_b32_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_u64)))
-svbool_t svwhilelt_b64_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_u64)))
-svbool_t svwhilelt_b16_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_s32)))
-svbool_t svwhilelt_b8_s32(int32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_s32)))
-svbool_t svwhilelt_b32_s32(int32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_s32)))
-svbool_t svwhilelt_b64_s32(int32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_s32)))
-svbool_t svwhilelt_b16_s32(int32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_s64)))
-svbool_t svwhilelt_b8_s64(int64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_s64)))
-svbool_t svwhilelt_b32_s64(int64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_s64)))
-svbool_t svwhilelt_b64_s64(int64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_s64)))
-svbool_t svwhilelt_b16_s64(int64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwrffr)))
-void svwrffr(svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u8)))
-svuint8_t svzip1_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u32)))
-svuint32_t svzip1_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u64)))
-svuint64_t svzip1_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u16)))
-svuint16_t svzip1_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s8)))
-svint8_t svzip1_s8(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_f64)))
-svfloat64_t svzip1_f64(svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_f32)))
-svfloat32_t svzip1_f32(svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_f16)))
-svfloat16_t svzip1_f16(svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s32)))
-svint32_t svzip1_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s64)))
-svint64_t svzip1_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s16)))
-svint16_t svzip1_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_b16)))
-svbool_t svzip1_b16(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_b32)))
-svbool_t svzip1_b32(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_b64)))
-svbool_t svzip1_b64(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_b8)))
-svbool_t svzip1_b8(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u8)))
-svuint8_t svzip2_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u32)))
-svuint32_t svzip2_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u64)))
-svuint64_t svzip2_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u16)))
-svuint16_t svzip2_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s8)))
-svint8_t svzip2_s8(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_f64)))
-svfloat64_t svzip2_f64(svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_f32)))
-svfloat32_t svzip2_f32(svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_f16)))
-svfloat16_t svzip2_f16(svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s32)))
-svint32_t svzip2_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s64)))
-svint64_t svzip2_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s16)))
-svint16_t svzip2_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_b16)))
-svbool_t svzip2_b16(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_b32)))
-svbool_t svzip2_b32(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_b64)))
-svbool_t svzip2_b64(svbool_t, svbool_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_b8)))
-svbool_t svzip2_b8(svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f64_m)))
-svfloat64_t svabd_m(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f32_m)))
-svfloat32_t svabd_m(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f16_m)))
-svfloat16_t svabd_m(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f64_x)))
-svfloat64_t svabd_x(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f32_x)))
-svfloat32_t svabd_x(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f16_x)))
-svfloat16_t svabd_x(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f64_z)))
-svfloat64_t svabd_z(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f32_z)))
-svfloat32_t svabd_z(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f16_z)))
-svfloat16_t svabd_z(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s8_m)))
-svint8_t svabd_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s32_m)))
-svint32_t svabd_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s64_m)))
-svint64_t svabd_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s16_m)))
-svint16_t svabd_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s8_x)))
-svint8_t svabd_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s32_x)))
-svint32_t svabd_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s64_x)))
-svint64_t svabd_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s16_x)))
-svint16_t svabd_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s8_z)))
-svint8_t svabd_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s32_z)))
-svint32_t svabd_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s64_z)))
-svint64_t svabd_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s16_z)))
-svint16_t svabd_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u8_m)))
-svuint8_t svabd_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u32_m)))
-svuint32_t svabd_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u64_m)))
-svuint64_t svabd_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u16_m)))
-svuint16_t svabd_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u8_x)))
-svuint8_t svabd_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u32_x)))
-svuint32_t svabd_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u64_x)))
-svuint64_t svabd_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u16_x)))
-svuint16_t svabd_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u8_z)))
-svuint8_t svabd_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u32_z)))
-svuint32_t svabd_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u64_z)))
-svuint64_t svabd_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u16_z)))
-svuint16_t svabd_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f64_m)))
-svfloat64_t svabd_m(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f32_m)))
-svfloat32_t svabd_m(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f16_m)))
-svfloat16_t svabd_m(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f64_x)))
-svfloat64_t svabd_x(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f32_x)))
-svfloat32_t svabd_x(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f16_x)))
-svfloat16_t svabd_x(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f64_z)))
-svfloat64_t svabd_z(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f32_z)))
-svfloat32_t svabd_z(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f16_z)))
-svfloat16_t svabd_z(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s8_m)))
-svint8_t svabd_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s32_m)))
-svint32_t svabd_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s64_m)))
-svint64_t svabd_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s16_m)))
-svint16_t svabd_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s8_x)))
-svint8_t svabd_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s32_x)))
-svint32_t svabd_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s64_x)))
-svint64_t svabd_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s16_x)))
-svint16_t svabd_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s8_z)))
-svint8_t svabd_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s32_z)))
-svint32_t svabd_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s64_z)))
-svint64_t svabd_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s16_z)))
-svint16_t svabd_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u8_m)))
-svuint8_t svabd_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u32_m)))
-svuint32_t svabd_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u64_m)))
-svuint64_t svabd_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u16_m)))
-svuint16_t svabd_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u8_x)))
-svuint8_t svabd_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u32_x)))
-svuint32_t svabd_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u64_x)))
-svuint64_t svabd_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u16_x)))
-svuint16_t svabd_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u8_z)))
-svuint8_t svabd_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u32_z)))
-svuint32_t svabd_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u64_z)))
-svuint64_t svabd_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u16_z)))
-svuint16_t svabd_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f64_m)))
-svfloat64_t svabs_m(svfloat64_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f32_m)))
-svfloat32_t svabs_m(svfloat32_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f16_m)))
-svfloat16_t svabs_m(svfloat16_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f64_x)))
-svfloat64_t svabs_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f32_x)))
-svfloat32_t svabs_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f16_x)))
-svfloat16_t svabs_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f64_z)))
-svfloat64_t svabs_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f32_z)))
-svfloat32_t svabs_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f16_z)))
-svfloat16_t svabs_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s8_m)))
-svint8_t svabs_m(svint8_t, svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s32_m)))
-svint32_t svabs_m(svint32_t, svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s64_m)))
-svint64_t svabs_m(svint64_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s16_m)))
-svint16_t svabs_m(svint16_t, svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s8_x)))
-svint8_t svabs_x(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s32_x)))
-svint32_t svabs_x(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s64_x)))
-svint64_t svabs_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s16_x)))
-svint16_t svabs_x(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s8_z)))
-svint8_t svabs_z(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s32_z)))
-svint32_t svabs_z(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s64_z)))
-svint64_t svabs_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s16_z)))
-svint16_t svabs_z(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_n_f64)))
-svbool_t svacge(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_n_f32)))
-svbool_t svacge(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_n_f16)))
-svbool_t svacge(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_f64)))
-svbool_t svacge(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_f32)))
-svbool_t svacge(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_f16)))
-svbool_t svacge(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_n_f64)))
-svbool_t svacgt(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_n_f32)))
-svbool_t svacgt(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_n_f16)))
-svbool_t svacgt(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_f64)))
-svbool_t svacgt(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_f32)))
-svbool_t svacgt(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_f16)))
-svbool_t svacgt(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_n_f64)))
-svbool_t svacle(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_n_f32)))
-svbool_t svacle(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_n_f16)))
-svbool_t svacle(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_f64)))
-svbool_t svacle(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_f32)))
-svbool_t svacle(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_f16)))
-svbool_t svacle(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_n_f64)))
-svbool_t svaclt(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_n_f32)))
-svbool_t svaclt(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_n_f16)))
-svbool_t svaclt(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_f64)))
-svbool_t svaclt(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_f32)))
-svbool_t svaclt(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_f16)))
-svbool_t svaclt(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f64_m)))
-svfloat64_t svadd_m(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f32_m)))
-svfloat32_t svadd_m(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f16_m)))
-svfloat16_t svadd_m(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f64_x)))
-svfloat64_t svadd_x(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f32_x)))
-svfloat32_t svadd_x(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f16_x)))
-svfloat16_t svadd_x(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f64_z)))
-svfloat64_t svadd_z(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f32_z)))
-svfloat32_t svadd_z(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f16_z)))
-svfloat16_t svadd_z(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u8_m)))
-svuint8_t svadd_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u32_m)))
-svuint32_t svadd_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u64_m)))
-svuint64_t svadd_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u16_m)))
-svuint16_t svadd_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s8_m)))
-svint8_t svadd_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s32_m)))
-svint32_t svadd_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s64_m)))
-svint64_t svadd_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s16_m)))
-svint16_t svadd_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u8_x)))
-svuint8_t svadd_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u32_x)))
-svuint32_t svadd_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u64_x)))
-svuint64_t svadd_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u16_x)))
-svuint16_t svadd_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s8_x)))
-svint8_t svadd_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s32_x)))
-svint32_t svadd_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s64_x)))
-svint64_t svadd_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s16_x)))
-svint16_t svadd_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u8_z)))
-svuint8_t svadd_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u32_z)))
-svuint32_t svadd_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u64_z)))
-svuint64_t svadd_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u16_z)))
-svuint16_t svadd_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s8_z)))
-svint8_t svadd_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s32_z)))
-svint32_t svadd_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s64_z)))
-svint64_t svadd_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s16_z)))
-svint16_t svadd_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f64_m)))
-svfloat64_t svadd_m(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f32_m)))
-svfloat32_t svadd_m(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f16_m)))
-svfloat16_t svadd_m(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f64_x)))
-svfloat64_t svadd_x(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f32_x)))
-svfloat32_t svadd_x(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f16_x)))
-svfloat16_t svadd_x(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f64_z)))
-svfloat64_t svadd_z(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f32_z)))
-svfloat32_t svadd_z(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f16_z)))
-svfloat16_t svadd_z(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u8_m)))
-svuint8_t svadd_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u32_m)))
-svuint32_t svadd_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u64_m)))
-svuint64_t svadd_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u16_m)))
-svuint16_t svadd_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s8_m)))
-svint8_t svadd_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s32_m)))
-svint32_t svadd_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s64_m)))
-svint64_t svadd_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s16_m)))
-svint16_t svadd_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u8_x)))
-svuint8_t svadd_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u32_x)))
-svuint32_t svadd_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u64_x)))
-svuint64_t svadd_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u16_x)))
-svuint16_t svadd_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s8_x)))
-svint8_t svadd_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s32_x)))
-svint32_t svadd_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s64_x)))
-svint64_t svadd_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s16_x)))
-svint16_t svadd_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u8_z)))
-svuint8_t svadd_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u32_z)))
-svuint32_t svadd_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u64_z)))
-svuint64_t svadd_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u16_z)))
-svuint16_t svadd_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s8_z)))
-svint8_t svadd_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s32_z)))
-svint32_t svadd_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s64_z)))
-svint64_t svadd_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s16_z)))
-svint16_t svadd_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadda_f64)))
-float64_t svadda(svbool_t, float64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadda_f32)))
-float32_t svadda(svbool_t, float32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadda_f16)))
-float16_t svadda(svbool_t, float16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s8)))
-int64_t svaddv(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s32)))
-int64_t svaddv(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s64)))
-int64_t svaddv(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s16)))
-int64_t svaddv(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u8)))
-uint64_t svaddv(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u32)))
-uint64_t svaddv(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u64)))
-uint64_t svaddv(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u16)))
-uint64_t svaddv(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_f64)))
-float64_t svaddv(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_f32)))
-float32_t svaddv(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_f16)))
-float16_t svaddv(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u32base_u32offset)))
-svuint32_t svadrb_offset(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u64base_u64offset)))
-svuint64_t svadrb_offset(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u32base_s32offset)))
-svuint32_t svadrb_offset(svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u64base_s64offset)))
-svuint64_t svadrb_offset(svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u32base_u32index)))
-svuint32_t svadrd_index(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u64base_u64index)))
-svuint64_t svadrd_index(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u32base_s32index)))
-svuint32_t svadrd_index(svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u64base_s64index)))
-svuint64_t svadrd_index(svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u32base_u32index)))
-svuint32_t svadrh_index(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u64base_u64index)))
-svuint64_t svadrh_index(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u32base_s32index)))
-svuint32_t svadrh_index(svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u64base_s64index)))
-svuint64_t svadrh_index(svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u32base_u32index)))
-svuint32_t svadrw_index(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u64base_u64index)))
-svuint64_t svadrw_index(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u32base_s32index)))
-svuint32_t svadrw_index(svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u64base_s64index)))
-svuint64_t svadrw_index(svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_b_z)))
-svbool_t svand_z(svbool_t, svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u8_m)))
-svuint8_t svand_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u32_m)))
-svuint32_t svand_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u64_m)))
-svuint64_t svand_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u16_m)))
-svuint16_t svand_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s8_m)))
-svint8_t svand_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s32_m)))
-svint32_t svand_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s64_m)))
-svint64_t svand_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s16_m)))
-svint16_t svand_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u8_x)))
-svuint8_t svand_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u32_x)))
-svuint32_t svand_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u64_x)))
-svuint64_t svand_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u16_x)))
-svuint16_t svand_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s8_x)))
-svint8_t svand_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s32_x)))
-svint32_t svand_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s64_x)))
-svint64_t svand_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s16_x)))
-svint16_t svand_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u8_z)))
-svuint8_t svand_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u32_z)))
-svuint32_t svand_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u64_z)))
-svuint64_t svand_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u16_z)))
-svuint16_t svand_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s8_z)))
-svint8_t svand_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s32_z)))
-svint32_t svand_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s64_z)))
-svint64_t svand_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s16_z)))
-svint16_t svand_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u8_m)))
-svuint8_t svand_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u32_m)))
-svuint32_t svand_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u64_m)))
-svuint64_t svand_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u16_m)))
-svuint16_t svand_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s8_m)))
-svint8_t svand_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s32_m)))
-svint32_t svand_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s64_m)))
-svint64_t svand_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s16_m)))
-svint16_t svand_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u8_x)))
-svuint8_t svand_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u32_x)))
-svuint32_t svand_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u64_x)))
-svuint64_t svand_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u16_x)))
-svuint16_t svand_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s8_x)))
-svint8_t svand_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s32_x)))
-svint32_t svand_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s64_x)))
-svint64_t svand_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s16_x)))
-svint16_t svand_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u8_z)))
-svuint8_t svand_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u32_z)))
-svuint32_t svand_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u64_z)))
-svuint64_t svand_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u16_z)))
-svuint16_t svand_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s8_z)))
-svint8_t svand_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s32_z)))
-svint32_t svand_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s64_z)))
-svint64_t svand_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s16_z)))
-svint16_t svand_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u8)))
-uint8_t svandv(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u32)))
-uint32_t svandv(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u64)))
-uint64_t svandv(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u16)))
-uint16_t svandv(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s8)))
-int8_t svandv(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s32)))
-int32_t svandv(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s64)))
-int64_t svandv(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s16)))
-int16_t svandv(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s8_m)))
-svint8_t svasr_m(svbool_t, svint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s32_m)))
-svint32_t svasr_m(svbool_t, svint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s64_m)))
-svint64_t svasr_m(svbool_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s16_m)))
-svint16_t svasr_m(svbool_t, svint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s8_x)))
-svint8_t svasr_x(svbool_t, svint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s32_x)))
-svint32_t svasr_x(svbool_t, svint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s64_x)))
-svint64_t svasr_x(svbool_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s16_x)))
-svint16_t svasr_x(svbool_t, svint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s8_z)))
-svint8_t svasr_z(svbool_t, svint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s32_z)))
-svint32_t svasr_z(svbool_t, svint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s64_z)))
-svint64_t svasr_z(svbool_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s16_z)))
-svint16_t svasr_z(svbool_t, svint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s8_m)))
-svint8_t svasr_m(svbool_t, svint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s32_m)))
-svint32_t svasr_m(svbool_t, svint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s64_m)))
-svint64_t svasr_m(svbool_t, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s16_m)))
-svint16_t svasr_m(svbool_t, svint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s8_x)))
-svint8_t svasr_x(svbool_t, svint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s32_x)))
-svint32_t svasr_x(svbool_t, svint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s64_x)))
-svint64_t svasr_x(svbool_t, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s16_x)))
-svint16_t svasr_x(svbool_t, svint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s8_z)))
-svint8_t svasr_z(svbool_t, svint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s32_z)))
-svint32_t svasr_z(svbool_t, svint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s64_z)))
-svint64_t svasr_z(svbool_t, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s16_z)))
-svint16_t svasr_z(svbool_t, svint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s8_m)))
-svint8_t svasr_wide_m(svbool_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s32_m)))
-svint32_t svasr_wide_m(svbool_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s16_m)))
-svint16_t svasr_wide_m(svbool_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s8_x)))
-svint8_t svasr_wide_x(svbool_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s32_x)))
-svint32_t svasr_wide_x(svbool_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s16_x)))
-svint16_t svasr_wide_x(svbool_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s8_z)))
-svint8_t svasr_wide_z(svbool_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s32_z)))
-svint32_t svasr_wide_z(svbool_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s16_z)))
-svint16_t svasr_wide_z(svbool_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s8_m)))
-svint8_t svasr_wide_m(svbool_t, svint8_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s32_m)))
-svint32_t svasr_wide_m(svbool_t, svint32_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s16_m)))
-svint16_t svasr_wide_m(svbool_t, svint16_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s8_x)))
-svint8_t svasr_wide_x(svbool_t, svint8_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s32_x)))
-svint32_t svasr_wide_x(svbool_t, svint32_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s16_x)))
-svint16_t svasr_wide_x(svbool_t, svint16_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s8_z)))
-svint8_t svasr_wide_z(svbool_t, svint8_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s32_z)))
-svint32_t svasr_wide_z(svbool_t, svint32_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s16_z)))
-svint16_t svasr_wide_z(svbool_t, svint16_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s8_m)))
-svint8_t svasrd_m(svbool_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s32_m)))
-svint32_t svasrd_m(svbool_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s64_m)))
-svint64_t svasrd_m(svbool_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s16_m)))
-svint16_t svasrd_m(svbool_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s8_x)))
-svint8_t svasrd_x(svbool_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s32_x)))
-svint32_t svasrd_x(svbool_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s64_x)))
-svint64_t svasrd_x(svbool_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s16_x)))
-svint16_t svasrd_x(svbool_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s8_z)))
-svint8_t svasrd_z(svbool_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s32_z)))
-svint32_t svasrd_z(svbool_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s64_z)))
-svint64_t svasrd_z(svbool_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s16_z)))
-svint16_t svasrd_z(svbool_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_b_z)))
-svbool_t svbic_z(svbool_t, svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u8_m)))
-svuint8_t svbic_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u32_m)))
-svuint32_t svbic_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u64_m)))
-svuint64_t svbic_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u16_m)))
-svuint16_t svbic_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s8_m)))
-svint8_t svbic_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s32_m)))
-svint32_t svbic_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s64_m)))
-svint64_t svbic_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s16_m)))
-svint16_t svbic_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u8_x)))
-svuint8_t svbic_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u32_x)))
-svuint32_t svbic_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u64_x)))
-svuint64_t svbic_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u16_x)))
-svuint16_t svbic_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s8_x)))
-svint8_t svbic_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s32_x)))
-svint32_t svbic_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s64_x)))
-svint64_t svbic_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s16_x)))
-svint16_t svbic_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u8_z)))
-svuint8_t svbic_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u32_z)))
-svuint32_t svbic_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u64_z)))
-svuint64_t svbic_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u16_z)))
-svuint16_t svbic_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s8_z)))
-svint8_t svbic_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s32_z)))
-svint32_t svbic_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s64_z)))
-svint64_t svbic_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s16_z)))
-svint16_t svbic_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u8_m)))
-svuint8_t svbic_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u32_m)))
-svuint32_t svbic_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u64_m)))
-svuint64_t svbic_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u16_m)))
-svuint16_t svbic_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s8_m)))
-svint8_t svbic_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s32_m)))
-svint32_t svbic_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s64_m)))
-svint64_t svbic_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s16_m)))
-svint16_t svbic_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u8_x)))
-svuint8_t svbic_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u32_x)))
-svuint32_t svbic_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u64_x)))
-svuint64_t svbic_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u16_x)))
-svuint16_t svbic_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s8_x)))
-svint8_t svbic_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s32_x)))
-svint32_t svbic_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s64_x)))
-svint64_t svbic_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s16_x)))
-svint16_t svbic_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u8_z)))
-svuint8_t svbic_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u32_z)))
-svuint32_t svbic_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u64_z)))
-svuint64_t svbic_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u16_z)))
-svuint16_t svbic_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s8_z)))
-svint8_t svbic_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s32_z)))
-svint32_t svbic_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s64_z)))
-svint64_t svbic_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s16_z)))
-svint16_t svbic_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrka_b_m)))
-svbool_t svbrka_m(svbool_t, svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrka_b_z)))
-svbool_t svbrka_z(svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkb_b_m)))
-svbool_t svbrkb_m(svbool_t, svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkb_b_z)))
-svbool_t svbrkb_z(svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkn_b_z)))
-svbool_t svbrkn_z(svbool_t, svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkpa_b_z)))
-svbool_t svbrkpa_z(svbool_t, svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkpb_b_z)))
-svbool_t svbrkpb_z(svbool_t, svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f64_m)))
-svfloat64_t svcadd_m(svbool_t, svfloat64_t, svfloat64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f32_m)))
-svfloat32_t svcadd_m(svbool_t, svfloat32_t, svfloat32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f16_m)))
-svfloat16_t svcadd_m(svbool_t, svfloat16_t, svfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f64_x)))
-svfloat64_t svcadd_x(svbool_t, svfloat64_t, svfloat64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f32_x)))
-svfloat32_t svcadd_x(svbool_t, svfloat32_t, svfloat32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f16_x)))
-svfloat16_t svcadd_x(svbool_t, svfloat16_t, svfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f64_z)))
-svfloat64_t svcadd_z(svbool_t, svfloat64_t, svfloat64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f32_z)))
-svfloat32_t svcadd_z(svbool_t, svfloat32_t, svfloat32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f16_z)))
-svfloat16_t svcadd_z(svbool_t, svfloat16_t, svfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u8)))
-uint8_t svclasta(svbool_t, uint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u32)))
-uint32_t svclasta(svbool_t, uint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u64)))
-uint64_t svclasta(svbool_t, uint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u16)))
-uint16_t svclasta(svbool_t, uint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s8)))
-int8_t svclasta(svbool_t, int8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_f64)))
-float64_t svclasta(svbool_t, float64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_f32)))
-float32_t svclasta(svbool_t, float32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_f16)))
-float16_t svclasta(svbool_t, float16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s32)))
-int32_t svclasta(svbool_t, int32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s64)))
-int64_t svclasta(svbool_t, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s16)))
-int16_t svclasta(svbool_t, int16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u8)))
-svuint8_t svclasta(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u32)))
-svuint32_t svclasta(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u64)))
-svuint64_t svclasta(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u16)))
-svuint16_t svclasta(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s8)))
-svint8_t svclasta(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_f64)))
-svfloat64_t svclasta(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_f32)))
-svfloat32_t svclasta(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_f16)))
-svfloat16_t svclasta(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s32)))
-svint32_t svclasta(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s64)))
-svint64_t svclasta(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s16)))
-svint16_t svclasta(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u8)))
-uint8_t svclastb(svbool_t, uint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u32)))
-uint32_t svclastb(svbool_t, uint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u64)))
-uint64_t svclastb(svbool_t, uint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u16)))
-uint16_t svclastb(svbool_t, uint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s8)))
-int8_t svclastb(svbool_t, int8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_f64)))
-float64_t svclastb(svbool_t, float64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_f32)))
-float32_t svclastb(svbool_t, float32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_f16)))
-float16_t svclastb(svbool_t, float16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s32)))
-int32_t svclastb(svbool_t, int32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s64)))
-int64_t svclastb(svbool_t, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s16)))
-int16_t svclastb(svbool_t, int16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u8)))
-svuint8_t svclastb(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u32)))
-svuint32_t svclastb(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u64)))
-svuint64_t svclastb(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u16)))
-svuint16_t svclastb(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s8)))
-svint8_t svclastb(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_f64)))
-svfloat64_t svclastb(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_f32)))
-svfloat32_t svclastb(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_f16)))
-svfloat16_t svclastb(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s32)))
-svint32_t svclastb(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s64)))
-svint64_t svclastb(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s16)))
-svint16_t svclastb(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s8_m)))
-svuint8_t svcls_m(svuint8_t, svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s32_m)))
-svuint32_t svcls_m(svuint32_t, svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s64_m)))
-svuint64_t svcls_m(svuint64_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s16_m)))
-svuint16_t svcls_m(svuint16_t, svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s8_x)))
-svuint8_t svcls_x(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s32_x)))
-svuint32_t svcls_x(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s64_x)))
-svuint64_t svcls_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s16_x)))
-svuint16_t svcls_x(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s8_z)))
-svuint8_t svcls_z(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s32_z)))
-svuint32_t svcls_z(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s64_z)))
-svuint64_t svcls_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s16_z)))
-svuint16_t svcls_z(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u8_m)))
-svuint8_t svclz_m(svuint8_t, svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u32_m)))
-svuint32_t svclz_m(svuint32_t, svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u64_m)))
-svuint64_t svclz_m(svuint64_t, svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u16_m)))
-svuint16_t svclz_m(svuint16_t, svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s8_m)))
-svuint8_t svclz_m(svuint8_t, svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s32_m)))
-svuint32_t svclz_m(svuint32_t, svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s64_m)))
-svuint64_t svclz_m(svuint64_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s16_m)))
-svuint16_t svclz_m(svuint16_t, svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u8_x)))
-svuint8_t svclz_x(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u32_x)))
-svuint32_t svclz_x(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u64_x)))
-svuint64_t svclz_x(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u16_x)))
-svuint16_t svclz_x(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s8_x)))
-svuint8_t svclz_x(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s32_x)))
-svuint32_t svclz_x(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s64_x)))
-svuint64_t svclz_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s16_x)))
-svuint16_t svclz_x(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u8_z)))
-svuint8_t svclz_z(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u32_z)))
-svuint32_t svclz_z(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u64_z)))
-svuint64_t svclz_z(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u16_z)))
-svuint16_t svclz_z(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s8_z)))
-svuint8_t svclz_z(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s32_z)))
-svuint32_t svclz_z(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s64_z)))
-svuint64_t svclz_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s16_z)))
-svuint16_t svclz_z(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f64_m)))
-svfloat64_t svcmla_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f32_m)))
-svfloat32_t svcmla_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f16_m)))
-svfloat16_t svcmla_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f64_x)))
-svfloat64_t svcmla_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f32_x)))
-svfloat32_t svcmla_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f16_x)))
-svfloat16_t svcmla_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f64_z)))
-svfloat64_t svcmla_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f32_z)))
-svfloat32_t svcmla_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f16_z)))
-svfloat16_t svcmla_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_f32)))
-svfloat32_t svcmla_lane(svfloat32_t, svfloat32_t, svfloat32_t, uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_f16)))
-svfloat16_t svcmla_lane(svfloat16_t, svfloat16_t, svfloat16_t, uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_f64)))
-svbool_t svcmpeq(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_f32)))
-svbool_t svcmpeq(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_f16)))
-svbool_t svcmpeq(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u8)))
-svbool_t svcmpeq(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u32)))
-svbool_t svcmpeq(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u64)))
-svbool_t svcmpeq(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u16)))
-svbool_t svcmpeq(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s8)))
-svbool_t svcmpeq(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s32)))
-svbool_t svcmpeq(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s64)))
-svbool_t svcmpeq(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s16)))
-svbool_t svcmpeq(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u8)))
-svbool_t svcmpeq(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u32)))
-svbool_t svcmpeq(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u64)))
-svbool_t svcmpeq(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u16)))
-svbool_t svcmpeq(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s8)))
-svbool_t svcmpeq(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s32)))
-svbool_t svcmpeq(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s64)))
-svbool_t svcmpeq(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s16)))
-svbool_t svcmpeq(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_f64)))
-svbool_t svcmpeq(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_f32)))
-svbool_t svcmpeq(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_f16)))
-svbool_t svcmpeq(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_n_s8)))
-svbool_t svcmpeq_wide(svbool_t, svint8_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_n_s32)))
-svbool_t svcmpeq_wide(svbool_t, svint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_n_s16)))
-svbool_t svcmpeq_wide(svbool_t, svint16_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_s8)))
-svbool_t svcmpeq_wide(svbool_t, svint8_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_s32)))
-svbool_t svcmpeq_wide(svbool_t, svint32_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_s16)))
-svbool_t svcmpeq_wide(svbool_t, svint16_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_f64)))
-svbool_t svcmpge(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_f32)))
-svbool_t svcmpge(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_f16)))
-svbool_t svcmpge(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s8)))
-svbool_t svcmpge(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s32)))
-svbool_t svcmpge(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s64)))
-svbool_t svcmpge(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s16)))
-svbool_t svcmpge(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u8)))
-svbool_t svcmpge(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u32)))
-svbool_t svcmpge(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u64)))
-svbool_t svcmpge(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u16)))
-svbool_t svcmpge(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s8)))
-svbool_t svcmpge(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s32)))
-svbool_t svcmpge(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s64)))
-svbool_t svcmpge(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s16)))
-svbool_t svcmpge(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_f64)))
-svbool_t svcmpge(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_f32)))
-svbool_t svcmpge(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_f16)))
-svbool_t svcmpge(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u8)))
-svbool_t svcmpge(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u32)))
-svbool_t svcmpge(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u64)))
-svbool_t svcmpge(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u16)))
-svbool_t svcmpge(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_s8)))
-svbool_t svcmpge_wide(svbool_t, svint8_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_s32)))
-svbool_t svcmpge_wide(svbool_t, svint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_s16)))
-svbool_t svcmpge_wide(svbool_t, svint16_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_u8)))
-svbool_t svcmpge_wide(svbool_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_u32)))
-svbool_t svcmpge_wide(svbool_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_u16)))
-svbool_t svcmpge_wide(svbool_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_s8)))
-svbool_t svcmpge_wide(svbool_t, svint8_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_s32)))
-svbool_t svcmpge_wide(svbool_t, svint32_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_s16)))
-svbool_t svcmpge_wide(svbool_t, svint16_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_u8)))
-svbool_t svcmpge_wide(svbool_t, svuint8_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_u32)))
-svbool_t svcmpge_wide(svbool_t, svuint32_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_u16)))
-svbool_t svcmpge_wide(svbool_t, svuint16_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_f64)))
-svbool_t svcmpgt(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_f32)))
-svbool_t svcmpgt(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_f16)))
-svbool_t svcmpgt(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s8)))
-svbool_t svcmpgt(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s32)))
-svbool_t svcmpgt(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s64)))
-svbool_t svcmpgt(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s16)))
-svbool_t svcmpgt(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u8)))
-svbool_t svcmpgt(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u32)))
-svbool_t svcmpgt(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u64)))
-svbool_t svcmpgt(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u16)))
-svbool_t svcmpgt(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s8)))
-svbool_t svcmpgt(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s32)))
-svbool_t svcmpgt(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s64)))
-svbool_t svcmpgt(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s16)))
-svbool_t svcmpgt(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_f64)))
-svbool_t svcmpgt(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_f32)))
-svbool_t svcmpgt(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_f16)))
-svbool_t svcmpgt(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u8)))
-svbool_t svcmpgt(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u32)))
-svbool_t svcmpgt(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u64)))
-svbool_t svcmpgt(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u16)))
-svbool_t svcmpgt(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_s8)))
-svbool_t svcmpgt_wide(svbool_t, svint8_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_s32)))
-svbool_t svcmpgt_wide(svbool_t, svint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_s16)))
-svbool_t svcmpgt_wide(svbool_t, svint16_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_u8)))
-svbool_t svcmpgt_wide(svbool_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_u32)))
-svbool_t svcmpgt_wide(svbool_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_u16)))
-svbool_t svcmpgt_wide(svbool_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_s8)))
-svbool_t svcmpgt_wide(svbool_t, svint8_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_s32)))
-svbool_t svcmpgt_wide(svbool_t, svint32_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_s16)))
-svbool_t svcmpgt_wide(svbool_t, svint16_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_u8)))
-svbool_t svcmpgt_wide(svbool_t, svuint8_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_u32)))
-svbool_t svcmpgt_wide(svbool_t, svuint32_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_u16)))
-svbool_t svcmpgt_wide(svbool_t, svuint16_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_f64)))
-svbool_t svcmple(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_f32)))
-svbool_t svcmple(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_f16)))
-svbool_t svcmple(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s8)))
-svbool_t svcmple(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s32)))
-svbool_t svcmple(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s64)))
-svbool_t svcmple(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s16)))
-svbool_t svcmple(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u8)))
-svbool_t svcmple(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u32)))
-svbool_t svcmple(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u64)))
-svbool_t svcmple(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u16)))
-svbool_t svcmple(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s8)))
-svbool_t svcmple(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s32)))
-svbool_t svcmple(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s64)))
-svbool_t svcmple(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s16)))
-svbool_t svcmple(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_f64)))
-svbool_t svcmple(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_f32)))
-svbool_t svcmple(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_f16)))
-svbool_t svcmple(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u8)))
-svbool_t svcmple(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u32)))
-svbool_t svcmple(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u64)))
-svbool_t svcmple(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u16)))
-svbool_t svcmple(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_s8)))
-svbool_t svcmple_wide(svbool_t, svint8_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_s32)))
-svbool_t svcmple_wide(svbool_t, svint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_s16)))
-svbool_t svcmple_wide(svbool_t, svint16_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_u8)))
-svbool_t svcmple_wide(svbool_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_u32)))
-svbool_t svcmple_wide(svbool_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_u16)))
-svbool_t svcmple_wide(svbool_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_s8)))
-svbool_t svcmple_wide(svbool_t, svint8_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_s32)))
-svbool_t svcmple_wide(svbool_t, svint32_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_s16)))
-svbool_t svcmple_wide(svbool_t, svint16_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_u8)))
-svbool_t svcmple_wide(svbool_t, svuint8_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_u32)))
-svbool_t svcmple_wide(svbool_t, svuint32_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_u16)))
-svbool_t svcmple_wide(svbool_t, svuint16_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u8)))
-svbool_t svcmplt(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u32)))
-svbool_t svcmplt(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u64)))
-svbool_t svcmplt(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u16)))
-svbool_t svcmplt(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_f64)))
-svbool_t svcmplt(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_f32)))
-svbool_t svcmplt(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_f16)))
-svbool_t svcmplt(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s8)))
-svbool_t svcmplt(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s32)))
-svbool_t svcmplt(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s64)))
-svbool_t svcmplt(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s16)))
-svbool_t svcmplt(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u8)))
-svbool_t svcmplt(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u32)))
-svbool_t svcmplt(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u64)))
-svbool_t svcmplt(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u16)))
-svbool_t svcmplt(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s8)))
-svbool_t svcmplt(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s32)))
-svbool_t svcmplt(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s64)))
-svbool_t svcmplt(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s16)))
-svbool_t svcmplt(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f64)))
-svbool_t svcmplt(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f32)))
-svbool_t svcmplt(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f16)))
-svbool_t svcmplt(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_u8)))
-svbool_t svcmplt_wide(svbool_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_u32)))
-svbool_t svcmplt_wide(svbool_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_u16)))
-svbool_t svcmplt_wide(svbool_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_s8)))
-svbool_t svcmplt_wide(svbool_t, svint8_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_s32)))
-svbool_t svcmplt_wide(svbool_t, svint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_s16)))
-svbool_t svcmplt_wide(svbool_t, svint16_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_u8)))
-svbool_t svcmplt_wide(svbool_t, svuint8_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_u32)))
-svbool_t svcmplt_wide(svbool_t, svuint32_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_u16)))
-svbool_t svcmplt_wide(svbool_t, svuint16_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_s8)))
-svbool_t svcmplt_wide(svbool_t, svint8_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_s32)))
-svbool_t svcmplt_wide(svbool_t, svint32_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_s16)))
-svbool_t svcmplt_wide(svbool_t, svint16_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_f64)))
-svbool_t svcmpne(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_f32)))
-svbool_t svcmpne(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_f16)))
-svbool_t svcmpne(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u8)))
-svbool_t svcmpne(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u32)))
-svbool_t svcmpne(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u64)))
-svbool_t svcmpne(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u16)))
-svbool_t svcmpne(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s8)))
-svbool_t svcmpne(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s32)))
-svbool_t svcmpne(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s64)))
-svbool_t svcmpne(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s16)))
-svbool_t svcmpne(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u8)))
-svbool_t svcmpne(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u32)))
-svbool_t svcmpne(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u64)))
-svbool_t svcmpne(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u16)))
-svbool_t svcmpne(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s8)))
-svbool_t svcmpne(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s32)))
-svbool_t svcmpne(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s64)))
-svbool_t svcmpne(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s16)))
-svbool_t svcmpne(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_f64)))
-svbool_t svcmpne(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_f32)))
-svbool_t svcmpne(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_f16)))
-svbool_t svcmpne(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_n_s8)))
-svbool_t svcmpne_wide(svbool_t, svint8_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_n_s32)))
-svbool_t svcmpne_wide(svbool_t, svint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_n_s16)))
-svbool_t svcmpne_wide(svbool_t, svint16_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_s8)))
-svbool_t svcmpne_wide(svbool_t, svint8_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_s32)))
-svbool_t svcmpne_wide(svbool_t, svint32_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_s16)))
-svbool_t svcmpne_wide(svbool_t, svint16_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_n_f64)))
-svbool_t svcmpuo(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_n_f32)))
-svbool_t svcmpuo(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_n_f16)))
-svbool_t svcmpuo(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_f64)))
-svbool_t svcmpuo(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_f32)))
-svbool_t svcmpuo(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_f16)))
-svbool_t svcmpuo(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u8_m)))
-svuint8_t svcnot_m(svuint8_t, svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u32_m)))
-svuint32_t svcnot_m(svuint32_t, svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u64_m)))
-svuint64_t svcnot_m(svuint64_t, svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u16_m)))
-svuint16_t svcnot_m(svuint16_t, svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s8_m)))
-svint8_t svcnot_m(svint8_t, svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s32_m)))
-svint32_t svcnot_m(svint32_t, svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s64_m)))
-svint64_t svcnot_m(svint64_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s16_m)))
-svint16_t svcnot_m(svint16_t, svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u8_x)))
-svuint8_t svcnot_x(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u32_x)))
-svuint32_t svcnot_x(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u64_x)))
-svuint64_t svcnot_x(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u16_x)))
-svuint16_t svcnot_x(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s8_x)))
-svint8_t svcnot_x(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s32_x)))
-svint32_t svcnot_x(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s64_x)))
-svint64_t svcnot_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s16_x)))
-svint16_t svcnot_x(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u8_z)))
-svuint8_t svcnot_z(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u32_z)))
-svuint32_t svcnot_z(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u64_z)))
-svuint64_t svcnot_z(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u16_z)))
-svuint16_t svcnot_z(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s8_z)))
-svint8_t svcnot_z(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s32_z)))
-svint32_t svcnot_z(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s64_z)))
-svint64_t svcnot_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s16_z)))
-svint16_t svcnot_z(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u8_m)))
-svuint8_t svcnt_m(svuint8_t, svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u32_m)))
-svuint32_t svcnt_m(svuint32_t, svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u64_m)))
-svuint64_t svcnt_m(svuint64_t, svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u16_m)))
-svuint16_t svcnt_m(svuint16_t, svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s8_m)))
-svuint8_t svcnt_m(svuint8_t, svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f64_m)))
-svuint64_t svcnt_m(svuint64_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f32_m)))
-svuint32_t svcnt_m(svuint32_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f16_m)))
-svuint16_t svcnt_m(svuint16_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s32_m)))
-svuint32_t svcnt_m(svuint32_t, svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s64_m)))
-svuint64_t svcnt_m(svuint64_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s16_m)))
-svuint16_t svcnt_m(svuint16_t, svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u8_x)))
-svuint8_t svcnt_x(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u32_x)))
-svuint32_t svcnt_x(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u64_x)))
-svuint64_t svcnt_x(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u16_x)))
-svuint16_t svcnt_x(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s8_x)))
-svuint8_t svcnt_x(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f64_x)))
-svuint64_t svcnt_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f32_x)))
-svuint32_t svcnt_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f16_x)))
-svuint16_t svcnt_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s32_x)))
-svuint32_t svcnt_x(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s64_x)))
-svuint64_t svcnt_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s16_x)))
-svuint16_t svcnt_x(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u8_z)))
-svuint8_t svcnt_z(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u32_z)))
-svuint32_t svcnt_z(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u64_z)))
-svuint64_t svcnt_z(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u16_z)))
-svuint16_t svcnt_z(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s8_z)))
-svuint8_t svcnt_z(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f64_z)))
-svuint64_t svcnt_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f32_z)))
-svuint32_t svcnt_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f16_z)))
-svuint16_t svcnt_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s32_z)))
-svuint32_t svcnt_z(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s64_z)))
-svuint64_t svcnt_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s16_z)))
-svuint16_t svcnt_z(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_u32)))
-svuint32_t svcompact(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_u64)))
-svuint64_t svcompact(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_f64)))
-svfloat64_t svcompact(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_f32)))
-svfloat32_t svcompact(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_s32)))
-svint32_t svcompact(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_s64)))
-svint64_t svcompact(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u8)))
-svuint8x2_t svcreate2(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u32)))
-svuint32x2_t svcreate2(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u64)))
-svuint64x2_t svcreate2(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u16)))
-svuint16x2_t svcreate2(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s8)))
-svint8x2_t svcreate2(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_f64)))
-svfloat64x2_t svcreate2(svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_f32)))
-svfloat32x2_t svcreate2(svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_f16)))
-svfloat16x2_t svcreate2(svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s32)))
-svint32x2_t svcreate2(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s64)))
-svint64x2_t svcreate2(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s16)))
-svint16x2_t svcreate2(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u8)))
-svuint8x3_t svcreate3(svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u32)))
-svuint32x3_t svcreate3(svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u64)))
-svuint64x3_t svcreate3(svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u16)))
-svuint16x3_t svcreate3(svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s8)))
-svint8x3_t svcreate3(svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_f64)))
-svfloat64x3_t svcreate3(svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_f32)))
-svfloat32x3_t svcreate3(svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_f16)))
-svfloat16x3_t svcreate3(svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s32)))
-svint32x3_t svcreate3(svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s64)))
-svint64x3_t svcreate3(svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s16)))
-svint16x3_t svcreate3(svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u8)))
-svuint8x4_t svcreate4(svuint8_t, svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u32)))
-svuint32x4_t svcreate4(svuint32_t, svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u64)))
-svuint64x4_t svcreate4(svuint64_t, svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u16)))
-svuint16x4_t svcreate4(svuint16_t, svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s8)))
-svint8x4_t svcreate4(svint8_t, svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_f64)))
-svfloat64x4_t svcreate4(svfloat64_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_f32)))
-svfloat32x4_t svcreate4(svfloat32_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_f16)))
-svfloat16x4_t svcreate4(svfloat16_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s32)))
-svint32x4_t svcreate4(svint32_t, svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s64)))
-svint64x4_t svcreate4(svint64_t, svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s16)))
-svint16x4_t svcreate4(svint16_t, svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_m)))
-svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_x)))
-svfloat16_t svcvt_f16_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_z)))
-svfloat16_t svcvt_f16_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f64_m)))
-svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f64_x)))
-svfloat16_t svcvt_f16_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f64_z)))
-svfloat16_t svcvt_f16_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s16_m)))
-svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s16_x)))
-svfloat16_t svcvt_f16_x(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s16_z)))
-svfloat16_t svcvt_f16_z(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s32_m)))
-svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s32_x)))
-svfloat16_t svcvt_f16_x(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s32_z)))
-svfloat16_t svcvt_f16_z(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s64_m)))
-svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s64_x)))
-svfloat16_t svcvt_f16_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s64_z)))
-svfloat16_t svcvt_f16_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u16_m)))
-svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u16_x)))
-svfloat16_t svcvt_f16_x(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u16_z)))
-svfloat16_t svcvt_f16_z(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u32_m)))
-svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u32_x)))
-svfloat16_t svcvt_f16_x(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u32_z)))
-svfloat16_t svcvt_f16_z(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u64_m)))
-svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u64_x)))
-svfloat16_t svcvt_f16_x(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u64_z)))
-svfloat16_t svcvt_f16_z(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_m)))
-svfloat32_t svcvt_f32_m(svfloat32_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_x)))
-svfloat32_t svcvt_f32_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_z)))
-svfloat32_t svcvt_f32_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f64_m)))
-svfloat32_t svcvt_f32_m(svfloat32_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f64_x)))
-svfloat32_t svcvt_f32_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f64_z)))
-svfloat32_t svcvt_f32_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_m)))
-svfloat32_t svcvt_f32_m(svfloat32_t, svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_x)))
-svfloat32_t svcvt_f32_x(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_z)))
-svfloat32_t svcvt_f32_z(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s64_m)))
-svfloat32_t svcvt_f32_m(svfloat32_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s64_x)))
-svfloat32_t svcvt_f32_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s64_z)))
-svfloat32_t svcvt_f32_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_m)))
-svfloat32_t svcvt_f32_m(svfloat32_t, svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_x)))
-svfloat32_t svcvt_f32_x(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_z)))
-svfloat32_t svcvt_f32_z(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u64_m)))
-svfloat32_t svcvt_f32_m(svfloat32_t, svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u64_x)))
-svfloat32_t svcvt_f32_x(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u64_z)))
-svfloat32_t svcvt_f32_z(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f16_m)))
-svfloat64_t svcvt_f64_m(svfloat64_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f16_x)))
-svfloat64_t svcvt_f64_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f16_z)))
-svfloat64_t svcvt_f64_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f32_m)))
-svfloat64_t svcvt_f64_m(svfloat64_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f32_x)))
-svfloat64_t svcvt_f64_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f32_z)))
-svfloat64_t svcvt_f64_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s32_m)))
-svfloat64_t svcvt_f64_m(svfloat64_t, svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s32_x)))
-svfloat64_t svcvt_f64_x(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s32_z)))
-svfloat64_t svcvt_f64_z(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s64_m)))
-svfloat64_t svcvt_f64_m(svfloat64_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s64_x)))
-svfloat64_t svcvt_f64_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s64_z)))
-svfloat64_t svcvt_f64_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u32_m)))
-svfloat64_t svcvt_f64_m(svfloat64_t, svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u32_x)))
-svfloat64_t svcvt_f64_x(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u32_z)))
-svfloat64_t svcvt_f64_z(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u64_m)))
-svfloat64_t svcvt_f64_m(svfloat64_t, svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u64_x)))
-svfloat64_t svcvt_f64_x(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u64_z)))
-svfloat64_t svcvt_f64_z(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s16_f16_m)))
-svint16_t svcvt_s16_m(svint16_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s16_f16_x)))
-svint16_t svcvt_s16_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s16_f16_z)))
-svint16_t svcvt_s16_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f16_m)))
-svint32_t svcvt_s32_m(svint32_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f16_x)))
-svint32_t svcvt_s32_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f16_z)))
-svint32_t svcvt_s32_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_m)))
-svint32_t svcvt_s32_m(svint32_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_x)))
-svint32_t svcvt_s32_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_z)))
-svint32_t svcvt_s32_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f64_m)))
-svint32_t svcvt_s32_m(svint32_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f64_x)))
-svint32_t svcvt_s32_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f64_z)))
-svint32_t svcvt_s32_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f16_m)))
-svint64_t svcvt_s64_m(svint64_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f16_x)))
-svint64_t svcvt_s64_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f16_z)))
-svint64_t svcvt_s64_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f32_m)))
-svint64_t svcvt_s64_m(svint64_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f32_x)))
-svint64_t svcvt_s64_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f32_z)))
-svint64_t svcvt_s64_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f64_m)))
-svint64_t svcvt_s64_m(svint64_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f64_x)))
-svint64_t svcvt_s64_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f64_z)))
-svint64_t svcvt_s64_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u16_f16_m)))
-svuint16_t svcvt_u16_m(svuint16_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u16_f16_x)))
-svuint16_t svcvt_u16_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u16_f16_z)))
-svuint16_t svcvt_u16_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f16_m)))
-svuint32_t svcvt_u32_m(svuint32_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f16_x)))
-svuint32_t svcvt_u32_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f16_z)))
-svuint32_t svcvt_u32_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_m)))
-svuint32_t svcvt_u32_m(svuint32_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_x)))
-svuint32_t svcvt_u32_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_z)))
-svuint32_t svcvt_u32_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f64_m)))
-svuint32_t svcvt_u32_m(svuint32_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f64_x)))
-svuint32_t svcvt_u32_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f64_z)))
-svuint32_t svcvt_u32_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f16_m)))
-svuint64_t svcvt_u64_m(svuint64_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f16_x)))
-svuint64_t svcvt_u64_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f16_z)))
-svuint64_t svcvt_u64_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f32_m)))
-svuint64_t svcvt_u64_m(svuint64_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f32_x)))
-svuint64_t svcvt_u64_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f32_z)))
-svuint64_t svcvt_u64_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f64_m)))
-svuint64_t svcvt_u64_m(svuint64_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f64_x)))
-svuint64_t svcvt_u64_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f64_z)))
-svuint64_t svcvt_u64_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f64_m)))
-svfloat64_t svdiv_m(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f32_m)))
-svfloat32_t svdiv_m(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f16_m)))
-svfloat16_t svdiv_m(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f64_x)))
-svfloat64_t svdiv_x(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f32_x)))
-svfloat32_t svdiv_x(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f16_x)))
-svfloat16_t svdiv_x(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f64_z)))
-svfloat64_t svdiv_z(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f32_z)))
-svfloat32_t svdiv_z(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f16_z)))
-svfloat16_t svdiv_z(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s32_m)))
-svint32_t svdiv_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s64_m)))
-svint64_t svdiv_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s32_x)))
-svint32_t svdiv_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s64_x)))
-svint64_t svdiv_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s32_z)))
-svint32_t svdiv_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s64_z)))
-svint64_t svdiv_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u32_m)))
-svuint32_t svdiv_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u64_m)))
-svuint64_t svdiv_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u32_x)))
-svuint32_t svdiv_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u64_x)))
-svuint64_t svdiv_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u32_z)))
-svuint32_t svdiv_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u64_z)))
-svuint64_t svdiv_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f64_m)))
-svfloat64_t svdiv_m(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f32_m)))
-svfloat32_t svdiv_m(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f16_m)))
-svfloat16_t svdiv_m(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f64_x)))
-svfloat64_t svdiv_x(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f32_x)))
-svfloat32_t svdiv_x(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f16_x)))
-svfloat16_t svdiv_x(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f64_z)))
-svfloat64_t svdiv_z(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f32_z)))
-svfloat32_t svdiv_z(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f16_z)))
-svfloat16_t svdiv_z(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s32_m)))
-svint32_t svdiv_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s64_m)))
-svint64_t svdiv_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s32_x)))
-svint32_t svdiv_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s64_x)))
-svint64_t svdiv_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s32_z)))
-svint32_t svdiv_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s64_z)))
-svint64_t svdiv_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u32_m)))
-svuint32_t svdiv_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u64_m)))
-svuint64_t svdiv_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u32_x)))
-svuint32_t svdiv_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u64_x)))
-svuint64_t svdiv_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u32_z)))
-svuint32_t svdiv_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u64_z)))
-svuint64_t svdiv_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f64_m)))
-svfloat64_t svdivr_m(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f32_m)))
-svfloat32_t svdivr_m(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f16_m)))
-svfloat16_t svdivr_m(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f64_x)))
-svfloat64_t svdivr_x(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f32_x)))
-svfloat32_t svdivr_x(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f16_x)))
-svfloat16_t svdivr_x(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f64_z)))
-svfloat64_t svdivr_z(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f32_z)))
-svfloat32_t svdivr_z(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f16_z)))
-svfloat16_t svdivr_z(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s32_m)))
-svint32_t svdivr_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s64_m)))
-svint64_t svdivr_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s32_x)))
-svint32_t svdivr_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s64_x)))
-svint64_t svdivr_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s32_z)))
-svint32_t svdivr_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s64_z)))
-svint64_t svdivr_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u32_m)))
-svuint32_t svdivr_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u64_m)))
-svuint64_t svdivr_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u32_x)))
-svuint32_t svdivr_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u64_x)))
-svuint64_t svdivr_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u32_z)))
-svuint32_t svdivr_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u64_z)))
-svuint64_t svdivr_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f64_m)))
-svfloat64_t svdivr_m(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f32_m)))
-svfloat32_t svdivr_m(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f16_m)))
-svfloat16_t svdivr_m(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f64_x)))
-svfloat64_t svdivr_x(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f32_x)))
-svfloat32_t svdivr_x(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f16_x)))
-svfloat16_t svdivr_x(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f64_z)))
-svfloat64_t svdivr_z(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f32_z)))
-svfloat32_t svdivr_z(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f16_z)))
-svfloat16_t svdivr_z(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s32_m)))
-svint32_t svdivr_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s64_m)))
-svint64_t svdivr_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s32_x)))
-svint32_t svdivr_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s64_x)))
-svint64_t svdivr_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s32_z)))
-svint32_t svdivr_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s64_z)))
-svint64_t svdivr_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u32_m)))
-svuint32_t svdivr_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u64_m)))
-svuint64_t svdivr_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u32_x)))
-svuint32_t svdivr_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u64_x)))
-svuint64_t svdivr_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u32_z)))
-svuint32_t svdivr_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u64_z)))
-svuint64_t svdivr_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_s32)))
-svint32_t svdot(svint32_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_s64)))
-svint64_t svdot(svint64_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_u32)))
-svuint32_t svdot(svuint32_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_u64)))
-svuint64_t svdot(svuint64_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_s32)))
-svint32_t svdot(svint32_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_s64)))
-svint64_t svdot(svint64_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_u32)))
-svuint32_t svdot(svuint32_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_u64)))
-svuint64_t svdot(svuint64_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_s32)))
-svint32_t svdot_lane(svint32_t, svint8_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_s64)))
-svint64_t svdot_lane(svint64_t, svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_u32)))
-svuint32_t svdot_lane(svuint32_t, svuint8_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_u64)))
-svuint64_t svdot_lane(svuint64_t, svuint16_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8)))
-svuint8_t svdup_u8(uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32)))
-svuint32_t svdup_u32(uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64)))
-svuint64_t svdup_u64(uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16)))
-svuint16_t svdup_u16(uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8)))
-svint8_t svdup_s8(int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64)))
-svfloat64_t svdup_f64(float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32)))
-svfloat32_t svdup_f32(float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16)))
-svfloat16_t svdup_f16(float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32)))
-svint32_t svdup_s32(int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64)))
-svint64_t svdup_s64(int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16)))
-svint16_t svdup_s16(int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8_m)))
-svuint8_t svdup_u8_m(svuint8_t, svbool_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32_m)))
-svuint32_t svdup_u32_m(svuint32_t, svbool_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64_m)))
-svuint64_t svdup_u64_m(svuint64_t, svbool_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16_m)))
-svuint16_t svdup_u16_m(svuint16_t, svbool_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8_m)))
-svint8_t svdup_s8_m(svint8_t, svbool_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64_m)))
-svfloat64_t svdup_f64_m(svfloat64_t, svbool_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32_m)))
-svfloat32_t svdup_f32_m(svfloat32_t, svbool_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16_m)))
-svfloat16_t svdup_f16_m(svfloat16_t, svbool_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32_m)))
-svint32_t svdup_s32_m(svint32_t, svbool_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64_m)))
-svint64_t svdup_s64_m(svint64_t, svbool_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16_m)))
-svint16_t svdup_s16_m(svint16_t, svbool_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b8)))
-svbool_t svdup_b8(bool);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b32)))
-svbool_t svdup_b32(bool);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b64)))
-svbool_t svdup_b64(bool);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b16)))
-svbool_t svdup_b16(bool);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8_x)))
-svuint8_t svdup_u8_x(svbool_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32_x)))
-svuint32_t svdup_u32_x(svbool_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64_x)))
-svuint64_t svdup_u64_x(svbool_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16_x)))
-svuint16_t svdup_u16_x(svbool_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8_x)))
-svint8_t svdup_s8_x(svbool_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64_x)))
-svfloat64_t svdup_f64_x(svbool_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32_x)))
-svfloat32_t svdup_f32_x(svbool_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16_x)))
-svfloat16_t svdup_f16_x(svbool_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32_x)))
-svint32_t svdup_s32_x(svbool_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64_x)))
-svint64_t svdup_s64_x(svbool_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16_x)))
-svint16_t svdup_s16_x(svbool_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8_z)))
-svuint8_t svdup_u8_z(svbool_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32_z)))
-svuint32_t svdup_u32_z(svbool_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64_z)))
-svuint64_t svdup_u64_z(svbool_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16_z)))
-svuint16_t svdup_u16_z(svbool_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8_z)))
-svint8_t svdup_s8_z(svbool_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64_z)))
-svfloat64_t svdup_f64_z(svbool_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32_z)))
-svfloat32_t svdup_f32_z(svbool_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16_z)))
-svfloat16_t svdup_f16_z(svbool_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32_z)))
-svint32_t svdup_s32_z(svbool_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64_z)))
-svint64_t svdup_s64_z(svbool_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16_z)))
-svint16_t svdup_s16_z(svbool_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u8)))
-svuint8_t svdup_lane(svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u32)))
-svuint32_t svdup_lane(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u64)))
-svuint64_t svdup_lane(svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u16)))
-svuint16_t svdup_lane(svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s8)))
-svint8_t svdup_lane(svint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_f64)))
-svfloat64_t svdup_lane(svfloat64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_f32)))
-svfloat32_t svdup_lane(svfloat32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_f16)))
-svfloat16_t svdup_lane(svfloat16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s32)))
-svint32_t svdup_lane(svint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s64)))
-svint64_t svdup_lane(svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s16)))
-svint16_t svdup_lane(svint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u8)))
-svuint8_t svdupq_u8(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s8)))
-svint8_t svdupq_s8(int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u16)))
-svuint16_t svdupq_u16(uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_f16)))
-svfloat16_t svdupq_f16(float16_t, float16_t, float16_t, float16_t, float16_t, float16_t, float16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s16)))
-svint16_t svdupq_s16(int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u32)))
-svuint32_t svdupq_u32(uint32_t, uint32_t, uint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_f32)))
-svfloat32_t svdupq_f32(float32_t, float32_t, float32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s32)))
-svint32_t svdupq_s32(int32_t, int32_t, int32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u64)))
-svuint64_t svdupq_u64(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_f64)))
-svfloat64_t svdupq_f64(float64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s64)))
-svint64_t svdupq_s64(int64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b8)))
-svbool_t svdupq_b8(bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b16)))
-svbool_t svdupq_b16(bool, bool, bool, bool, bool, bool, bool, bool);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b32)))
-svbool_t svdupq_b32(bool, bool, bool, bool);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b64)))
-svbool_t svdupq_b64(bool, bool);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u8)))
-svuint8_t svdupq_lane(svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u32)))
-svuint32_t svdupq_lane(svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u64)))
-svuint64_t svdupq_lane(svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u16)))
-svuint16_t svdupq_lane(svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s8)))
-svint8_t svdupq_lane(svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_f64)))
-svfloat64_t svdupq_lane(svfloat64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_f32)))
-svfloat32_t svdupq_lane(svfloat32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_f16)))
-svfloat16_t svdupq_lane(svfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s32)))
-svint32_t svdupq_lane(svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s64)))
-svint64_t svdupq_lane(svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s16)))
-svint16_t svdupq_lane(svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_b_z)))
-svbool_t sveor_z(svbool_t, svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u8_m)))
-svuint8_t sveor_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u32_m)))
-svuint32_t sveor_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u64_m)))
-svuint64_t sveor_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u16_m)))
-svuint16_t sveor_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s8_m)))
-svint8_t sveor_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s32_m)))
-svint32_t sveor_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s64_m)))
-svint64_t sveor_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s16_m)))
-svint16_t sveor_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u8_x)))
-svuint8_t sveor_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u32_x)))
-svuint32_t sveor_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u64_x)))
-svuint64_t sveor_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u16_x)))
-svuint16_t sveor_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s8_x)))
-svint8_t sveor_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s32_x)))
-svint32_t sveor_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s64_x)))
-svint64_t sveor_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s16_x)))
-svint16_t sveor_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u8_z)))
-svuint8_t sveor_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u32_z)))
-svuint32_t sveor_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u64_z)))
-svuint64_t sveor_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u16_z)))
-svuint16_t sveor_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s8_z)))
-svint8_t sveor_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s32_z)))
-svint32_t sveor_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s64_z)))
-svint64_t sveor_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s16_z)))
-svint16_t sveor_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u8_m)))
-svuint8_t sveor_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u32_m)))
-svuint32_t sveor_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u64_m)))
-svuint64_t sveor_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u16_m)))
-svuint16_t sveor_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s8_m)))
-svint8_t sveor_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s32_m)))
-svint32_t sveor_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s64_m)))
-svint64_t sveor_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s16_m)))
-svint16_t sveor_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u8_x)))
-svuint8_t sveor_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u32_x)))
-svuint32_t sveor_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u64_x)))
-svuint64_t sveor_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u16_x)))
-svuint16_t sveor_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s8_x)))
-svint8_t sveor_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s32_x)))
-svint32_t sveor_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s64_x)))
-svint64_t sveor_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s16_x)))
-svint16_t sveor_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u8_z)))
-svuint8_t sveor_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u32_z)))
-svuint32_t sveor_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u64_z)))
-svuint64_t sveor_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u16_z)))
-svuint16_t sveor_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s8_z)))
-svint8_t sveor_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s32_z)))
-svint32_t sveor_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s64_z)))
-svint64_t sveor_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s16_z)))
-svint16_t sveor_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u8)))
-uint8_t sveorv(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u32)))
-uint32_t sveorv(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u64)))
-uint64_t sveorv(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u16)))
-uint16_t sveorv(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s8)))
-int8_t sveorv(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s32)))
-int32_t sveorv(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s64)))
-int64_t sveorv(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s16)))
-int16_t sveorv(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexpa_f64)))
-svfloat64_t svexpa(svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexpa_f32)))
-svfloat32_t svexpa(svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexpa_f16)))
-svfloat16_t svexpa(svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u8)))
-svuint8_t svext(svuint8_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u32)))
-svuint32_t svext(svuint32_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u64)))
-svuint64_t svext(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u16)))
-svuint16_t svext(svuint16_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s8)))
-svint8_t svext(svint8_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_f64)))
-svfloat64_t svext(svfloat64_t, svfloat64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_f32)))
-svfloat32_t svext(svfloat32_t, svfloat32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_f16)))
-svfloat16_t svext(svfloat16_t, svfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s32)))
-svint32_t svext(svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s64)))
-svint64_t svext(svint64_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s16)))
-svint16_t svext(svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s32_m)))
-svint32_t svextb_m(svint32_t, svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s64_m)))
-svint64_t svextb_m(svint64_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s16_m)))
-svint16_t svextb_m(svint16_t, svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s32_x)))
-svint32_t svextb_x(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s64_x)))
-svint64_t svextb_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s16_x)))
-svint16_t svextb_x(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s32_z)))
-svint32_t svextb_z(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s64_z)))
-svint64_t svextb_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s16_z)))
-svint16_t svextb_z(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u32_m)))
-svuint32_t svextb_m(svuint32_t, svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u64_m)))
-svuint64_t svextb_m(svuint64_t, svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u16_m)))
-svuint16_t svextb_m(svuint16_t, svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u32_x)))
-svuint32_t svextb_x(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u64_x)))
-svuint64_t svextb_x(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u16_x)))
-svuint16_t svextb_x(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u32_z)))
-svuint32_t svextb_z(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u64_z)))
-svuint64_t svextb_z(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u16_z)))
-svuint16_t svextb_z(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s32_m)))
-svint32_t svexth_m(svint32_t, svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s64_m)))
-svint64_t svexth_m(svint64_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s32_x)))
-svint32_t svexth_x(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s64_x)))
-svint64_t svexth_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s32_z)))
-svint32_t svexth_z(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s64_z)))
-svint64_t svexth_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u32_m)))
-svuint32_t svexth_m(svuint32_t, svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u64_m)))
-svuint64_t svexth_m(svuint64_t, svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u32_x)))
-svuint32_t svexth_x(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u64_x)))
-svuint64_t svexth_x(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u32_z)))
-svuint32_t svexth_z(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u64_z)))
-svuint64_t svexth_z(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_s64_m)))
-svint64_t svextw_m(svint64_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_s64_x)))
-svint64_t svextw_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_s64_z)))
-svint64_t svextw_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_u64_m)))
-svuint64_t svextw_m(svuint64_t, svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_u64_x)))
-svuint64_t svextw_x(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_u64_z)))
-svuint64_t svextw_z(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u8)))
-svuint8_t svget2(svuint8x2_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u32)))
-svuint32_t svget2(svuint32x2_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u64)))
-svuint64_t svget2(svuint64x2_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u16)))
-svuint16_t svget2(svuint16x2_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s8)))
-svint8_t svget2(svint8x2_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_f64)))
-svfloat64_t svget2(svfloat64x2_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_f32)))
-svfloat32_t svget2(svfloat32x2_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_f16)))
-svfloat16_t svget2(svfloat16x2_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s32)))
-svint32_t svget2(svint32x2_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s64)))
-svint64_t svget2(svint64x2_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s16)))
-svint16_t svget2(svint16x2_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u8)))
-svuint8_t svget3(svuint8x3_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u32)))
-svuint32_t svget3(svuint32x3_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u64)))
-svuint64_t svget3(svuint64x3_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u16)))
-svuint16_t svget3(svuint16x3_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s8)))
-svint8_t svget3(svint8x3_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_f64)))
-svfloat64_t svget3(svfloat64x3_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_f32)))
-svfloat32_t svget3(svfloat32x3_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_f16)))
-svfloat16_t svget3(svfloat16x3_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s32)))
-svint32_t svget3(svint32x3_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s64)))
-svint64_t svget3(svint64x3_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s16)))
-svint16_t svget3(svint16x3_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u8)))
-svuint8_t svget4(svuint8x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u32)))
-svuint32_t svget4(svuint32x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u64)))
-svuint64_t svget4(svuint64x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u16)))
-svuint16_t svget4(svuint16x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s8)))
-svint8_t svget4(svint8x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_f64)))
-svfloat64_t svget4(svfloat64x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_f32)))
-svfloat32_t svget4(svfloat32x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_f16)))
-svfloat16_t svget4(svfloat16x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s32)))
-svint32_t svget4(svint32x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s64)))
-svint64_t svget4(svint64x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s16)))
-svint16_t svget4(svint16x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u8)))
-svuint8_t svinsr(svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u32)))
-svuint32_t svinsr(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u64)))
-svuint64_t svinsr(svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u16)))
-svuint16_t svinsr(svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s8)))
-svint8_t svinsr(svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_f64)))
-svfloat64_t svinsr(svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_f32)))
-svfloat32_t svinsr(svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_f16)))
-svfloat16_t svinsr(svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s32)))
-svint32_t svinsr(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s64)))
-svint64_t svinsr(svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s16)))
-svint16_t svinsr(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u8)))
-uint8_t svlasta(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u32)))
-uint32_t svlasta(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u64)))
-uint64_t svlasta(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u16)))
-uint16_t svlasta(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s8)))
-int8_t svlasta(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_f64)))
-float64_t svlasta(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_f32)))
-float32_t svlasta(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_f16)))
-float16_t svlasta(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s32)))
-int32_t svlasta(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s64)))
-int64_t svlasta(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s16)))
-int16_t svlasta(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u8)))
-uint8_t svlastb(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u32)))
-uint32_t svlastb(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u64)))
-uint64_t svlastb(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u16)))
-uint16_t svlastb(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s8)))
-int8_t svlastb(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_f64)))
-float64_t svlastb(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_f32)))
-float32_t svlastb(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_f16)))
-float16_t svlastb(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s32)))
-int32_t svlastb(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s64)))
-int64_t svlastb(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s16)))
-int16_t svlastb(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u8)))
-svuint8_t svld1(svbool_t, uint8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u32)))
-svuint32_t svld1(svbool_t, uint32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u64)))
-svuint64_t svld1(svbool_t, uint64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u16)))
-svuint16_t svld1(svbool_t, uint16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s8)))
-svint8_t svld1(svbool_t, int8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f64)))
-svfloat64_t svld1(svbool_t, float64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f32)))
-svfloat32_t svld1(svbool_t, float32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f16)))
-svfloat16_t svld1(svbool_t, float16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s32)))
-svint32_t svld1(svbool_t, int32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s64)))
-svint64_t svld1(svbool_t, int64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s16)))
-svint16_t svld1(svbool_t, int16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_index_u32)))
-svuint32_t svld1_gather_index_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_index_u64)))
-svuint64_t svld1_gather_index_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_index_f64)))
-svfloat64_t svld1_gather_index_f64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_index_f32)))
-svfloat32_t svld1_gather_index_f32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_index_s32)))
-svint32_t svld1_gather_index_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_index_s64)))
-svint64_t svld1_gather_index_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_offset_u32)))
-svuint32_t svld1_gather_offset_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_offset_u64)))
-svuint64_t svld1_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_offset_f64)))
-svfloat64_t svld1_gather_offset_f64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_offset_f32)))
-svfloat32_t svld1_gather_offset_f32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_offset_s32)))
-svint32_t svld1_gather_offset_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_offset_s64)))
-svint64_t svld1_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_u32)))
-svuint32_t svld1_gather_u32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_u64)))
-svuint64_t svld1_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_f64)))
-svfloat64_t svld1_gather_f64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_f32)))
-svfloat32_t svld1_gather_f32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_s32)))
-svint32_t svld1_gather_s32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_s64)))
-svint64_t svld1_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32index_u32)))
-svuint32_t svld1_gather_index(svbool_t, uint32_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32index_f32)))
-svfloat32_t svld1_gather_index(svbool_t, float32_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32index_s32)))
-svint32_t svld1_gather_index(svbool_t, int32_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32index_u32)))
-svuint32_t svld1_gather_index(svbool_t, uint32_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32index_f32)))
-svfloat32_t svld1_gather_index(svbool_t, float32_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32index_s32)))
-svint32_t svld1_gather_index(svbool_t, int32_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64index_u64)))
-svuint64_t svld1_gather_index(svbool_t, uint64_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64index_f64)))
-svfloat64_t svld1_gather_index(svbool_t, float64_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64index_s64)))
-svint64_t svld1_gather_index(svbool_t, int64_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64index_u64)))
-svuint64_t svld1_gather_index(svbool_t, uint64_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64index_f64)))
-svfloat64_t svld1_gather_index(svbool_t, float64_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64index_s64)))
-svint64_t svld1_gather_index(svbool_t, int64_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32offset_u32)))
-svuint32_t svld1_gather_offset(svbool_t, uint32_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32offset_f32)))
-svfloat32_t svld1_gather_offset(svbool_t, float32_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32offset_s32)))
-svint32_t svld1_gather_offset(svbool_t, int32_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32offset_u32)))
-svuint32_t svld1_gather_offset(svbool_t, uint32_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32offset_f32)))
-svfloat32_t svld1_gather_offset(svbool_t, float32_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32offset_s32)))
-svint32_t svld1_gather_offset(svbool_t, int32_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64offset_u64)))
-svuint64_t svld1_gather_offset(svbool_t, uint64_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64offset_f64)))
-svfloat64_t svld1_gather_offset(svbool_t, float64_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64offset_s64)))
-svint64_t svld1_gather_offset(svbool_t, int64_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64offset_u64)))
-svuint64_t svld1_gather_offset(svbool_t, uint64_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64offset_f64)))
-svfloat64_t svld1_gather_offset(svbool_t, float64_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64offset_s64)))
-svint64_t svld1_gather_offset(svbool_t, int64_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u8)))
-svuint8_t svld1_vnum(svbool_t, uint8_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u32)))
-svuint32_t svld1_vnum(svbool_t, uint32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u64)))
-svuint64_t svld1_vnum(svbool_t, uint64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u16)))
-svuint16_t svld1_vnum(svbool_t, uint16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s8)))
-svint8_t svld1_vnum(svbool_t, int8_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f64)))
-svfloat64_t svld1_vnum(svbool_t, float64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f32)))
-svfloat32_t svld1_vnum(svbool_t, float32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f16)))
-svfloat16_t svld1_vnum(svbool_t, float16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s32)))
-svint32_t svld1_vnum(svbool_t, int32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s64)))
-svint64_t svld1_vnum(svbool_t, int64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s16)))
-svint16_t svld1_vnum(svbool_t, int16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u8)))
-svuint8_t svld1rq(svbool_t, uint8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u32)))
-svuint32_t svld1rq(svbool_t, uint32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u64)))
-svuint64_t svld1rq(svbool_t, uint64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u16)))
-svuint16_t svld1rq(svbool_t, uint16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s8)))
-svint8_t svld1rq(svbool_t, int8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_f64)))
-svfloat64_t svld1rq(svbool_t, float64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_f32)))
-svfloat32_t svld1rq(svbool_t, float32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_f16)))
-svfloat16_t svld1rq(svbool_t, float16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s32)))
-svint32_t svld1rq(svbool_t, int32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s64)))
-svint64_t svld1rq(svbool_t, int64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s16)))
-svint16_t svld1rq(svbool_t, int16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_offset_u32)))
-svuint32_t svld1sb_gather_offset_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_offset_u64)))
-svuint64_t svld1sb_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_offset_s32)))
-svint32_t svld1sb_gather_offset_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_offset_s64)))
-svint64_t svld1sb_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_u32)))
-svuint32_t svld1sb_gather_u32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_u64)))
-svuint64_t svld1sb_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_s32)))
-svint32_t svld1sb_gather_s32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_s64)))
-svint64_t svld1sb_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s32offset_u32)))
-svuint32_t svld1sb_gather_offset_u32(svbool_t, int8_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s32offset_s32)))
-svint32_t svld1sb_gather_offset_s32(svbool_t, int8_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32offset_u32)))
-svuint32_t svld1sb_gather_offset_u32(svbool_t, int8_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32offset_s32)))
-svint32_t svld1sb_gather_offset_s32(svbool_t, int8_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s64offset_u64)))
-svuint64_t svld1sb_gather_offset_u64(svbool_t, int8_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s64offset_s64)))
-svint64_t svld1sb_gather_offset_s64(svbool_t, int8_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64offset_u64)))
-svuint64_t svld1sb_gather_offset_u64(svbool_t, int8_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64offset_s64)))
-svint64_t svld1sb_gather_offset_s64(svbool_t, int8_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_index_u32)))
-svuint32_t svld1sh_gather_index_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_index_u64)))
-svuint64_t svld1sh_gather_index_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_index_s32)))
-svint32_t svld1sh_gather_index_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_index_s64)))
-svint64_t svld1sh_gather_index_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_offset_u32)))
-svuint32_t svld1sh_gather_offset_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_offset_u64)))
-svuint64_t svld1sh_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_offset_s32)))
-svint32_t svld1sh_gather_offset_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_offset_s64)))
-svint64_t svld1sh_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_u32)))
-svuint32_t svld1sh_gather_u32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_u64)))
-svuint64_t svld1sh_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_s32)))
-svint32_t svld1sh_gather_s32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_s64)))
-svint64_t svld1sh_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32index_u32)))
-svuint32_t svld1sh_gather_index_u32(svbool_t, int16_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32index_s32)))
-svint32_t svld1sh_gather_index_s32(svbool_t, int16_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32index_u32)))
-svuint32_t svld1sh_gather_index_u32(svbool_t, int16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32index_s32)))
-svint32_t svld1sh_gather_index_s32(svbool_t, int16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64index_u64)))
-svuint64_t svld1sh_gather_index_u64(svbool_t, int16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64index_s64)))
-svint64_t svld1sh_gather_index_s64(svbool_t, int16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64index_u64)))
-svuint64_t svld1sh_gather_index_u64(svbool_t, int16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64index_s64)))
-svint64_t svld1sh_gather_index_s64(svbool_t, int16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32offset_u32)))
-svuint32_t svld1sh_gather_offset_u32(svbool_t, int16_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32offset_s32)))
-svint32_t svld1sh_gather_offset_s32(svbool_t, int16_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32offset_u32)))
-svuint32_t svld1sh_gather_offset_u32(svbool_t, int16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32offset_s32)))
-svint32_t svld1sh_gather_offset_s32(svbool_t, int16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64offset_u64)))
-svuint64_t svld1sh_gather_offset_u64(svbool_t, int16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64offset_s64)))
-svint64_t svld1sh_gather_offset_s64(svbool_t, int16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64offset_u64)))
-svuint64_t svld1sh_gather_offset_u64(svbool_t, int16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64offset_s64)))
-svint64_t svld1sh_gather_offset_s64(svbool_t, int16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_index_u64)))
-svuint64_t svld1sw_gather_index_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_index_s64)))
-svint64_t svld1sw_gather_index_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_offset_u64)))
-svuint64_t svld1sw_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_offset_s64)))
-svint64_t svld1sw_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_u64)))
-svuint64_t svld1sw_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_s64)))
-svint64_t svld1sw_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64index_u64)))
-svuint64_t svld1sw_gather_index_u64(svbool_t, int32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64index_s64)))
-svint64_t svld1sw_gather_index_s64(svbool_t, int32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64index_u64)))
-svuint64_t svld1sw_gather_index_u64(svbool_t, int32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64index_s64)))
-svint64_t svld1sw_gather_index_s64(svbool_t, int32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64offset_u64)))
-svuint64_t svld1sw_gather_offset_u64(svbool_t, int32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64offset_s64)))
-svint64_t svld1sw_gather_offset_s64(svbool_t, int32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64offset_u64)))
-svuint64_t svld1sw_gather_offset_u64(svbool_t, int32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64offset_s64)))
-svint64_t svld1sw_gather_offset_s64(svbool_t, int32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_offset_u32)))
-svuint32_t svld1ub_gather_offset_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_offset_u64)))
-svuint64_t svld1ub_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_offset_s32)))
-svint32_t svld1ub_gather_offset_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_offset_s64)))
-svint64_t svld1ub_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_u32)))
-svuint32_t svld1ub_gather_u32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_u64)))
-svuint64_t svld1ub_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_s32)))
-svint32_t svld1ub_gather_s32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_s64)))
-svint64_t svld1ub_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s32offset_u32)))
-svuint32_t svld1ub_gather_offset_u32(svbool_t, uint8_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s32offset_s32)))
-svint32_t svld1ub_gather_offset_s32(svbool_t, uint8_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32offset_u32)))
-svuint32_t svld1ub_gather_offset_u32(svbool_t, uint8_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32offset_s32)))
-svint32_t svld1ub_gather_offset_s32(svbool_t, uint8_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s64offset_u64)))
-svuint64_t svld1ub_gather_offset_u64(svbool_t, uint8_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s64offset_s64)))
-svint64_t svld1ub_gather_offset_s64(svbool_t, uint8_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64offset_u64)))
-svuint64_t svld1ub_gather_offset_u64(svbool_t, uint8_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64offset_s64)))
-svint64_t svld1ub_gather_offset_s64(svbool_t, uint8_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_index_u32)))
-svuint32_t svld1uh_gather_index_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_index_u64)))
-svuint64_t svld1uh_gather_index_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_index_s32)))
-svint32_t svld1uh_gather_index_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_index_s64)))
-svint64_t svld1uh_gather_index_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_offset_u32)))
-svuint32_t svld1uh_gather_offset_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_offset_u64)))
-svuint64_t svld1uh_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_offset_s32)))
-svint32_t svld1uh_gather_offset_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_offset_s64)))
-svint64_t svld1uh_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_u32)))
-svuint32_t svld1uh_gather_u32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_u64)))
-svuint64_t svld1uh_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_s32)))
-svint32_t svld1uh_gather_s32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_s64)))
-svint64_t svld1uh_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32index_u32)))
-svuint32_t svld1uh_gather_index_u32(svbool_t, uint16_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32index_s32)))
-svint32_t svld1uh_gather_index_s32(svbool_t, uint16_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32index_u32)))
-svuint32_t svld1uh_gather_index_u32(svbool_t, uint16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32index_s32)))
-svint32_t svld1uh_gather_index_s32(svbool_t, uint16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64index_u64)))
-svuint64_t svld1uh_gather_index_u64(svbool_t, uint16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64index_s64)))
-svint64_t svld1uh_gather_index_s64(svbool_t, uint16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64index_u64)))
-svuint64_t svld1uh_gather_index_u64(svbool_t, uint16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64index_s64)))
-svint64_t svld1uh_gather_index_s64(svbool_t, uint16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32offset_u32)))
-svuint32_t svld1uh_gather_offset_u32(svbool_t, uint16_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32offset_s32)))
-svint32_t svld1uh_gather_offset_s32(svbool_t, uint16_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32offset_u32)))
-svuint32_t svld1uh_gather_offset_u32(svbool_t, uint16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32offset_s32)))
-svint32_t svld1uh_gather_offset_s32(svbool_t, uint16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64offset_u64)))
-svuint64_t svld1uh_gather_offset_u64(svbool_t, uint16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64offset_s64)))
-svint64_t svld1uh_gather_offset_s64(svbool_t, uint16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64offset_u64)))
-svuint64_t svld1uh_gather_offset_u64(svbool_t, uint16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64offset_s64)))
-svint64_t svld1uh_gather_offset_s64(svbool_t, uint16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_index_u64)))
-svuint64_t svld1uw_gather_index_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_index_s64)))
-svint64_t svld1uw_gather_index_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_offset_u64)))
-svuint64_t svld1uw_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_offset_s64)))
-svint64_t svld1uw_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_u64)))
-svuint64_t svld1uw_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_s64)))
-svint64_t svld1uw_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64index_u64)))
-svuint64_t svld1uw_gather_index_u64(svbool_t, uint32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64index_s64)))
-svint64_t svld1uw_gather_index_s64(svbool_t, uint32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64index_u64)))
-svuint64_t svld1uw_gather_index_u64(svbool_t, uint32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64index_s64)))
-svint64_t svld1uw_gather_index_s64(svbool_t, uint32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64offset_u64)))
-svuint64_t svld1uw_gather_offset_u64(svbool_t, uint32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64offset_s64)))
-svint64_t svld1uw_gather_offset_s64(svbool_t, uint32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64offset_u64)))
-svuint64_t svld1uw_gather_offset_u64(svbool_t, uint32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64offset_s64)))
-svint64_t svld1uw_gather_offset_s64(svbool_t, uint32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u8)))
-svuint8x2_t svld2(svbool_t, uint8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u32)))
-svuint32x2_t svld2(svbool_t, uint32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u64)))
-svuint64x2_t svld2(svbool_t, uint64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u16)))
-svuint16x2_t svld2(svbool_t, uint16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s8)))
-svint8x2_t svld2(svbool_t, int8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_f64)))
-svfloat64x2_t svld2(svbool_t, float64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_f32)))
-svfloat32x2_t svld2(svbool_t, float32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_f16)))
-svfloat16x2_t svld2(svbool_t, float16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s32)))
-svint32x2_t svld2(svbool_t, int32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s64)))
-svint64x2_t svld2(svbool_t, int64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s16)))
-svint16x2_t svld2(svbool_t, int16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u8)))
-svuint8x2_t svld2_vnum(svbool_t, uint8_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u32)))
-svuint32x2_t svld2_vnum(svbool_t, uint32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u64)))
-svuint64x2_t svld2_vnum(svbool_t, uint64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u16)))
-svuint16x2_t svld2_vnum(svbool_t, uint16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s8)))
-svint8x2_t svld2_vnum(svbool_t, int8_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_f64)))
-svfloat64x2_t svld2_vnum(svbool_t, float64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_f32)))
-svfloat32x2_t svld2_vnum(svbool_t, float32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_f16)))
-svfloat16x2_t svld2_vnum(svbool_t, float16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s32)))
-svint32x2_t svld2_vnum(svbool_t, int32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s64)))
-svint64x2_t svld2_vnum(svbool_t, int64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s16)))
-svint16x2_t svld2_vnum(svbool_t, int16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u8)))
-svuint8x3_t svld3(svbool_t, uint8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u32)))
-svuint32x3_t svld3(svbool_t, uint32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u64)))
-svuint64x3_t svld3(svbool_t, uint64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u16)))
-svuint16x3_t svld3(svbool_t, uint16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s8)))
-svint8x3_t svld3(svbool_t, int8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_f64)))
-svfloat64x3_t svld3(svbool_t, float64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_f32)))
-svfloat32x3_t svld3(svbool_t, float32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_f16)))
-svfloat16x3_t svld3(svbool_t, float16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s32)))
-svint32x3_t svld3(svbool_t, int32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s64)))
-svint64x3_t svld3(svbool_t, int64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s16)))
-svint16x3_t svld3(svbool_t, int16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u8)))
-svuint8x3_t svld3_vnum(svbool_t, uint8_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u32)))
-svuint32x3_t svld3_vnum(svbool_t, uint32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u64)))
-svuint64x3_t svld3_vnum(svbool_t, uint64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u16)))
-svuint16x3_t svld3_vnum(svbool_t, uint16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s8)))
-svint8x3_t svld3_vnum(svbool_t, int8_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_f64)))
-svfloat64x3_t svld3_vnum(svbool_t, float64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_f32)))
-svfloat32x3_t svld3_vnum(svbool_t, float32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_f16)))
-svfloat16x3_t svld3_vnum(svbool_t, float16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s32)))
-svint32x3_t svld3_vnum(svbool_t, int32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s64)))
-svint64x3_t svld3_vnum(svbool_t, int64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s16)))
-svint16x3_t svld3_vnum(svbool_t, int16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u8)))
-svuint8x4_t svld4(svbool_t, uint8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u32)))
-svuint32x4_t svld4(svbool_t, uint32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u64)))
-svuint64x4_t svld4(svbool_t, uint64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u16)))
-svuint16x4_t svld4(svbool_t, uint16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s8)))
-svint8x4_t svld4(svbool_t, int8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_f64)))
-svfloat64x4_t svld4(svbool_t, float64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_f32)))
-svfloat32x4_t svld4(svbool_t, float32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_f16)))
-svfloat16x4_t svld4(svbool_t, float16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s32)))
-svint32x4_t svld4(svbool_t, int32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s64)))
-svint64x4_t svld4(svbool_t, int64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s16)))
-svint16x4_t svld4(svbool_t, int16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u8)))
-svuint8x4_t svld4_vnum(svbool_t, uint8_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u32)))
-svuint32x4_t svld4_vnum(svbool_t, uint32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u64)))
-svuint64x4_t svld4_vnum(svbool_t, uint64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u16)))
-svuint16x4_t svld4_vnum(svbool_t, uint16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s8)))
-svint8x4_t svld4_vnum(svbool_t, int8_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_f64)))
-svfloat64x4_t svld4_vnum(svbool_t, float64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_f32)))
-svfloat32x4_t svld4_vnum(svbool_t, float32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_f16)))
-svfloat16x4_t svld4_vnum(svbool_t, float16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s32)))
-svint32x4_t svld4_vnum(svbool_t, int32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s64)))
-svint64x4_t svld4_vnum(svbool_t, int64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s16)))
-svint16x4_t svld4_vnum(svbool_t, int16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u8)))
-svuint8_t svldff1(svbool_t, uint8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u32)))
-svuint32_t svldff1(svbool_t, uint32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u64)))
-svuint64_t svldff1(svbool_t, uint64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u16)))
-svuint16_t svldff1(svbool_t, uint16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s8)))
-svint8_t svldff1(svbool_t, int8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_f64)))
-svfloat64_t svldff1(svbool_t, float64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_f32)))
-svfloat32_t svldff1(svbool_t, float32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_f16)))
-svfloat16_t svldff1(svbool_t, float16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s32)))
-svint32_t svldff1(svbool_t, int32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s64)))
-svint64_t svldff1(svbool_t, int64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s16)))
-svint16_t svldff1(svbool_t, int16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_index_u32)))
-svuint32_t svldff1_gather_index_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_index_u64)))
-svuint64_t svldff1_gather_index_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_index_f64)))
-svfloat64_t svldff1_gather_index_f64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_index_f32)))
-svfloat32_t svldff1_gather_index_f32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_index_s32)))
-svint32_t svldff1_gather_index_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_index_s64)))
-svint64_t svldff1_gather_index_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_offset_u32)))
-svuint32_t svldff1_gather_offset_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_offset_u64)))
-svuint64_t svldff1_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_offset_f64)))
-svfloat64_t svldff1_gather_offset_f64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_offset_f32)))
-svfloat32_t svldff1_gather_offset_f32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_offset_s32)))
-svint32_t svldff1_gather_offset_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_offset_s64)))
-svint64_t svldff1_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_u32)))
-svuint32_t svldff1_gather_u32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_u64)))
-svuint64_t svldff1_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_f64)))
-svfloat64_t svldff1_gather_f64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_f32)))
-svfloat32_t svldff1_gather_f32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_s32)))
-svint32_t svldff1_gather_s32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_s64)))
-svint64_t svldff1_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32index_u32)))
-svuint32_t svldff1_gather_index(svbool_t, uint32_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32index_f32)))
-svfloat32_t svldff1_gather_index(svbool_t, float32_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32index_s32)))
-svint32_t svldff1_gather_index(svbool_t, int32_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32index_u32)))
-svuint32_t svldff1_gather_index(svbool_t, uint32_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32index_f32)))
-svfloat32_t svldff1_gather_index(svbool_t, float32_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32index_s32)))
-svint32_t svldff1_gather_index(svbool_t, int32_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64index_u64)))
-svuint64_t svldff1_gather_index(svbool_t, uint64_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64index_f64)))
-svfloat64_t svldff1_gather_index(svbool_t, float64_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64index_s64)))
-svint64_t svldff1_gather_index(svbool_t, int64_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64index_u64)))
-svuint64_t svldff1_gather_index(svbool_t, uint64_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64index_f64)))
-svfloat64_t svldff1_gather_index(svbool_t, float64_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64index_s64)))
-svint64_t svldff1_gather_index(svbool_t, int64_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32offset_u32)))
-svuint32_t svldff1_gather_offset(svbool_t, uint32_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32offset_f32)))
-svfloat32_t svldff1_gather_offset(svbool_t, float32_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32offset_s32)))
-svint32_t svldff1_gather_offset(svbool_t, int32_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32offset_u32)))
-svuint32_t svldff1_gather_offset(svbool_t, uint32_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32offset_f32)))
-svfloat32_t svldff1_gather_offset(svbool_t, float32_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32offset_s32)))
-svint32_t svldff1_gather_offset(svbool_t, int32_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64offset_u64)))
-svuint64_t svldff1_gather_offset(svbool_t, uint64_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64offset_f64)))
-svfloat64_t svldff1_gather_offset(svbool_t, float64_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64offset_s64)))
-svint64_t svldff1_gather_offset(svbool_t, int64_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64offset_u64)))
-svuint64_t svldff1_gather_offset(svbool_t, uint64_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64offset_f64)))
-svfloat64_t svldff1_gather_offset(svbool_t, float64_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64offset_s64)))
-svint64_t svldff1_gather_offset(svbool_t, int64_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u8)))
-svuint8_t svldff1_vnum(svbool_t, uint8_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u32)))
-svuint32_t svldff1_vnum(svbool_t, uint32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u64)))
-svuint64_t svldff1_vnum(svbool_t, uint64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u16)))
-svuint16_t svldff1_vnum(svbool_t, uint16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s8)))
-svint8_t svldff1_vnum(svbool_t, int8_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_f64)))
-svfloat64_t svldff1_vnum(svbool_t, float64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_f32)))
-svfloat32_t svldff1_vnum(svbool_t, float32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_f16)))
-svfloat16_t svldff1_vnum(svbool_t, float16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s32)))
-svint32_t svldff1_vnum(svbool_t, int32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s64)))
-svint64_t svldff1_vnum(svbool_t, int64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s16)))
-svint16_t svldff1_vnum(svbool_t, int16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_offset_u32)))
-svuint32_t svldff1sb_gather_offset_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_offset_u64)))
-svuint64_t svldff1sb_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_offset_s32)))
-svint32_t svldff1sb_gather_offset_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_offset_s64)))
-svint64_t svldff1sb_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_u32)))
-svuint32_t svldff1sb_gather_u32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_u64)))
-svuint64_t svldff1sb_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_s32)))
-svint32_t svldff1sb_gather_s32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_s64)))
-svint64_t svldff1sb_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s32offset_u32)))
-svuint32_t svldff1sb_gather_offset_u32(svbool_t, int8_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s32offset_s32)))
-svint32_t svldff1sb_gather_offset_s32(svbool_t, int8_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32offset_u32)))
-svuint32_t svldff1sb_gather_offset_u32(svbool_t, int8_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32offset_s32)))
-svint32_t svldff1sb_gather_offset_s32(svbool_t, int8_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s64offset_u64)))
-svuint64_t svldff1sb_gather_offset_u64(svbool_t, int8_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s64offset_s64)))
-svint64_t svldff1sb_gather_offset_s64(svbool_t, int8_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64offset_u64)))
-svuint64_t svldff1sb_gather_offset_u64(svbool_t, int8_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64offset_s64)))
-svint64_t svldff1sb_gather_offset_s64(svbool_t, int8_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_index_u32)))
-svuint32_t svldff1sh_gather_index_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_index_u64)))
-svuint64_t svldff1sh_gather_index_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_index_s32)))
-svint32_t svldff1sh_gather_index_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_index_s64)))
-svint64_t svldff1sh_gather_index_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_offset_u32)))
-svuint32_t svldff1sh_gather_offset_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_offset_u64)))
-svuint64_t svldff1sh_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_offset_s32)))
-svint32_t svldff1sh_gather_offset_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_offset_s64)))
-svint64_t svldff1sh_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_u32)))
-svuint32_t svldff1sh_gather_u32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_u64)))
-svuint64_t svldff1sh_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_s32)))
-svint32_t svldff1sh_gather_s32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_s64)))
-svint64_t svldff1sh_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32index_u32)))
-svuint32_t svldff1sh_gather_index_u32(svbool_t, int16_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32index_s32)))
-svint32_t svldff1sh_gather_index_s32(svbool_t, int16_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32index_u32)))
-svuint32_t svldff1sh_gather_index_u32(svbool_t, int16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32index_s32)))
-svint32_t svldff1sh_gather_index_s32(svbool_t, int16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64index_u64)))
-svuint64_t svldff1sh_gather_index_u64(svbool_t, int16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64index_s64)))
-svint64_t svldff1sh_gather_index_s64(svbool_t, int16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64index_u64)))
-svuint64_t svldff1sh_gather_index_u64(svbool_t, int16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64index_s64)))
-svint64_t svldff1sh_gather_index_s64(svbool_t, int16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32offset_u32)))
-svuint32_t svldff1sh_gather_offset_u32(svbool_t, int16_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32offset_s32)))
-svint32_t svldff1sh_gather_offset_s32(svbool_t, int16_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32offset_u32)))
-svuint32_t svldff1sh_gather_offset_u32(svbool_t, int16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32offset_s32)))
-svint32_t svldff1sh_gather_offset_s32(svbool_t, int16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64offset_u64)))
-svuint64_t svldff1sh_gather_offset_u64(svbool_t, int16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64offset_s64)))
-svint64_t svldff1sh_gather_offset_s64(svbool_t, int16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64offset_u64)))
-svuint64_t svldff1sh_gather_offset_u64(svbool_t, int16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64offset_s64)))
-svint64_t svldff1sh_gather_offset_s64(svbool_t, int16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_index_u64)))
-svuint64_t svldff1sw_gather_index_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_index_s64)))
-svint64_t svldff1sw_gather_index_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_offset_u64)))
-svuint64_t svldff1sw_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_offset_s64)))
-svint64_t svldff1sw_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_u64)))
-svuint64_t svldff1sw_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_s64)))
-svint64_t svldff1sw_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64index_u64)))
-svuint64_t svldff1sw_gather_index_u64(svbool_t, int32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64index_s64)))
-svint64_t svldff1sw_gather_index_s64(svbool_t, int32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64index_u64)))
-svuint64_t svldff1sw_gather_index_u64(svbool_t, int32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64index_s64)))
-svint64_t svldff1sw_gather_index_s64(svbool_t, int32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64offset_u64)))
-svuint64_t svldff1sw_gather_offset_u64(svbool_t, int32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64offset_s64)))
-svint64_t svldff1sw_gather_offset_s64(svbool_t, int32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64offset_u64)))
-svuint64_t svldff1sw_gather_offset_u64(svbool_t, int32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64offset_s64)))
-svint64_t svldff1sw_gather_offset_s64(svbool_t, int32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_offset_u32)))
-svuint32_t svldff1ub_gather_offset_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_offset_u64)))
-svuint64_t svldff1ub_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_offset_s32)))
-svint32_t svldff1ub_gather_offset_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_offset_s64)))
-svint64_t svldff1ub_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_u32)))
-svuint32_t svldff1ub_gather_u32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_u64)))
-svuint64_t svldff1ub_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_s32)))
-svint32_t svldff1ub_gather_s32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_s64)))
-svint64_t svldff1ub_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s32offset_u32)))
-svuint32_t svldff1ub_gather_offset_u32(svbool_t, uint8_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s32offset_s32)))
-svint32_t svldff1ub_gather_offset_s32(svbool_t, uint8_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32offset_u32)))
-svuint32_t svldff1ub_gather_offset_u32(svbool_t, uint8_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32offset_s32)))
-svint32_t svldff1ub_gather_offset_s32(svbool_t, uint8_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s64offset_u64)))
-svuint64_t svldff1ub_gather_offset_u64(svbool_t, uint8_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s64offset_s64)))
-svint64_t svldff1ub_gather_offset_s64(svbool_t, uint8_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64offset_u64)))
-svuint64_t svldff1ub_gather_offset_u64(svbool_t, uint8_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64offset_s64)))
-svint64_t svldff1ub_gather_offset_s64(svbool_t, uint8_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_index_u32)))
-svuint32_t svldff1uh_gather_index_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_index_u64)))
-svuint64_t svldff1uh_gather_index_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_index_s32)))
-svint32_t svldff1uh_gather_index_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_index_s64)))
-svint64_t svldff1uh_gather_index_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_offset_u32)))
-svuint32_t svldff1uh_gather_offset_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_offset_u64)))
-svuint64_t svldff1uh_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_offset_s32)))
-svint32_t svldff1uh_gather_offset_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_offset_s64)))
-svint64_t svldff1uh_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_u32)))
-svuint32_t svldff1uh_gather_u32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_u64)))
-svuint64_t svldff1uh_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_s32)))
-svint32_t svldff1uh_gather_s32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_s64)))
-svint64_t svldff1uh_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32index_u32)))
-svuint32_t svldff1uh_gather_index_u32(svbool_t, uint16_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32index_s32)))
-svint32_t svldff1uh_gather_index_s32(svbool_t, uint16_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32index_u32)))
-svuint32_t svldff1uh_gather_index_u32(svbool_t, uint16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32index_s32)))
-svint32_t svldff1uh_gather_index_s32(svbool_t, uint16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64index_u64)))
-svuint64_t svldff1uh_gather_index_u64(svbool_t, uint16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64index_s64)))
-svint64_t svldff1uh_gather_index_s64(svbool_t, uint16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64index_u64)))
-svuint64_t svldff1uh_gather_index_u64(svbool_t, uint16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64index_s64)))
-svint64_t svldff1uh_gather_index_s64(svbool_t, uint16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32offset_u32)))
-svuint32_t svldff1uh_gather_offset_u32(svbool_t, uint16_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32offset_s32)))
-svint32_t svldff1uh_gather_offset_s32(svbool_t, uint16_t const *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32offset_u32)))
-svuint32_t svldff1uh_gather_offset_u32(svbool_t, uint16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32offset_s32)))
-svint32_t svldff1uh_gather_offset_s32(svbool_t, uint16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64offset_u64)))
-svuint64_t svldff1uh_gather_offset_u64(svbool_t, uint16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64offset_s64)))
-svint64_t svldff1uh_gather_offset_s64(svbool_t, uint16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64offset_u64)))
-svuint64_t svldff1uh_gather_offset_u64(svbool_t, uint16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64offset_s64)))
-svint64_t svldff1uh_gather_offset_s64(svbool_t, uint16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_index_u64)))
-svuint64_t svldff1uw_gather_index_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_index_s64)))
-svint64_t svldff1uw_gather_index_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_offset_u64)))
-svuint64_t svldff1uw_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_offset_s64)))
-svint64_t svldff1uw_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_u64)))
-svuint64_t svldff1uw_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_s64)))
-svint64_t svldff1uw_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64index_u64)))
-svuint64_t svldff1uw_gather_index_u64(svbool_t, uint32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64index_s64)))
-svint64_t svldff1uw_gather_index_s64(svbool_t, uint32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64index_u64)))
-svuint64_t svldff1uw_gather_index_u64(svbool_t, uint32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64index_s64)))
-svint64_t svldff1uw_gather_index_s64(svbool_t, uint32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64offset_u64)))
-svuint64_t svldff1uw_gather_offset_u64(svbool_t, uint32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64offset_s64)))
-svint64_t svldff1uw_gather_offset_s64(svbool_t, uint32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64offset_u64)))
-svuint64_t svldff1uw_gather_offset_u64(svbool_t, uint32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64offset_s64)))
-svint64_t svldff1uw_gather_offset_s64(svbool_t, uint32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u8)))
-svuint8_t svldnf1(svbool_t, uint8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u32)))
-svuint32_t svldnf1(svbool_t, uint32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u64)))
-svuint64_t svldnf1(svbool_t, uint64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u16)))
-svuint16_t svldnf1(svbool_t, uint16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s8)))
-svint8_t svldnf1(svbool_t, int8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_f64)))
-svfloat64_t svldnf1(svbool_t, float64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_f32)))
-svfloat32_t svldnf1(svbool_t, float32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_f16)))
-svfloat16_t svldnf1(svbool_t, float16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s32)))
-svint32_t svldnf1(svbool_t, int32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s64)))
-svint64_t svldnf1(svbool_t, int64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s16)))
-svint16_t svldnf1(svbool_t, int16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u8)))
-svuint8_t svldnf1_vnum(svbool_t, uint8_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u32)))
-svuint32_t svldnf1_vnum(svbool_t, uint32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u64)))
-svuint64_t svldnf1_vnum(svbool_t, uint64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u16)))
-svuint16_t svldnf1_vnum(svbool_t, uint16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s8)))
-svint8_t svldnf1_vnum(svbool_t, int8_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_f64)))
-svfloat64_t svldnf1_vnum(svbool_t, float64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_f32)))
-svfloat32_t svldnf1_vnum(svbool_t, float32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_f16)))
-svfloat16_t svldnf1_vnum(svbool_t, float16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s32)))
-svint32_t svldnf1_vnum(svbool_t, int32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s64)))
-svint64_t svldnf1_vnum(svbool_t, int64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s16)))
-svint16_t svldnf1_vnum(svbool_t, int16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u8)))
-svuint8_t svldnt1(svbool_t, uint8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u32)))
-svuint32_t svldnt1(svbool_t, uint32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u64)))
-svuint64_t svldnt1(svbool_t, uint64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u16)))
-svuint16_t svldnt1(svbool_t, uint16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s8)))
-svint8_t svldnt1(svbool_t, int8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f64)))
-svfloat64_t svldnt1(svbool_t, float64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f32)))
-svfloat32_t svldnt1(svbool_t, float32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f16)))
-svfloat16_t svldnt1(svbool_t, float16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s32)))
-svint32_t svldnt1(svbool_t, int32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s64)))
-svint64_t svldnt1(svbool_t, int64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s16)))
-svint16_t svldnt1(svbool_t, int16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u8)))
-svuint8_t svldnt1_vnum(svbool_t, uint8_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u32)))
-svuint32_t svldnt1_vnum(svbool_t, uint32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u64)))
-svuint64_t svldnt1_vnum(svbool_t, uint64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u16)))
-svuint16_t svldnt1_vnum(svbool_t, uint16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s8)))
-svint8_t svldnt1_vnum(svbool_t, int8_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f64)))
-svfloat64_t svldnt1_vnum(svbool_t, float64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f32)))
-svfloat32_t svldnt1_vnum(svbool_t, float32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f16)))
-svfloat16_t svldnt1_vnum(svbool_t, float16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s32)))
-svint32_t svldnt1_vnum(svbool_t, int32_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s64)))
-svint64_t svldnt1_vnum(svbool_t, int64_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s16)))
-svint16_t svldnt1_vnum(svbool_t, int16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u8)))
-uint64_t svlen(svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u32)))
-uint64_t svlen(svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u64)))
-uint64_t svlen(svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u16)))
-uint64_t svlen(svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s8)))
-uint64_t svlen(svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_f64)))
-uint64_t svlen(svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_f32)))
-uint64_t svlen(svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_f16)))
-uint64_t svlen(svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s32)))
-uint64_t svlen(svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s64)))
-uint64_t svlen(svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s16)))
-uint64_t svlen(svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u8_m)))
-svuint8_t svlsl_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u32_m)))
-svuint32_t svlsl_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u64_m)))
-svuint64_t svlsl_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u16_m)))
-svuint16_t svlsl_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s8_m)))
-svint8_t svlsl_m(svbool_t, svint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s32_m)))
-svint32_t svlsl_m(svbool_t, svint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s64_m)))
-svint64_t svlsl_m(svbool_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s16_m)))
-svint16_t svlsl_m(svbool_t, svint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u8_x)))
-svuint8_t svlsl_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u32_x)))
-svuint32_t svlsl_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u64_x)))
-svuint64_t svlsl_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u16_x)))
-svuint16_t svlsl_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s8_x)))
-svint8_t svlsl_x(svbool_t, svint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s32_x)))
-svint32_t svlsl_x(svbool_t, svint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s64_x)))
-svint64_t svlsl_x(svbool_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s16_x)))
-svint16_t svlsl_x(svbool_t, svint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u8_z)))
-svuint8_t svlsl_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u32_z)))
-svuint32_t svlsl_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u64_z)))
-svuint64_t svlsl_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u16_z)))
-svuint16_t svlsl_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s8_z)))
-svint8_t svlsl_z(svbool_t, svint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s32_z)))
-svint32_t svlsl_z(svbool_t, svint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s64_z)))
-svint64_t svlsl_z(svbool_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s16_z)))
-svint16_t svlsl_z(svbool_t, svint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u8_m)))
-svuint8_t svlsl_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u32_m)))
-svuint32_t svlsl_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u64_m)))
-svuint64_t svlsl_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u16_m)))
-svuint16_t svlsl_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s8_m)))
-svint8_t svlsl_m(svbool_t, svint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s32_m)))
-svint32_t svlsl_m(svbool_t, svint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s64_m)))
-svint64_t svlsl_m(svbool_t, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s16_m)))
-svint16_t svlsl_m(svbool_t, svint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u8_x)))
-svuint8_t svlsl_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u32_x)))
-svuint32_t svlsl_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u64_x)))
-svuint64_t svlsl_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u16_x)))
-svuint16_t svlsl_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s8_x)))
-svint8_t svlsl_x(svbool_t, svint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s32_x)))
-svint32_t svlsl_x(svbool_t, svint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s64_x)))
-svint64_t svlsl_x(svbool_t, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s16_x)))
-svint16_t svlsl_x(svbool_t, svint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u8_z)))
-svuint8_t svlsl_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u32_z)))
-svuint32_t svlsl_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u64_z)))
-svuint64_t svlsl_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u16_z)))
-svuint16_t svlsl_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s8_z)))
-svint8_t svlsl_z(svbool_t, svint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s32_z)))
-svint32_t svlsl_z(svbool_t, svint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s64_z)))
-svint64_t svlsl_z(svbool_t, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s16_z)))
-svint16_t svlsl_z(svbool_t, svint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u8_m)))
-svuint8_t svlsl_wide_m(svbool_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u32_m)))
-svuint32_t svlsl_wide_m(svbool_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u16_m)))
-svuint16_t svlsl_wide_m(svbool_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s8_m)))
-svint8_t svlsl_wide_m(svbool_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s32_m)))
-svint32_t svlsl_wide_m(svbool_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s16_m)))
-svint16_t svlsl_wide_m(svbool_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u8_x)))
-svuint8_t svlsl_wide_x(svbool_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u32_x)))
-svuint32_t svlsl_wide_x(svbool_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u16_x)))
-svuint16_t svlsl_wide_x(svbool_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s8_x)))
-svint8_t svlsl_wide_x(svbool_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s32_x)))
-svint32_t svlsl_wide_x(svbool_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s16_x)))
-svint16_t svlsl_wide_x(svbool_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u8_z)))
-svuint8_t svlsl_wide_z(svbool_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u32_z)))
-svuint32_t svlsl_wide_z(svbool_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u16_z)))
-svuint16_t svlsl_wide_z(svbool_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s8_z)))
-svint8_t svlsl_wide_z(svbool_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s32_z)))
-svint32_t svlsl_wide_z(svbool_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s16_z)))
-svint16_t svlsl_wide_z(svbool_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u8_m)))
-svuint8_t svlsl_wide_m(svbool_t, svuint8_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u32_m)))
-svuint32_t svlsl_wide_m(svbool_t, svuint32_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u16_m)))
-svuint16_t svlsl_wide_m(svbool_t, svuint16_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s8_m)))
-svint8_t svlsl_wide_m(svbool_t, svint8_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s32_m)))
-svint32_t svlsl_wide_m(svbool_t, svint32_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s16_m)))
-svint16_t svlsl_wide_m(svbool_t, svint16_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u8_x)))
-svuint8_t svlsl_wide_x(svbool_t, svuint8_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u32_x)))
-svuint32_t svlsl_wide_x(svbool_t, svuint32_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u16_x)))
-svuint16_t svlsl_wide_x(svbool_t, svuint16_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s8_x)))
-svint8_t svlsl_wide_x(svbool_t, svint8_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s32_x)))
-svint32_t svlsl_wide_x(svbool_t, svint32_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s16_x)))
-svint16_t svlsl_wide_x(svbool_t, svint16_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u8_z)))
-svuint8_t svlsl_wide_z(svbool_t, svuint8_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u32_z)))
-svuint32_t svlsl_wide_z(svbool_t, svuint32_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u16_z)))
-svuint16_t svlsl_wide_z(svbool_t, svuint16_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s8_z)))
-svint8_t svlsl_wide_z(svbool_t, svint8_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s32_z)))
-svint32_t svlsl_wide_z(svbool_t, svint32_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s16_z)))
-svint16_t svlsl_wide_z(svbool_t, svint16_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u8_m)))
-svuint8_t svlsr_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u32_m)))
-svuint32_t svlsr_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u64_m)))
-svuint64_t svlsr_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u16_m)))
-svuint16_t svlsr_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u8_x)))
-svuint8_t svlsr_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u32_x)))
-svuint32_t svlsr_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u64_x)))
-svuint64_t svlsr_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u16_x)))
-svuint16_t svlsr_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u8_z)))
-svuint8_t svlsr_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u32_z)))
-svuint32_t svlsr_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u64_z)))
-svuint64_t svlsr_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u16_z)))
-svuint16_t svlsr_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u8_m)))
-svuint8_t svlsr_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u32_m)))
-svuint32_t svlsr_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u64_m)))
-svuint64_t svlsr_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u16_m)))
-svuint16_t svlsr_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u8_x)))
-svuint8_t svlsr_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u32_x)))
-svuint32_t svlsr_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u64_x)))
-svuint64_t svlsr_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u16_x)))
-svuint16_t svlsr_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u8_z)))
-svuint8_t svlsr_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u32_z)))
-svuint32_t svlsr_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u64_z)))
-svuint64_t svlsr_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u16_z)))
-svuint16_t svlsr_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u8_m)))
-svuint8_t svlsr_wide_m(svbool_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u32_m)))
-svuint32_t svlsr_wide_m(svbool_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u16_m)))
-svuint16_t svlsr_wide_m(svbool_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u8_x)))
-svuint8_t svlsr_wide_x(svbool_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u32_x)))
-svuint32_t svlsr_wide_x(svbool_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u16_x)))
-svuint16_t svlsr_wide_x(svbool_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u8_z)))
-svuint8_t svlsr_wide_z(svbool_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u32_z)))
-svuint32_t svlsr_wide_z(svbool_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u16_z)))
-svuint16_t svlsr_wide_z(svbool_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u8_m)))
-svuint8_t svlsr_wide_m(svbool_t, svuint8_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u32_m)))
-svuint32_t svlsr_wide_m(svbool_t, svuint32_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u16_m)))
-svuint16_t svlsr_wide_m(svbool_t, svuint16_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u8_x)))
-svuint8_t svlsr_wide_x(svbool_t, svuint8_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u32_x)))
-svuint32_t svlsr_wide_x(svbool_t, svuint32_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u16_x)))
-svuint16_t svlsr_wide_x(svbool_t, svuint16_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u8_z)))
-svuint8_t svlsr_wide_z(svbool_t, svuint8_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u32_z)))
-svuint32_t svlsr_wide_z(svbool_t, svuint32_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u16_z)))
-svuint16_t svlsr_wide_z(svbool_t, svuint16_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f64_m)))
-svfloat64_t svmad_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f32_m)))
-svfloat32_t svmad_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f16_m)))
-svfloat16_t svmad_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f64_x)))
-svfloat64_t svmad_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f32_x)))
-svfloat32_t svmad_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f16_x)))
-svfloat16_t svmad_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f64_z)))
-svfloat64_t svmad_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f32_z)))
-svfloat32_t svmad_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f16_z)))
-svfloat16_t svmad_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u8_m)))
-svuint8_t svmad_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u32_m)))
-svuint32_t svmad_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u64_m)))
-svuint64_t svmad_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u16_m)))
-svuint16_t svmad_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s8_m)))
-svint8_t svmad_m(svbool_t, svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s32_m)))
-svint32_t svmad_m(svbool_t, svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s64_m)))
-svint64_t svmad_m(svbool_t, svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s16_m)))
-svint16_t svmad_m(svbool_t, svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u8_x)))
-svuint8_t svmad_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u32_x)))
-svuint32_t svmad_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u64_x)))
-svuint64_t svmad_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u16_x)))
-svuint16_t svmad_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s8_x)))
-svint8_t svmad_x(svbool_t, svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s32_x)))
-svint32_t svmad_x(svbool_t, svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s64_x)))
-svint64_t svmad_x(svbool_t, svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s16_x)))
-svint16_t svmad_x(svbool_t, svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u8_z)))
-svuint8_t svmad_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u32_z)))
-svuint32_t svmad_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u64_z)))
-svuint64_t svmad_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u16_z)))
-svuint16_t svmad_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s8_z)))
-svint8_t svmad_z(svbool_t, svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s32_z)))
-svint32_t svmad_z(svbool_t, svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s64_z)))
-svint64_t svmad_z(svbool_t, svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s16_z)))
-svint16_t svmad_z(svbool_t, svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f64_m)))
-svfloat64_t svmad_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f32_m)))
-svfloat32_t svmad_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f16_m)))
-svfloat16_t svmad_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f64_x)))
-svfloat64_t svmad_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f32_x)))
-svfloat32_t svmad_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f16_x)))
-svfloat16_t svmad_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f64_z)))
-svfloat64_t svmad_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f32_z)))
-svfloat32_t svmad_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f16_z)))
-svfloat16_t svmad_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u8_m)))
-svuint8_t svmad_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u32_m)))
-svuint32_t svmad_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u64_m)))
-svuint64_t svmad_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u16_m)))
-svuint16_t svmad_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s8_m)))
-svint8_t svmad_m(svbool_t, svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s32_m)))
-svint32_t svmad_m(svbool_t, svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s64_m)))
-svint64_t svmad_m(svbool_t, svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s16_m)))
-svint16_t svmad_m(svbool_t, svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u8_x)))
-svuint8_t svmad_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u32_x)))
-svuint32_t svmad_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u64_x)))
-svuint64_t svmad_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u16_x)))
-svuint16_t svmad_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s8_x)))
-svint8_t svmad_x(svbool_t, svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s32_x)))
-svint32_t svmad_x(svbool_t, svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s64_x)))
-svint64_t svmad_x(svbool_t, svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s16_x)))
-svint16_t svmad_x(svbool_t, svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u8_z)))
-svuint8_t svmad_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u32_z)))
-svuint32_t svmad_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u64_z)))
-svuint64_t svmad_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u16_z)))
-svuint16_t svmad_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s8_z)))
-svint8_t svmad_z(svbool_t, svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s32_z)))
-svint32_t svmad_z(svbool_t, svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s64_z)))
-svint64_t svmad_z(svbool_t, svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s16_z)))
-svint16_t svmad_z(svbool_t, svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f64_m)))
-svfloat64_t svmax_m(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f32_m)))
-svfloat32_t svmax_m(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f16_m)))
-svfloat16_t svmax_m(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f64_x)))
-svfloat64_t svmax_x(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f32_x)))
-svfloat32_t svmax_x(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f16_x)))
-svfloat16_t svmax_x(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f64_z)))
-svfloat64_t svmax_z(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f32_z)))
-svfloat32_t svmax_z(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f16_z)))
-svfloat16_t svmax_z(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s8_m)))
-svint8_t svmax_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s32_m)))
-svint32_t svmax_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s64_m)))
-svint64_t svmax_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s16_m)))
-svint16_t svmax_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s8_x)))
-svint8_t svmax_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s32_x)))
-svint32_t svmax_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s64_x)))
-svint64_t svmax_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s16_x)))
-svint16_t svmax_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s8_z)))
-svint8_t svmax_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s32_z)))
-svint32_t svmax_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s64_z)))
-svint64_t svmax_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s16_z)))
-svint16_t svmax_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u8_m)))
-svuint8_t svmax_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u32_m)))
-svuint32_t svmax_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u64_m)))
-svuint64_t svmax_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u16_m)))
-svuint16_t svmax_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u8_x)))
-svuint8_t svmax_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u32_x)))
-svuint32_t svmax_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u64_x)))
-svuint64_t svmax_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u16_x)))
-svuint16_t svmax_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u8_z)))
-svuint8_t svmax_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u32_z)))
-svuint32_t svmax_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u64_z)))
-svuint64_t svmax_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u16_z)))
-svuint16_t svmax_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_m)))
-svfloat64_t svmax_m(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_m)))
-svfloat32_t svmax_m(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_m)))
-svfloat16_t svmax_m(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_x)))
-svfloat64_t svmax_x(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_x)))
-svfloat32_t svmax_x(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_x)))
-svfloat16_t svmax_x(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_z)))
-svfloat64_t svmax_z(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_z)))
-svfloat32_t svmax_z(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_z)))
-svfloat16_t svmax_z(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_m)))
-svint8_t svmax_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_m)))
-svint32_t svmax_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_m)))
-svint64_t svmax_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_m)))
-svint16_t svmax_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_x)))
-svint8_t svmax_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_x)))
-svint32_t svmax_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_x)))
-svint64_t svmax_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_x)))
-svint16_t svmax_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_z)))
-svint8_t svmax_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_z)))
-svint32_t svmax_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_z)))
-svint64_t svmax_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_z)))
-svint16_t svmax_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_m)))
-svuint8_t svmax_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_m)))
-svuint32_t svmax_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_m)))
-svuint64_t svmax_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_m)))
-svuint16_t svmax_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_x)))
-svuint8_t svmax_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_x)))
-svuint32_t svmax_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_x)))
-svuint64_t svmax_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_x)))
-svuint16_t svmax_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_z)))
-svuint8_t svmax_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_z)))
-svuint32_t svmax_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_z)))
-svuint64_t svmax_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_z)))
-svuint16_t svmax_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f64_m)))
-svfloat64_t svmaxnm_m(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f32_m)))
-svfloat32_t svmaxnm_m(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f16_m)))
-svfloat16_t svmaxnm_m(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f64_x)))
-svfloat64_t svmaxnm_x(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f32_x)))
-svfloat32_t svmaxnm_x(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f16_x)))
-svfloat16_t svmaxnm_x(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f64_z)))
-svfloat64_t svmaxnm_z(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f32_z)))
-svfloat32_t svmaxnm_z(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f16_z)))
-svfloat16_t svmaxnm_z(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_m)))
-svfloat64_t svmaxnm_m(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_m)))
-svfloat32_t svmaxnm_m(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_m)))
-svfloat16_t svmaxnm_m(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_x)))
-svfloat64_t svmaxnm_x(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_x)))
-svfloat32_t svmaxnm_x(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x)))
-svfloat16_t svmaxnm_x(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_z)))
-svfloat64_t svmaxnm_z(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_z)))
-svfloat32_t svmaxnm_z(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_z)))
-svfloat16_t svmaxnm_z(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmv_f64)))
-float64_t svmaxnmv(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmv_f32)))
-float32_t svmaxnmv(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmv_f16)))
-float16_t svmaxnmv(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_f64)))
-float64_t svmaxv(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_f32)))
-float32_t svmaxv(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_f16)))
-float16_t svmaxv(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s8)))
-int8_t svmaxv(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s32)))
-int32_t svmaxv(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s64)))
-int64_t svmaxv(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s16)))
-int16_t svmaxv(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u8)))
-uint8_t svmaxv(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u32)))
-uint32_t svmaxv(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u64)))
-uint64_t svmaxv(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u16)))
-uint16_t svmaxv(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f64_m)))
-svfloat64_t svmin_m(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f32_m)))
-svfloat32_t svmin_m(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f16_m)))
-svfloat16_t svmin_m(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f64_x)))
-svfloat64_t svmin_x(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f32_x)))
-svfloat32_t svmin_x(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f16_x)))
-svfloat16_t svmin_x(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f64_z)))
-svfloat64_t svmin_z(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f32_z)))
-svfloat32_t svmin_z(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f16_z)))
-svfloat16_t svmin_z(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s8_m)))
-svint8_t svmin_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s32_m)))
-svint32_t svmin_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s64_m)))
-svint64_t svmin_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s16_m)))
-svint16_t svmin_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s8_x)))
-svint8_t svmin_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s32_x)))
-svint32_t svmin_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s64_x)))
-svint64_t svmin_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s16_x)))
-svint16_t svmin_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s8_z)))
-svint8_t svmin_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s32_z)))
-svint32_t svmin_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s64_z)))
-svint64_t svmin_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s16_z)))
-svint16_t svmin_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u8_m)))
-svuint8_t svmin_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u32_m)))
-svuint32_t svmin_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u64_m)))
-svuint64_t svmin_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u16_m)))
-svuint16_t svmin_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u8_x)))
-svuint8_t svmin_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u32_x)))
-svuint32_t svmin_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u64_x)))
-svuint64_t svmin_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u16_x)))
-svuint16_t svmin_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u8_z)))
-svuint8_t svmin_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u32_z)))
-svuint32_t svmin_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u64_z)))
-svuint64_t svmin_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u16_z)))
-svuint16_t svmin_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_m)))
-svfloat64_t svmin_m(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_m)))
-svfloat32_t svmin_m(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_m)))
-svfloat16_t svmin_m(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_x)))
-svfloat64_t svmin_x(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_x)))
-svfloat32_t svmin_x(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_x)))
-svfloat16_t svmin_x(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_z)))
-svfloat64_t svmin_z(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_z)))
-svfloat32_t svmin_z(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_z)))
-svfloat16_t svmin_z(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_m)))
-svint8_t svmin_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_m)))
-svint32_t svmin_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_m)))
-svint64_t svmin_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_m)))
-svint16_t svmin_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_x)))
-svint8_t svmin_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_x)))
-svint32_t svmin_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_x)))
-svint64_t svmin_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_x)))
-svint16_t svmin_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_z)))
-svint8_t svmin_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_z)))
-svint32_t svmin_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_z)))
-svint64_t svmin_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_z)))
-svint16_t svmin_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_m)))
-svuint8_t svmin_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_m)))
-svuint32_t svmin_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_m)))
-svuint64_t svmin_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_m)))
-svuint16_t svmin_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_x)))
-svuint8_t svmin_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_x)))
-svuint32_t svmin_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_x)))
-svuint64_t svmin_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_x)))
-svuint16_t svmin_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_z)))
-svuint8_t svmin_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_z)))
-svuint32_t svmin_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_z)))
-svuint64_t svmin_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_z)))
-svuint16_t svmin_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f64_m)))
-svfloat64_t svminnm_m(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f32_m)))
-svfloat32_t svminnm_m(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f16_m)))
-svfloat16_t svminnm_m(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f64_x)))
-svfloat64_t svminnm_x(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f32_x)))
-svfloat32_t svminnm_x(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f16_x)))
-svfloat16_t svminnm_x(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f64_z)))
-svfloat64_t svminnm_z(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f32_z)))
-svfloat32_t svminnm_z(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f16_z)))
-svfloat16_t svminnm_z(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_m)))
-svfloat64_t svminnm_m(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_m)))
-svfloat32_t svminnm_m(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_m)))
-svfloat16_t svminnm_m(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_x)))
-svfloat64_t svminnm_x(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_x)))
-svfloat32_t svminnm_x(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_x)))
-svfloat16_t svminnm_x(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_z)))
-svfloat64_t svminnm_z(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_z)))
-svfloat32_t svminnm_z(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_z)))
-svfloat16_t svminnm_z(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmv_f64)))
-float64_t svminnmv(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmv_f32)))
-float32_t svminnmv(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmv_f16)))
-float16_t svminnmv(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_f64)))
-float64_t svminv(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_f32)))
-float32_t svminv(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_f16)))
-float16_t svminv(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s8)))
-int8_t svminv(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s32)))
-int32_t svminv(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s64)))
-int64_t svminv(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s16)))
-int16_t svminv(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u8)))
-uint8_t svminv(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u32)))
-uint32_t svminv(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u64)))
-uint64_t svminv(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u16)))
-uint16_t svminv(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f64_m)))
-svfloat64_t svmla_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f32_m)))
-svfloat32_t svmla_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f16_m)))
-svfloat16_t svmla_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f64_x)))
-svfloat64_t svmla_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f32_x)))
-svfloat32_t svmla_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f16_x)))
-svfloat16_t svmla_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f64_z)))
-svfloat64_t svmla_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f32_z)))
-svfloat32_t svmla_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f16_z)))
-svfloat16_t svmla_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u8_m)))
-svuint8_t svmla_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u32_m)))
-svuint32_t svmla_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u64_m)))
-svuint64_t svmla_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u16_m)))
-svuint16_t svmla_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s8_m)))
-svint8_t svmla_m(svbool_t, svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s32_m)))
-svint32_t svmla_m(svbool_t, svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s64_m)))
-svint64_t svmla_m(svbool_t, svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s16_m)))
-svint16_t svmla_m(svbool_t, svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u8_x)))
-svuint8_t svmla_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u32_x)))
-svuint32_t svmla_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u64_x)))
-svuint64_t svmla_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u16_x)))
-svuint16_t svmla_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s8_x)))
-svint8_t svmla_x(svbool_t, svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s32_x)))
-svint32_t svmla_x(svbool_t, svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s64_x)))
-svint64_t svmla_x(svbool_t, svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s16_x)))
-svint16_t svmla_x(svbool_t, svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u8_z)))
-svuint8_t svmla_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u32_z)))
-svuint32_t svmla_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u64_z)))
-svuint64_t svmla_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u16_z)))
-svuint16_t svmla_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s8_z)))
-svint8_t svmla_z(svbool_t, svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s32_z)))
-svint32_t svmla_z(svbool_t, svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s64_z)))
-svint64_t svmla_z(svbool_t, svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s16_z)))
-svint16_t svmla_z(svbool_t, svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f64_m)))
-svfloat64_t svmla_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f32_m)))
-svfloat32_t svmla_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f16_m)))
-svfloat16_t svmla_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f64_x)))
-svfloat64_t svmla_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f32_x)))
-svfloat32_t svmla_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f16_x)))
-svfloat16_t svmla_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f64_z)))
-svfloat64_t svmla_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f32_z)))
-svfloat32_t svmla_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f16_z)))
-svfloat16_t svmla_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u8_m)))
-svuint8_t svmla_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u32_m)))
-svuint32_t svmla_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u64_m)))
-svuint64_t svmla_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u16_m)))
-svuint16_t svmla_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s8_m)))
-svint8_t svmla_m(svbool_t, svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s32_m)))
-svint32_t svmla_m(svbool_t, svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s64_m)))
-svint64_t svmla_m(svbool_t, svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s16_m)))
-svint16_t svmla_m(svbool_t, svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u8_x)))
-svuint8_t svmla_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u32_x)))
-svuint32_t svmla_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u64_x)))
-svuint64_t svmla_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u16_x)))
-svuint16_t svmla_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s8_x)))
-svint8_t svmla_x(svbool_t, svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s32_x)))
-svint32_t svmla_x(svbool_t, svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s64_x)))
-svint64_t svmla_x(svbool_t, svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s16_x)))
-svint16_t svmla_x(svbool_t, svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u8_z)))
-svuint8_t svmla_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u32_z)))
-svuint32_t svmla_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u64_z)))
-svuint64_t svmla_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u16_z)))
-svuint16_t svmla_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s8_z)))
-svint8_t svmla_z(svbool_t, svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s32_z)))
-svint32_t svmla_z(svbool_t, svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s64_z)))
-svint64_t svmla_z(svbool_t, svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s16_z)))
-svint16_t svmla_z(svbool_t, svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_f64)))
-svfloat64_t svmla_lane(svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_f32)))
-svfloat32_t svmla_lane(svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_f16)))
-svfloat16_t svmla_lane(svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f64_m)))
-svfloat64_t svmls_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f32_m)))
-svfloat32_t svmls_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f16_m)))
-svfloat16_t svmls_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f64_x)))
-svfloat64_t svmls_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f32_x)))
-svfloat32_t svmls_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f16_x)))
-svfloat16_t svmls_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f64_z)))
-svfloat64_t svmls_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f32_z)))
-svfloat32_t svmls_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f16_z)))
-svfloat16_t svmls_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u8_m)))
-svuint8_t svmls_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u32_m)))
-svuint32_t svmls_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u64_m)))
-svuint64_t svmls_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u16_m)))
-svuint16_t svmls_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s8_m)))
-svint8_t svmls_m(svbool_t, svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s32_m)))
-svint32_t svmls_m(svbool_t, svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s64_m)))
-svint64_t svmls_m(svbool_t, svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s16_m)))
-svint16_t svmls_m(svbool_t, svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u8_x)))
-svuint8_t svmls_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u32_x)))
-svuint32_t svmls_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u64_x)))
-svuint64_t svmls_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u16_x)))
-svuint16_t svmls_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s8_x)))
-svint8_t svmls_x(svbool_t, svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s32_x)))
-svint32_t svmls_x(svbool_t, svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s64_x)))
-svint64_t svmls_x(svbool_t, svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s16_x)))
-svint16_t svmls_x(svbool_t, svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u8_z)))
-svuint8_t svmls_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u32_z)))
-svuint32_t svmls_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u64_z)))
-svuint64_t svmls_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u16_z)))
-svuint16_t svmls_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s8_z)))
-svint8_t svmls_z(svbool_t, svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s32_z)))
-svint32_t svmls_z(svbool_t, svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s64_z)))
-svint64_t svmls_z(svbool_t, svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s16_z)))
-svint16_t svmls_z(svbool_t, svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f64_m)))
-svfloat64_t svmls_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f32_m)))
-svfloat32_t svmls_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f16_m)))
-svfloat16_t svmls_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f64_x)))
-svfloat64_t svmls_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f32_x)))
-svfloat32_t svmls_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f16_x)))
-svfloat16_t svmls_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f64_z)))
-svfloat64_t svmls_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f32_z)))
-svfloat32_t svmls_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f16_z)))
-svfloat16_t svmls_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u8_m)))
-svuint8_t svmls_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u32_m)))
-svuint32_t svmls_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u64_m)))
-svuint64_t svmls_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u16_m)))
-svuint16_t svmls_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s8_m)))
-svint8_t svmls_m(svbool_t, svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s32_m)))
-svint32_t svmls_m(svbool_t, svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s64_m)))
-svint64_t svmls_m(svbool_t, svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s16_m)))
-svint16_t svmls_m(svbool_t, svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u8_x)))
-svuint8_t svmls_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u32_x)))
-svuint32_t svmls_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u64_x)))
-svuint64_t svmls_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u16_x)))
-svuint16_t svmls_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s8_x)))
-svint8_t svmls_x(svbool_t, svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s32_x)))
-svint32_t svmls_x(svbool_t, svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s64_x)))
-svint64_t svmls_x(svbool_t, svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s16_x)))
-svint16_t svmls_x(svbool_t, svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u8_z)))
-svuint8_t svmls_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u32_z)))
-svuint32_t svmls_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u64_z)))
-svuint64_t svmls_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u16_z)))
-svuint16_t svmls_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s8_z)))
-svint8_t svmls_z(svbool_t, svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s32_z)))
-svint32_t svmls_z(svbool_t, svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s64_z)))
-svint64_t svmls_z(svbool_t, svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s16_z)))
-svint16_t svmls_z(svbool_t, svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_f64)))
-svfloat64_t svmls_lane(svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_f32)))
-svfloat32_t svmls_lane(svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_f16)))
-svfloat16_t svmls_lane(svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmov_b_z)))
-svbool_t svmov_z(svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f64_m)))
-svfloat64_t svmsb_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f32_m)))
-svfloat32_t svmsb_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f16_m)))
-svfloat16_t svmsb_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f64_x)))
-svfloat64_t svmsb_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f32_x)))
-svfloat32_t svmsb_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f16_x)))
-svfloat16_t svmsb_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f64_z)))
-svfloat64_t svmsb_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f32_z)))
-svfloat32_t svmsb_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f16_z)))
-svfloat16_t svmsb_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u8_m)))
-svuint8_t svmsb_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u32_m)))
-svuint32_t svmsb_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u64_m)))
-svuint64_t svmsb_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u16_m)))
-svuint16_t svmsb_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s8_m)))
-svint8_t svmsb_m(svbool_t, svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s32_m)))
-svint32_t svmsb_m(svbool_t, svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s64_m)))
-svint64_t svmsb_m(svbool_t, svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s16_m)))
-svint16_t svmsb_m(svbool_t, svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u8_x)))
-svuint8_t svmsb_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u32_x)))
-svuint32_t svmsb_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u64_x)))
-svuint64_t svmsb_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u16_x)))
-svuint16_t svmsb_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s8_x)))
-svint8_t svmsb_x(svbool_t, svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s32_x)))
-svint32_t svmsb_x(svbool_t, svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s64_x)))
-svint64_t svmsb_x(svbool_t, svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s16_x)))
-svint16_t svmsb_x(svbool_t, svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u8_z)))
-svuint8_t svmsb_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u32_z)))
-svuint32_t svmsb_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u64_z)))
-svuint64_t svmsb_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u16_z)))
-svuint16_t svmsb_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s8_z)))
-svint8_t svmsb_z(svbool_t, svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s32_z)))
-svint32_t svmsb_z(svbool_t, svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s64_z)))
-svint64_t svmsb_z(svbool_t, svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s16_z)))
-svint16_t svmsb_z(svbool_t, svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f64_m)))
-svfloat64_t svmsb_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f32_m)))
-svfloat32_t svmsb_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f16_m)))
-svfloat16_t svmsb_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f64_x)))
-svfloat64_t svmsb_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f32_x)))
-svfloat32_t svmsb_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f16_x)))
-svfloat16_t svmsb_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f64_z)))
-svfloat64_t svmsb_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f32_z)))
-svfloat32_t svmsb_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f16_z)))
-svfloat16_t svmsb_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u8_m)))
-svuint8_t svmsb_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u32_m)))
-svuint32_t svmsb_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u64_m)))
-svuint64_t svmsb_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u16_m)))
-svuint16_t svmsb_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s8_m)))
-svint8_t svmsb_m(svbool_t, svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s32_m)))
-svint32_t svmsb_m(svbool_t, svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s64_m)))
-svint64_t svmsb_m(svbool_t, svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s16_m)))
-svint16_t svmsb_m(svbool_t, svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u8_x)))
-svuint8_t svmsb_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u32_x)))
-svuint32_t svmsb_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u64_x)))
-svuint64_t svmsb_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u16_x)))
-svuint16_t svmsb_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s8_x)))
-svint8_t svmsb_x(svbool_t, svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s32_x)))
-svint32_t svmsb_x(svbool_t, svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s64_x)))
-svint64_t svmsb_x(svbool_t, svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s16_x)))
-svint16_t svmsb_x(svbool_t, svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u8_z)))
-svuint8_t svmsb_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u32_z)))
-svuint32_t svmsb_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u64_z)))
-svuint64_t svmsb_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u16_z)))
-svuint16_t svmsb_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s8_z)))
-svint8_t svmsb_z(svbool_t, svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s32_z)))
-svint32_t svmsb_z(svbool_t, svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s64_z)))
-svint64_t svmsb_z(svbool_t, svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s16_z)))
-svint16_t svmsb_z(svbool_t, svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f64_m)))
-svfloat64_t svmul_m(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f32_m)))
-svfloat32_t svmul_m(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f16_m)))
-svfloat16_t svmul_m(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f64_x)))
-svfloat64_t svmul_x(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f32_x)))
-svfloat32_t svmul_x(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f16_x)))
-svfloat16_t svmul_x(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f64_z)))
-svfloat64_t svmul_z(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f32_z)))
-svfloat32_t svmul_z(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f16_z)))
-svfloat16_t svmul_z(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u8_m)))
-svuint8_t svmul_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u32_m)))
-svuint32_t svmul_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u64_m)))
-svuint64_t svmul_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u16_m)))
-svuint16_t svmul_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s8_m)))
-svint8_t svmul_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s32_m)))
-svint32_t svmul_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s64_m)))
-svint64_t svmul_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s16_m)))
-svint16_t svmul_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u8_x)))
-svuint8_t svmul_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u32_x)))
-svuint32_t svmul_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u64_x)))
-svuint64_t svmul_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u16_x)))
-svuint16_t svmul_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s8_x)))
-svint8_t svmul_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s32_x)))
-svint32_t svmul_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s64_x)))
-svint64_t svmul_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s16_x)))
-svint16_t svmul_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u8_z)))
-svuint8_t svmul_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u32_z)))
-svuint32_t svmul_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u64_z)))
-svuint64_t svmul_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u16_z)))
-svuint16_t svmul_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s8_z)))
-svint8_t svmul_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s32_z)))
-svint32_t svmul_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s64_z)))
-svint64_t svmul_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s16_z)))
-svint16_t svmul_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f64_m)))
-svfloat64_t svmul_m(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f32_m)))
-svfloat32_t svmul_m(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f16_m)))
-svfloat16_t svmul_m(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f64_x)))
-svfloat64_t svmul_x(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f32_x)))
-svfloat32_t svmul_x(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f16_x)))
-svfloat16_t svmul_x(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f64_z)))
-svfloat64_t svmul_z(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f32_z)))
-svfloat32_t svmul_z(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f16_z)))
-svfloat16_t svmul_z(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u8_m)))
-svuint8_t svmul_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u32_m)))
-svuint32_t svmul_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u64_m)))
-svuint64_t svmul_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u16_m)))
-svuint16_t svmul_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s8_m)))
-svint8_t svmul_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s32_m)))
-svint32_t svmul_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s64_m)))
-svint64_t svmul_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s16_m)))
-svint16_t svmul_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u8_x)))
-svuint8_t svmul_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u32_x)))
-svuint32_t svmul_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u64_x)))
-svuint64_t svmul_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u16_x)))
-svuint16_t svmul_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s8_x)))
-svint8_t svmul_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s32_x)))
-svint32_t svmul_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s64_x)))
-svint64_t svmul_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s16_x)))
-svint16_t svmul_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u8_z)))
-svuint8_t svmul_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u32_z)))
-svuint32_t svmul_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u64_z)))
-svuint64_t svmul_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u16_z)))
-svuint16_t svmul_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s8_z)))
-svint8_t svmul_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s32_z)))
-svint32_t svmul_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s64_z)))
-svint64_t svmul_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s16_z)))
-svint16_t svmul_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_f64)))
-svfloat64_t svmul_lane(svfloat64_t, svfloat64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_f32)))
-svfloat32_t svmul_lane(svfloat32_t, svfloat32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_f16)))
-svfloat16_t svmul_lane(svfloat16_t, svfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s8_m)))
-svint8_t svmulh_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s32_m)))
-svint32_t svmulh_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s64_m)))
-svint64_t svmulh_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s16_m)))
-svint16_t svmulh_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s8_x)))
-svint8_t svmulh_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s32_x)))
-svint32_t svmulh_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s64_x)))
-svint64_t svmulh_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s16_x)))
-svint16_t svmulh_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s8_z)))
-svint8_t svmulh_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s32_z)))
-svint32_t svmulh_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s64_z)))
-svint64_t svmulh_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s16_z)))
-svint16_t svmulh_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u8_m)))
-svuint8_t svmulh_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u32_m)))
-svuint32_t svmulh_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u64_m)))
-svuint64_t svmulh_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u16_m)))
-svuint16_t svmulh_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u8_x)))
-svuint8_t svmulh_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u32_x)))
-svuint32_t svmulh_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u64_x)))
-svuint64_t svmulh_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u16_x)))
-svuint16_t svmulh_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u8_z)))
-svuint8_t svmulh_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u32_z)))
-svuint32_t svmulh_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u64_z)))
-svuint64_t svmulh_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u16_z)))
-svuint16_t svmulh_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s8_m)))
-svint8_t svmulh_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s32_m)))
-svint32_t svmulh_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s64_m)))
-svint64_t svmulh_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s16_m)))
-svint16_t svmulh_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s8_x)))
-svint8_t svmulh_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s32_x)))
-svint32_t svmulh_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s64_x)))
-svint64_t svmulh_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s16_x)))
-svint16_t svmulh_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s8_z)))
-svint8_t svmulh_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s32_z)))
-svint32_t svmulh_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s64_z)))
-svint64_t svmulh_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s16_z)))
-svint16_t svmulh_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u8_m)))
-svuint8_t svmulh_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u32_m)))
-svuint32_t svmulh_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u64_m)))
-svuint64_t svmulh_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u16_m)))
-svuint16_t svmulh_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u8_x)))
-svuint8_t svmulh_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u32_x)))
-svuint32_t svmulh_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u64_x)))
-svuint64_t svmulh_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u16_x)))
-svuint16_t svmulh_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u8_z)))
-svuint8_t svmulh_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u32_z)))
-svuint32_t svmulh_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u64_z)))
-svuint64_t svmulh_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u16_z)))
-svuint16_t svmulh_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f64_m)))
-svfloat64_t svmulx_m(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f32_m)))
-svfloat32_t svmulx_m(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f16_m)))
-svfloat16_t svmulx_m(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f64_x)))
-svfloat64_t svmulx_x(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f32_x)))
-svfloat32_t svmulx_x(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f16_x)))
-svfloat16_t svmulx_x(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f64_z)))
-svfloat64_t svmulx_z(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f32_z)))
-svfloat32_t svmulx_z(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f16_z)))
-svfloat16_t svmulx_z(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f64_m)))
-svfloat64_t svmulx_m(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f32_m)))
-svfloat32_t svmulx_m(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f16_m)))
-svfloat16_t svmulx_m(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f64_x)))
-svfloat64_t svmulx_x(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f32_x)))
-svfloat32_t svmulx_x(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f16_x)))
-svfloat16_t svmulx_x(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f64_z)))
-svfloat64_t svmulx_z(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f32_z)))
-svfloat32_t svmulx_z(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f16_z)))
-svfloat16_t svmulx_z(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnand_b_z)))
-svbool_t svnand_z(svbool_t, svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f64_m)))
-svfloat64_t svneg_m(svfloat64_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f32_m)))
-svfloat32_t svneg_m(svfloat32_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f16_m)))
-svfloat16_t svneg_m(svfloat16_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f64_x)))
-svfloat64_t svneg_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f32_x)))
-svfloat32_t svneg_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f16_x)))
-svfloat16_t svneg_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f64_z)))
-svfloat64_t svneg_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f32_z)))
-svfloat32_t svneg_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f16_z)))
-svfloat16_t svneg_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s8_m)))
-svint8_t svneg_m(svint8_t, svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s32_m)))
-svint32_t svneg_m(svint32_t, svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s64_m)))
-svint64_t svneg_m(svint64_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s16_m)))
-svint16_t svneg_m(svint16_t, svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s8_x)))
-svint8_t svneg_x(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s32_x)))
-svint32_t svneg_x(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s64_x)))
-svint64_t svneg_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s16_x)))
-svint16_t svneg_x(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s8_z)))
-svint8_t svneg_z(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s32_z)))
-svint32_t svneg_z(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s64_z)))
-svint64_t svneg_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s16_z)))
-svint16_t svneg_z(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f64_m)))
-svfloat64_t svnmad_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f32_m)))
-svfloat32_t svnmad_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f16_m)))
-svfloat16_t svnmad_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f64_x)))
-svfloat64_t svnmad_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f32_x)))
-svfloat32_t svnmad_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f16_x)))
-svfloat16_t svnmad_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f64_z)))
-svfloat64_t svnmad_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f32_z)))
-svfloat32_t svnmad_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f16_z)))
-svfloat16_t svnmad_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f64_m)))
-svfloat64_t svnmad_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f32_m)))
-svfloat32_t svnmad_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f16_m)))
-svfloat16_t svnmad_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f64_x)))
-svfloat64_t svnmad_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f32_x)))
-svfloat32_t svnmad_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f16_x)))
-svfloat16_t svnmad_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f64_z)))
-svfloat64_t svnmad_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f32_z)))
-svfloat32_t svnmad_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f16_z)))
-svfloat16_t svnmad_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f64_m)))
-svfloat64_t svnmla_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f32_m)))
-svfloat32_t svnmla_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f16_m)))
-svfloat16_t svnmla_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f64_x)))
-svfloat64_t svnmla_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f32_x)))
-svfloat32_t svnmla_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f16_x)))
-svfloat16_t svnmla_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f64_z)))
-svfloat64_t svnmla_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f32_z)))
-svfloat32_t svnmla_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f16_z)))
-svfloat16_t svnmla_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f64_m)))
-svfloat64_t svnmla_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f32_m)))
-svfloat32_t svnmla_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f16_m)))
-svfloat16_t svnmla_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f64_x)))
-svfloat64_t svnmla_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f32_x)))
-svfloat32_t svnmla_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f16_x)))
-svfloat16_t svnmla_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f64_z)))
-svfloat64_t svnmla_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f32_z)))
-svfloat32_t svnmla_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f16_z)))
-svfloat16_t svnmla_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f64_m)))
-svfloat64_t svnmls_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f32_m)))
-svfloat32_t svnmls_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f16_m)))
-svfloat16_t svnmls_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f64_x)))
-svfloat64_t svnmls_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f32_x)))
-svfloat32_t svnmls_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f16_x)))
-svfloat16_t svnmls_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f64_z)))
-svfloat64_t svnmls_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f32_z)))
-svfloat32_t svnmls_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f16_z)))
-svfloat16_t svnmls_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f64_m)))
-svfloat64_t svnmls_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f32_m)))
-svfloat32_t svnmls_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f16_m)))
-svfloat16_t svnmls_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f64_x)))
-svfloat64_t svnmls_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f32_x)))
-svfloat32_t svnmls_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f16_x)))
-svfloat16_t svnmls_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f64_z)))
-svfloat64_t svnmls_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f32_z)))
-svfloat32_t svnmls_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f16_z)))
-svfloat16_t svnmls_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f64_m)))
-svfloat64_t svnmsb_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f32_m)))
-svfloat32_t svnmsb_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f16_m)))
-svfloat16_t svnmsb_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f64_x)))
-svfloat64_t svnmsb_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f32_x)))
-svfloat32_t svnmsb_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f16_x)))
-svfloat16_t svnmsb_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f64_z)))
-svfloat64_t svnmsb_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f32_z)))
-svfloat32_t svnmsb_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f16_z)))
-svfloat16_t svnmsb_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f64_m)))
-svfloat64_t svnmsb_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f32_m)))
-svfloat32_t svnmsb_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f16_m)))
-svfloat16_t svnmsb_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f64_x)))
-svfloat64_t svnmsb_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f32_x)))
-svfloat32_t svnmsb_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f16_x)))
-svfloat16_t svnmsb_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f64_z)))
-svfloat64_t svnmsb_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f32_z)))
-svfloat32_t svnmsb_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f16_z)))
-svfloat16_t svnmsb_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnor_b_z)))
-svbool_t svnor_z(svbool_t, svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_b_z)))
-svbool_t svnot_z(svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u8_m)))
-svuint8_t svnot_m(svuint8_t, svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u32_m)))
-svuint32_t svnot_m(svuint32_t, svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u64_m)))
-svuint64_t svnot_m(svuint64_t, svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u16_m)))
-svuint16_t svnot_m(svuint16_t, svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s8_m)))
-svint8_t svnot_m(svint8_t, svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s32_m)))
-svint32_t svnot_m(svint32_t, svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s64_m)))
-svint64_t svnot_m(svint64_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s16_m)))
-svint16_t svnot_m(svint16_t, svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u8_x)))
-svuint8_t svnot_x(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u32_x)))
-svuint32_t svnot_x(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u64_x)))
-svuint64_t svnot_x(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u16_x)))
-svuint16_t svnot_x(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s8_x)))
-svint8_t svnot_x(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s32_x)))
-svint32_t svnot_x(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s64_x)))
-svint64_t svnot_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s16_x)))
-svint16_t svnot_x(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u8_z)))
-svuint8_t svnot_z(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u32_z)))
-svuint32_t svnot_z(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u64_z)))
-svuint64_t svnot_z(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u16_z)))
-svuint16_t svnot_z(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s8_z)))
-svint8_t svnot_z(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s32_z)))
-svint32_t svnot_z(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s64_z)))
-svint64_t svnot_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s16_z)))
-svint16_t svnot_z(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorn_b_z)))
-svbool_t svorn_z(svbool_t, svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_b_z)))
-svbool_t svorr_z(svbool_t, svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u8_m)))
-svuint8_t svorr_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u32_m)))
-svuint32_t svorr_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u64_m)))
-svuint64_t svorr_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u16_m)))
-svuint16_t svorr_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s8_m)))
-svint8_t svorr_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s32_m)))
-svint32_t svorr_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s64_m)))
-svint64_t svorr_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s16_m)))
-svint16_t svorr_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u8_x)))
-svuint8_t svorr_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u32_x)))
-svuint32_t svorr_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u64_x)))
-svuint64_t svorr_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u16_x)))
-svuint16_t svorr_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s8_x)))
-svint8_t svorr_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s32_x)))
-svint32_t svorr_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s64_x)))
-svint64_t svorr_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s16_x)))
-svint16_t svorr_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u8_z)))
-svuint8_t svorr_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u32_z)))
-svuint32_t svorr_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u64_z)))
-svuint64_t svorr_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u16_z)))
-svuint16_t svorr_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s8_z)))
-svint8_t svorr_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s32_z)))
-svint32_t svorr_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s64_z)))
-svint64_t svorr_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s16_z)))
-svint16_t svorr_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u8_m)))
-svuint8_t svorr_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u32_m)))
-svuint32_t svorr_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u64_m)))
-svuint64_t svorr_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u16_m)))
-svuint16_t svorr_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s8_m)))
-svint8_t svorr_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s32_m)))
-svint32_t svorr_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s64_m)))
-svint64_t svorr_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s16_m)))
-svint16_t svorr_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u8_x)))
-svuint8_t svorr_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u32_x)))
-svuint32_t svorr_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u64_x)))
-svuint64_t svorr_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u16_x)))
-svuint16_t svorr_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s8_x)))
-svint8_t svorr_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s32_x)))
-svint32_t svorr_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s64_x)))
-svint64_t svorr_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s16_x)))
-svint16_t svorr_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u8_z)))
-svuint8_t svorr_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u32_z)))
-svuint32_t svorr_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u64_z)))
-svuint64_t svorr_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u16_z)))
-svuint16_t svorr_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s8_z)))
-svint8_t svorr_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s32_z)))
-svint32_t svorr_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s64_z)))
-svint64_t svorr_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s16_z)))
-svint16_t svorr_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u8)))
-uint8_t svorv(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u32)))
-uint32_t svorv(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u64)))
-uint64_t svorv(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u16)))
-uint16_t svorv(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s8)))
-int8_t svorv(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s32)))
-int32_t svorv(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s64)))
-int64_t svorv(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s16)))
-int16_t svorv(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpfalse_b)))
-svbool_t svpfalse(void);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpfirst_b)))
-svbool_t svpfirst(svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u32base)))
-void svprfb_gather(svbool_t, svuint32_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u64base)))
-void svprfb_gather(svbool_t, svuint64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u32base_offset)))
-void svprfb_gather_offset(svbool_t, svuint32_t, int64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u64base_offset)))
-void svprfb_gather_offset(svbool_t, svuint64_t, int64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_s32offset)))
-void svprfb_gather_offset(svbool_t, void const *, svint32_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u32offset)))
-void svprfb_gather_offset(svbool_t, void const *, svuint32_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_s64offset)))
-void svprfb_gather_offset(svbool_t, void const *, svint64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u64offset)))
-void svprfb_gather_offset(svbool_t, void const *, svuint64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u32base)))
-void svprfd_gather(svbool_t, svuint32_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u64base)))
-void svprfd_gather(svbool_t, svuint64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u32base_index)))
-void svprfd_gather_index(svbool_t, svuint32_t, int64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u64base_index)))
-void svprfd_gather_index(svbool_t, svuint64_t, int64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_s32index)))
-void svprfd_gather_index(svbool_t, void const *, svint32_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u32index)))
-void svprfd_gather_index(svbool_t, void const *, svuint32_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_s64index)))
-void svprfd_gather_index(svbool_t, void const *, svint64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u64index)))
-void svprfd_gather_index(svbool_t, void const *, svuint64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u32base)))
-void svprfh_gather(svbool_t, svuint32_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u64base)))
-void svprfh_gather(svbool_t, svuint64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u32base_index)))
-void svprfh_gather_index(svbool_t, svuint32_t, int64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u64base_index)))
-void svprfh_gather_index(svbool_t, svuint64_t, int64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_s32index)))
-void svprfh_gather_index(svbool_t, void const *, svint32_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u32index)))
-void svprfh_gather_index(svbool_t, void const *, svuint32_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_s64index)))
-void svprfh_gather_index(svbool_t, void const *, svint64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u64index)))
-void svprfh_gather_index(svbool_t, void const *, svuint64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u32base)))
-void svprfw_gather(svbool_t, svuint32_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u64base)))
-void svprfw_gather(svbool_t, svuint64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u32base_index)))
-void svprfw_gather_index(svbool_t, svuint32_t, int64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u64base_index)))
-void svprfw_gather_index(svbool_t, svuint64_t, int64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_s32index)))
-void svprfw_gather_index(svbool_t, void const *, svint32_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u32index)))
-void svprfw_gather_index(svbool_t, void const *, svuint32_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_s64index)))
-void svprfw_gather_index(svbool_t, void const *, svint64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u64index)))
-void svprfw_gather_index(svbool_t, void const *, svuint64_t, enum svprfop);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8)))
-svint8_t svqadd(svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32)))
-svint32_t svqadd(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64)))
-svint64_t svqadd(svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16)))
-svint16_t svqadd(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8)))
-svuint8_t svqadd(svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32)))
-svuint32_t svqadd(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64)))
-svuint64_t svqadd(svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16)))
-svuint16_t svqadd(svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8)))
-svint8_t svqadd(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32)))
-svint32_t svqadd(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64)))
-svint64_t svqadd(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16)))
-svint16_t svqadd(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8)))
-svuint8_t svqadd(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32)))
-svuint32_t svqadd(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64)))
-svuint64_t svqadd(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16)))
-svuint16_t svqadd(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_s32)))
-int32_t svqdecb(int32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_s64)))
-int64_t svqdecb(int64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_u32)))
-uint32_t svqdecb(uint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_u64)))
-uint64_t svqdecb(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_s32)))
-int32_t svqdecb_pat(int32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_s64)))
-int64_t svqdecb_pat(int64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_u32)))
-uint32_t svqdecb_pat(uint32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_u64)))
-uint64_t svqdecb_pat(uint64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_s32)))
-int32_t svqdecd(int32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_s64)))
-int64_t svqdecd(int64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_u32)))
-uint32_t svqdecd(uint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_u64)))
-uint64_t svqdecd(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_s64)))
-svint64_t svqdecd(svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_u64)))
-svuint64_t svqdecd(svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_s32)))
-int32_t svqdecd_pat(int32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_s64)))
-int64_t svqdecd_pat(int64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_u32)))
-uint32_t svqdecd_pat(uint32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_u64)))
-uint64_t svqdecd_pat(uint64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_s64)))
-svint64_t svqdecd_pat(svint64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_u64)))
-svuint64_t svqdecd_pat(svuint64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_s32)))
-int32_t svqdech(int32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_s64)))
-int64_t svqdech(int64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_u32)))
-uint32_t svqdech(uint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_u64)))
-uint64_t svqdech(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_s16)))
-svint16_t svqdech(svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_u16)))
-svuint16_t svqdech(svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_s32)))
-int32_t svqdech_pat(int32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_s64)))
-int64_t svqdech_pat(int64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_u32)))
-uint32_t svqdech_pat(uint32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_u64)))
-uint64_t svqdech_pat(uint64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_s16)))
-svint16_t svqdech_pat(svint16_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_u16)))
-svuint16_t svqdech_pat(svuint16_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b8)))
-int32_t svqdecp_b8(int32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b32)))
-int32_t svqdecp_b32(int32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b64)))
-int32_t svqdecp_b64(int32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b16)))
-int32_t svqdecp_b16(int32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b8)))
-int64_t svqdecp_b8(int64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b32)))
-int64_t svqdecp_b32(int64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b64)))
-int64_t svqdecp_b64(int64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b16)))
-int64_t svqdecp_b16(int64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b8)))
-uint32_t svqdecp_b8(uint32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b32)))
-uint32_t svqdecp_b32(uint32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b64)))
-uint32_t svqdecp_b64(uint32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b16)))
-uint32_t svqdecp_b16(uint32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b8)))
-uint64_t svqdecp_b8(uint64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b32)))
-uint64_t svqdecp_b32(uint64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b64)))
-uint64_t svqdecp_b64(uint64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b16)))
-uint64_t svqdecp_b16(uint64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_s32)))
-svint32_t svqdecp(svint32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_s64)))
-svint64_t svqdecp(svint64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_s16)))
-svint16_t svqdecp(svint16_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_u32)))
-svuint32_t svqdecp(svuint32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_u64)))
-svuint64_t svqdecp(svuint64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_u16)))
-svuint16_t svqdecp(svuint16_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_s32)))
-int32_t svqdecw(int32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_s64)))
-int64_t svqdecw(int64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_u32)))
-uint32_t svqdecw(uint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_u64)))
-uint64_t svqdecw(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_s32)))
-svint32_t svqdecw(svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_u32)))
-svuint32_t svqdecw(svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_s32)))
-int32_t svqdecw_pat(int32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_s64)))
-int64_t svqdecw_pat(int64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_u32)))
-uint32_t svqdecw_pat(uint32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_u64)))
-uint64_t svqdecw_pat(uint64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_s32)))
-svint32_t svqdecw_pat(svint32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_u32)))
-svuint32_t svqdecw_pat(svuint32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_s32)))
-int32_t svqincb(int32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_s64)))
-int64_t svqincb(int64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_u32)))
-uint32_t svqincb(uint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_u64)))
-uint64_t svqincb(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_s32)))
-int32_t svqincb_pat(int32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_s64)))
-int64_t svqincb_pat(int64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_u32)))
-uint32_t svqincb_pat(uint32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_u64)))
-uint64_t svqincb_pat(uint64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_s32)))
-int32_t svqincd(int32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_s64)))
-int64_t svqincd(int64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_u32)))
-uint32_t svqincd(uint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_u64)))
-uint64_t svqincd(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_s64)))
-svint64_t svqincd(svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_u64)))
-svuint64_t svqincd(svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_s32)))
-int32_t svqincd_pat(int32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_s64)))
-int64_t svqincd_pat(int64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_u32)))
-uint32_t svqincd_pat(uint32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_u64)))
-uint64_t svqincd_pat(uint64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_s64)))
-svint64_t svqincd_pat(svint64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_u64)))
-svuint64_t svqincd_pat(svuint64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_s32)))
-int32_t svqinch(int32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_s64)))
-int64_t svqinch(int64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_u32)))
-uint32_t svqinch(uint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_u64)))
-uint64_t svqinch(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_s16)))
-svint16_t svqinch(svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_u16)))
-svuint16_t svqinch(svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_s32)))
-int32_t svqinch_pat(int32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_s64)))
-int64_t svqinch_pat(int64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_u32)))
-uint32_t svqinch_pat(uint32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_u64)))
-uint64_t svqinch_pat(uint64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_s16)))
-svint16_t svqinch_pat(svint16_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_u16)))
-svuint16_t svqinch_pat(svuint16_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b8)))
-int32_t svqincp_b8(int32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b32)))
-int32_t svqincp_b32(int32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b64)))
-int32_t svqincp_b64(int32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b16)))
-int32_t svqincp_b16(int32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b8)))
-int64_t svqincp_b8(int64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b32)))
-int64_t svqincp_b32(int64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b64)))
-int64_t svqincp_b64(int64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b16)))
-int64_t svqincp_b16(int64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b8)))
-uint32_t svqincp_b8(uint32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b32)))
-uint32_t svqincp_b32(uint32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b64)))
-uint32_t svqincp_b64(uint32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b16)))
-uint32_t svqincp_b16(uint32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b8)))
-uint64_t svqincp_b8(uint64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b32)))
-uint64_t svqincp_b32(uint64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b64)))
-uint64_t svqincp_b64(uint64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b16)))
-uint64_t svqincp_b16(uint64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_s32)))
-svint32_t svqincp(svint32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_s64)))
-svint64_t svqincp(svint64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_s16)))
-svint16_t svqincp(svint16_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_u32)))
-svuint32_t svqincp(svuint32_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_u64)))
-svuint64_t svqincp(svuint64_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_u16)))
-svuint16_t svqincp(svuint16_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_s32)))
-int32_t svqincw(int32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_s64)))
-int64_t svqincw(int64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_u32)))
-uint32_t svqincw(uint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_u64)))
-uint64_t svqincw(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_s32)))
-svint32_t svqincw(svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_u32)))
-svuint32_t svqincw(svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_s32)))
-int32_t svqincw_pat(int32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_s64)))
-int64_t svqincw_pat(int64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_u32)))
-uint32_t svqincw_pat(uint32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_u64)))
-uint64_t svqincw_pat(uint64_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_s32)))
-svint32_t svqincw_pat(svint32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_u32)))
-svuint32_t svqincw_pat(svuint32_t, enum svpattern, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8)))
-svint8_t svqsub(svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32)))
-svint32_t svqsub(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64)))
-svint64_t svqsub(svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16)))
-svint16_t svqsub(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8)))
-svuint8_t svqsub(svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32)))
-svuint32_t svqsub(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64)))
-svuint64_t svqsub(svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16)))
-svuint16_t svqsub(svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8)))
-svint8_t svqsub(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32)))
-svint32_t svqsub(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64)))
-svint64_t svqsub(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16)))
-svint16_t svqsub(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8)))
-svuint8_t svqsub(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32)))
-svuint32_t svqsub(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64)))
-svuint64_t svqsub(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16)))
-svuint16_t svqsub(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u8_m)))
-svuint8_t svrbit_m(svuint8_t, svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u32_m)))
-svuint32_t svrbit_m(svuint32_t, svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u64_m)))
-svuint64_t svrbit_m(svuint64_t, svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u16_m)))
-svuint16_t svrbit_m(svuint16_t, svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s8_m)))
-svint8_t svrbit_m(svint8_t, svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s32_m)))
-svint32_t svrbit_m(svint32_t, svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s64_m)))
-svint64_t svrbit_m(svint64_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s16_m)))
-svint16_t svrbit_m(svint16_t, svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u8_x)))
-svuint8_t svrbit_x(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u32_x)))
-svuint32_t svrbit_x(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u64_x)))
-svuint64_t svrbit_x(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u16_x)))
-svuint16_t svrbit_x(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s8_x)))
-svint8_t svrbit_x(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s32_x)))
-svint32_t svrbit_x(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s64_x)))
-svint64_t svrbit_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s16_x)))
-svint16_t svrbit_x(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u8_z)))
-svuint8_t svrbit_z(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u32_z)))
-svuint32_t svrbit_z(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u64_z)))
-svuint64_t svrbit_z(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u16_z)))
-svuint16_t svrbit_z(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s8_z)))
-svint8_t svrbit_z(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s32_z)))
-svint32_t svrbit_z(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s64_z)))
-svint64_t svrbit_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s16_z)))
-svint16_t svrbit_z(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_f64)))
-svfloat64_t svrecpe(svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_f32)))
-svfloat32_t svrecpe(svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_f16)))
-svfloat16_t svrecpe(svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecps_f64)))
-svfloat64_t svrecps(svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecps_f32)))
-svfloat32_t svrecps(svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecps_f16)))
-svfloat16_t svrecps(svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f64_m)))
-svfloat64_t svrecpx_m(svfloat64_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f32_m)))
-svfloat32_t svrecpx_m(svfloat32_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f16_m)))
-svfloat16_t svrecpx_m(svfloat16_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f64_x)))
-svfloat64_t svrecpx_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f32_x)))
-svfloat32_t svrecpx_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f16_x)))
-svfloat16_t svrecpx_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f64_z)))
-svfloat64_t svrecpx_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f32_z)))
-svfloat32_t svrecpx_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f16_z)))
-svfloat16_t svrecpx_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u8)))
-svuint8_t svrev(svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u32)))
-svuint32_t svrev(svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u64)))
-svuint64_t svrev(svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u16)))
-svuint16_t svrev(svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s8)))
-svint8_t svrev(svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_f64)))
-svfloat64_t svrev(svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_f32)))
-svfloat32_t svrev(svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_f16)))
-svfloat16_t svrev(svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s32)))
-svint32_t svrev(svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s64)))
-svint64_t svrev(svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s16)))
-svint16_t svrev(svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u32_m)))
-svuint32_t svrevb_m(svuint32_t, svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u64_m)))
-svuint64_t svrevb_m(svuint64_t, svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u16_m)))
-svuint16_t svrevb_m(svuint16_t, svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s32_m)))
-svint32_t svrevb_m(svint32_t, svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s64_m)))
-svint64_t svrevb_m(svint64_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s16_m)))
-svint16_t svrevb_m(svint16_t, svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u32_x)))
-svuint32_t svrevb_x(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u64_x)))
-svuint64_t svrevb_x(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u16_x)))
-svuint16_t svrevb_x(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s32_x)))
-svint32_t svrevb_x(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s64_x)))
-svint64_t svrevb_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s16_x)))
-svint16_t svrevb_x(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u32_z)))
-svuint32_t svrevb_z(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u64_z)))
-svuint64_t svrevb_z(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u16_z)))
-svuint16_t svrevb_z(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s32_z)))
-svint32_t svrevb_z(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s64_z)))
-svint64_t svrevb_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s16_z)))
-svint16_t svrevb_z(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_m)))
-svuint32_t svrevh_m(svuint32_t, svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u64_m)))
-svuint64_t svrevh_m(svuint64_t, svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s32_m)))
-svint32_t svrevh_m(svint32_t, svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s64_m)))
-svint64_t svrevh_m(svint64_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_x)))
-svuint32_t svrevh_x(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u64_x)))
-svuint64_t svrevh_x(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s32_x)))
-svint32_t svrevh_x(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s64_x)))
-svint64_t svrevh_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_z)))
-svuint32_t svrevh_z(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u64_z)))
-svuint64_t svrevh_z(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s32_z)))
-svint32_t svrevh_z(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s64_z)))
-svint64_t svrevh_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_m)))
-svuint64_t svrevw_m(svuint64_t, svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_s64_m)))
-svint64_t svrevw_m(svint64_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_x)))
-svuint64_t svrevw_x(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_s64_x)))
-svint64_t svrevw_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_z)))
-svuint64_t svrevw_z(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_s64_z)))
-svint64_t svrevw_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f64_m)))
-svfloat64_t svrinta_m(svfloat64_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_m)))
-svfloat32_t svrinta_m(svfloat32_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f16_m)))
-svfloat16_t svrinta_m(svfloat16_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f64_x)))
-svfloat64_t svrinta_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_x)))
-svfloat32_t svrinta_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f16_x)))
-svfloat16_t svrinta_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f64_z)))
-svfloat64_t svrinta_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_z)))
-svfloat32_t svrinta_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f16_z)))
-svfloat16_t svrinta_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f64_m)))
-svfloat64_t svrinti_m(svfloat64_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f32_m)))
-svfloat32_t svrinti_m(svfloat32_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f16_m)))
-svfloat16_t svrinti_m(svfloat16_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f64_x)))
-svfloat64_t svrinti_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f32_x)))
-svfloat32_t svrinti_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f16_x)))
-svfloat16_t svrinti_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f64_z)))
-svfloat64_t svrinti_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f32_z)))
-svfloat32_t svrinti_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f16_z)))
-svfloat16_t svrinti_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f64_m)))
-svfloat64_t svrintm_m(svfloat64_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_m)))
-svfloat32_t svrintm_m(svfloat32_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f16_m)))
-svfloat16_t svrintm_m(svfloat16_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f64_x)))
-svfloat64_t svrintm_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_x)))
-svfloat32_t svrintm_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f16_x)))
-svfloat16_t svrintm_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f64_z)))
-svfloat64_t svrintm_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_z)))
-svfloat32_t svrintm_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f16_z)))
-svfloat16_t svrintm_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f64_m)))
-svfloat64_t svrintn_m(svfloat64_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_m)))
-svfloat32_t svrintn_m(svfloat32_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f16_m)))
-svfloat16_t svrintn_m(svfloat16_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f64_x)))
-svfloat64_t svrintn_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_x)))
-svfloat32_t svrintn_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f16_x)))
-svfloat16_t svrintn_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f64_z)))
-svfloat64_t svrintn_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_z)))
-svfloat32_t svrintn_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f16_z)))
-svfloat16_t svrintn_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f64_m)))
-svfloat64_t svrintp_m(svfloat64_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_m)))
-svfloat32_t svrintp_m(svfloat32_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f16_m)))
-svfloat16_t svrintp_m(svfloat16_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f64_x)))
-svfloat64_t svrintp_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_x)))
-svfloat32_t svrintp_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f16_x)))
-svfloat16_t svrintp_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f64_z)))
-svfloat64_t svrintp_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_z)))
-svfloat32_t svrintp_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f16_z)))
-svfloat16_t svrintp_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f64_m)))
-svfloat64_t svrintx_m(svfloat64_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f32_m)))
-svfloat32_t svrintx_m(svfloat32_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f16_m)))
-svfloat16_t svrintx_m(svfloat16_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f64_x)))
-svfloat64_t svrintx_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f32_x)))
-svfloat32_t svrintx_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f16_x)))
-svfloat16_t svrintx_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f64_z)))
-svfloat64_t svrintx_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f32_z)))
-svfloat32_t svrintx_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f16_z)))
-svfloat16_t svrintx_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f64_m)))
-svfloat64_t svrintz_m(svfloat64_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f32_m)))
-svfloat32_t svrintz_m(svfloat32_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f16_m)))
-svfloat16_t svrintz_m(svfloat16_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f64_x)))
-svfloat64_t svrintz_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f32_x)))
-svfloat32_t svrintz_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f16_x)))
-svfloat16_t svrintz_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f64_z)))
-svfloat64_t svrintz_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f32_z)))
-svfloat32_t svrintz_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f16_z)))
-svfloat16_t svrintz_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_f64)))
-svfloat64_t svrsqrte(svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_f32)))
-svfloat32_t svrsqrte(svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_f16)))
-svfloat16_t svrsqrte(svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrts_f64)))
-svfloat64_t svrsqrts(svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrts_f32)))
-svfloat32_t svrsqrts(svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrts_f16)))
-svfloat16_t svrsqrts(svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f64_m)))
-svfloat64_t svscale_m(svbool_t, svfloat64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f32_m)))
-svfloat32_t svscale_m(svbool_t, svfloat32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f16_m)))
-svfloat16_t svscale_m(svbool_t, svfloat16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f64_x)))
-svfloat64_t svscale_x(svbool_t, svfloat64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f32_x)))
-svfloat32_t svscale_x(svbool_t, svfloat32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f16_x)))
-svfloat16_t svscale_x(svbool_t, svfloat16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f64_z)))
-svfloat64_t svscale_z(svbool_t, svfloat64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f32_z)))
-svfloat32_t svscale_z(svbool_t, svfloat32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f16_z)))
-svfloat16_t svscale_z(svbool_t, svfloat16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f64_m)))
-svfloat64_t svscale_m(svbool_t, svfloat64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f32_m)))
-svfloat32_t svscale_m(svbool_t, svfloat32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f16_m)))
-svfloat16_t svscale_m(svbool_t, svfloat16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f64_x)))
-svfloat64_t svscale_x(svbool_t, svfloat64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f32_x)))
-svfloat32_t svscale_x(svbool_t, svfloat32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f16_x)))
-svfloat16_t svscale_x(svbool_t, svfloat16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f64_z)))
-svfloat64_t svscale_z(svbool_t, svfloat64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f32_z)))
-svfloat32_t svscale_z(svbool_t, svfloat32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f16_z)))
-svfloat16_t svscale_z(svbool_t, svfloat16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_b)))
-svbool_t svsel(svbool_t, svbool_t, svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8)))
-svuint8_t svsel(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u32)))
-svuint32_t svsel(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u64)))
-svuint64_t svsel(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u16)))
-svuint16_t svsel(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s8)))
-svint8_t svsel(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f64)))
-svfloat64_t svsel(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f32)))
-svfloat32_t svsel(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16)))
-svfloat16_t svsel(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s32)))
-svint32_t svsel(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s64)))
-svint64_t svsel(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s16)))
-svint16_t svsel(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u8)))
-svuint8x2_t svset2(svuint8x2_t, uint64_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u32)))
-svuint32x2_t svset2(svuint32x2_t, uint64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u64)))
-svuint64x2_t svset2(svuint64x2_t, uint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u16)))
-svuint16x2_t svset2(svuint16x2_t, uint64_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s8)))
-svint8x2_t svset2(svint8x2_t, uint64_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_f64)))
-svfloat64x2_t svset2(svfloat64x2_t, uint64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_f32)))
-svfloat32x2_t svset2(svfloat32x2_t, uint64_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_f16)))
-svfloat16x2_t svset2(svfloat16x2_t, uint64_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s32)))
-svint32x2_t svset2(svint32x2_t, uint64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s64)))
-svint64x2_t svset2(svint64x2_t, uint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s16)))
-svint16x2_t svset2(svint16x2_t, uint64_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u8)))
-svuint8x3_t svset3(svuint8x3_t, uint64_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u32)))
-svuint32x3_t svset3(svuint32x3_t, uint64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u64)))
-svuint64x3_t svset3(svuint64x3_t, uint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u16)))
-svuint16x3_t svset3(svuint16x3_t, uint64_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s8)))
-svint8x3_t svset3(svint8x3_t, uint64_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_f64)))
-svfloat64x3_t svset3(svfloat64x3_t, uint64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_f32)))
-svfloat32x3_t svset3(svfloat32x3_t, uint64_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_f16)))
-svfloat16x3_t svset3(svfloat16x3_t, uint64_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s32)))
-svint32x3_t svset3(svint32x3_t, uint64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s64)))
-svint64x3_t svset3(svint64x3_t, uint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s16)))
-svint16x3_t svset3(svint16x3_t, uint64_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u8)))
-svuint8x4_t svset4(svuint8x4_t, uint64_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u32)))
-svuint32x4_t svset4(svuint32x4_t, uint64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u64)))
-svuint64x4_t svset4(svuint64x4_t, uint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u16)))
-svuint16x4_t svset4(svuint16x4_t, uint64_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s8)))
-svint8x4_t svset4(svint8x4_t, uint64_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_f64)))
-svfloat64x4_t svset4(svfloat64x4_t, uint64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_f32)))
-svfloat32x4_t svset4(svfloat32x4_t, uint64_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_f16)))
-svfloat16x4_t svset4(svfloat16x4_t, uint64_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s32)))
-svint32x4_t svset4(svint32x4_t, uint64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s64)))
-svint64x4_t svset4(svint64x4_t, uint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s16)))
-svint16x4_t svset4(svint16x4_t, uint64_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u8)))
-svuint8_t svsplice(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u32)))
-svuint32_t svsplice(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u64)))
-svuint64_t svsplice(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u16)))
-svuint16_t svsplice(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s8)))
-svint8_t svsplice(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_f64)))
-svfloat64_t svsplice(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_f32)))
-svfloat32_t svsplice(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_f16)))
-svfloat16_t svsplice(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s32)))
-svint32_t svsplice(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s64)))
-svint64_t svsplice(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s16)))
-svint16_t svsplice(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f64_m)))
-svfloat64_t svsqrt_m(svfloat64_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f32_m)))
-svfloat32_t svsqrt_m(svfloat32_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f16_m)))
-svfloat16_t svsqrt_m(svfloat16_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f64_x)))
-svfloat64_t svsqrt_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f32_x)))
-svfloat32_t svsqrt_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f16_x)))
-svfloat16_t svsqrt_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f64_z)))
-svfloat64_t svsqrt_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f32_z)))
-svfloat32_t svsqrt_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f16_z)))
-svfloat16_t svsqrt_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u8)))
-void svst1(svbool_t, uint8_t *, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u32)))
-void svst1(svbool_t, uint32_t *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u64)))
-void svst1(svbool_t, uint64_t *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u16)))
-void svst1(svbool_t, uint16_t *, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s8)))
-void svst1(svbool_t, int8_t *, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f64)))
-void svst1(svbool_t, float64_t *, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f32)))
-void svst1(svbool_t, float32_t *, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f16)))
-void svst1(svbool_t, float16_t *, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s32)))
-void svst1(svbool_t, int32_t *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s64)))
-void svst1(svbool_t, int64_t *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s16)))
-void svst1(svbool_t, int16_t *, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_index_u32)))
-void svst1_scatter_index(svbool_t, svuint32_t, int64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_index_u64)))
-void svst1_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_index_f64)))
-void svst1_scatter_index(svbool_t, svuint64_t, int64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_index_f32)))
-void svst1_scatter_index(svbool_t, svuint32_t, int64_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_index_s32)))
-void svst1_scatter_index(svbool_t, svuint32_t, int64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_index_s64)))
-void svst1_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_offset_u32)))
-void svst1_scatter_offset(svbool_t, svuint32_t, int64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_offset_u64)))
-void svst1_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_offset_f64)))
-void svst1_scatter_offset(svbool_t, svuint64_t, int64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_offset_f32)))
-void svst1_scatter_offset(svbool_t, svuint32_t, int64_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_offset_s32)))
-void svst1_scatter_offset(svbool_t, svuint32_t, int64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_offset_s64)))
-void svst1_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_u32)))
-void svst1_scatter(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_u64)))
-void svst1_scatter(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_f64)))
-void svst1_scatter(svbool_t, svuint64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_f32)))
-void svst1_scatter(svbool_t, svuint32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_s32)))
-void svst1_scatter(svbool_t, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_s64)))
-void svst1_scatter(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32index_u32)))
-void svst1_scatter_index(svbool_t, uint32_t *, svint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32index_f32)))
-void svst1_scatter_index(svbool_t, float32_t *, svint32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32index_s32)))
-void svst1_scatter_index(svbool_t, int32_t *, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32index_u32)))
-void svst1_scatter_index(svbool_t, uint32_t *, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32index_f32)))
-void svst1_scatter_index(svbool_t, float32_t *, svuint32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32index_s32)))
-void svst1_scatter_index(svbool_t, int32_t *, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64index_u64)))
-void svst1_scatter_index(svbool_t, uint64_t *, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64index_f64)))
-void svst1_scatter_index(svbool_t, float64_t *, svint64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64index_s64)))
-void svst1_scatter_index(svbool_t, int64_t *, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64index_u64)))
-void svst1_scatter_index(svbool_t, uint64_t *, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64index_f64)))
-void svst1_scatter_index(svbool_t, float64_t *, svuint64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64index_s64)))
-void svst1_scatter_index(svbool_t, int64_t *, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32offset_u32)))
-void svst1_scatter_offset(svbool_t, uint32_t *, svint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32offset_f32)))
-void svst1_scatter_offset(svbool_t, float32_t *, svint32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32offset_s32)))
-void svst1_scatter_offset(svbool_t, int32_t *, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32offset_u32)))
-void svst1_scatter_offset(svbool_t, uint32_t *, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32offset_f32)))
-void svst1_scatter_offset(svbool_t, float32_t *, svuint32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32offset_s32)))
-void svst1_scatter_offset(svbool_t, int32_t *, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64offset_u64)))
-void svst1_scatter_offset(svbool_t, uint64_t *, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64offset_f64)))
-void svst1_scatter_offset(svbool_t, float64_t *, svint64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64offset_s64)))
-void svst1_scatter_offset(svbool_t, int64_t *, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64offset_u64)))
-void svst1_scatter_offset(svbool_t, uint64_t *, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64offset_f64)))
-void svst1_scatter_offset(svbool_t, float64_t *, svuint64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64offset_s64)))
-void svst1_scatter_offset(svbool_t, int64_t *, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u8)))
-void svst1_vnum(svbool_t, uint8_t *, int64_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u32)))
-void svst1_vnum(svbool_t, uint32_t *, int64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u64)))
-void svst1_vnum(svbool_t, uint64_t *, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u16)))
-void svst1_vnum(svbool_t, uint16_t *, int64_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s8)))
-void svst1_vnum(svbool_t, int8_t *, int64_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f64)))
-void svst1_vnum(svbool_t, float64_t *, int64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f32)))
-void svst1_vnum(svbool_t, float32_t *, int64_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f16)))
-void svst1_vnum(svbool_t, float16_t *, int64_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s32)))
-void svst1_vnum(svbool_t, int32_t *, int64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s64)))
-void svst1_vnum(svbool_t, int64_t *, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s16)))
-void svst1_vnum(svbool_t, int16_t *, int64_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_s32)))
-void svst1b(svbool_t, int8_t *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_s64)))
-void svst1b(svbool_t, int8_t *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_s16)))
-void svst1b(svbool_t, int8_t *, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_u32)))
-void svst1b(svbool_t, uint8_t *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_u64)))
-void svst1b(svbool_t, uint8_t *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_u16)))
-void svst1b(svbool_t, uint8_t *, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_offset_u32)))
-void svst1b_scatter_offset(svbool_t, svuint32_t, int64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_offset_u64)))
-void svst1b_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_offset_s32)))
-void svst1b_scatter_offset(svbool_t, svuint32_t, int64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_offset_s64)))
-void svst1b_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_u32)))
-void svst1b_scatter(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_u64)))
-void svst1b_scatter(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_s32)))
-void svst1b_scatter(svbool_t, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_s64)))
-void svst1b_scatter(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s32offset_s32)))
-void svst1b_scatter_offset(svbool_t, int8_t *, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s32offset_u32)))
-void svst1b_scatter_offset(svbool_t, uint8_t *, svint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32offset_s32)))
-void svst1b_scatter_offset(svbool_t, int8_t *, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32offset_u32)))
-void svst1b_scatter_offset(svbool_t, uint8_t *, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s64offset_s64)))
-void svst1b_scatter_offset(svbool_t, int8_t *, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s64offset_u64)))
-void svst1b_scatter_offset(svbool_t, uint8_t *, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64offset_s64)))
-void svst1b_scatter_offset(svbool_t, int8_t *, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64offset_u64)))
-void svst1b_scatter_offset(svbool_t, uint8_t *, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_s32)))
-void svst1b_vnum(svbool_t, int8_t *, int64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_s64)))
-void svst1b_vnum(svbool_t, int8_t *, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_s16)))
-void svst1b_vnum(svbool_t, int8_t *, int64_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_u32)))
-void svst1b_vnum(svbool_t, uint8_t *, int64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_u64)))
-void svst1b_vnum(svbool_t, uint8_t *, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_u16)))
-void svst1b_vnum(svbool_t, uint8_t *, int64_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_s32)))
-void svst1h(svbool_t, int16_t *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_s64)))
-void svst1h(svbool_t, int16_t *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_u32)))
-void svst1h(svbool_t, uint16_t *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_u64)))
-void svst1h(svbool_t, uint16_t *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_index_u32)))
-void svst1h_scatter_index(svbool_t, svuint32_t, int64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_index_u64)))
-void svst1h_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_index_s32)))
-void svst1h_scatter_index(svbool_t, svuint32_t, int64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_index_s64)))
-void svst1h_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_offset_u32)))
-void svst1h_scatter_offset(svbool_t, svuint32_t, int64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_offset_u64)))
-void svst1h_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_offset_s32)))
-void svst1h_scatter_offset(svbool_t, svuint32_t, int64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_offset_s64)))
-void svst1h_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_u32)))
-void svst1h_scatter(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_u64)))
-void svst1h_scatter(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_s32)))
-void svst1h_scatter(svbool_t, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_s64)))
-void svst1h_scatter(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32index_s32)))
-void svst1h_scatter_index(svbool_t, int16_t *, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32index_u32)))
-void svst1h_scatter_index(svbool_t, uint16_t *, svint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32index_s32)))
-void svst1h_scatter_index(svbool_t, int16_t *, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32index_u32)))
-void svst1h_scatter_index(svbool_t, uint16_t *, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64index_s64)))
-void svst1h_scatter_index(svbool_t, int16_t *, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64index_u64)))
-void svst1h_scatter_index(svbool_t, uint16_t *, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64index_s64)))
-void svst1h_scatter_index(svbool_t, int16_t *, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64index_u64)))
-void svst1h_scatter_index(svbool_t, uint16_t *, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32offset_s32)))
-void svst1h_scatter_offset(svbool_t, int16_t *, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32offset_u32)))
-void svst1h_scatter_offset(svbool_t, uint16_t *, svint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32offset_s32)))
-void svst1h_scatter_offset(svbool_t, int16_t *, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32offset_u32)))
-void svst1h_scatter_offset(svbool_t, uint16_t *, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64offset_s64)))
-void svst1h_scatter_offset(svbool_t, int16_t *, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64offset_u64)))
-void svst1h_scatter_offset(svbool_t, uint16_t *, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64offset_s64)))
-void svst1h_scatter_offset(svbool_t, int16_t *, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64offset_u64)))
-void svst1h_scatter_offset(svbool_t, uint16_t *, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_s32)))
-void svst1h_vnum(svbool_t, int16_t *, int64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_s64)))
-void svst1h_vnum(svbool_t, int16_t *, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_u32)))
-void svst1h_vnum(svbool_t, uint16_t *, int64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_u64)))
-void svst1h_vnum(svbool_t, uint16_t *, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_s64)))
-void svst1w(svbool_t, int32_t *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_u64)))
-void svst1w(svbool_t, uint32_t *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_index_u64)))
-void svst1w_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_index_s64)))
-void svst1w_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_offset_u64)))
-void svst1w_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_offset_s64)))
-void svst1w_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_u64)))
-void svst1w_scatter(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_s64)))
-void svst1w_scatter(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64index_s64)))
-void svst1w_scatter_index(svbool_t, int32_t *, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64index_u64)))
-void svst1w_scatter_index(svbool_t, uint32_t *, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64index_s64)))
-void svst1w_scatter_index(svbool_t, int32_t *, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64index_u64)))
-void svst1w_scatter_index(svbool_t, uint32_t *, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64offset_s64)))
-void svst1w_scatter_offset(svbool_t, int32_t *, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64offset_u64)))
-void svst1w_scatter_offset(svbool_t, uint32_t *, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64offset_s64)))
-void svst1w_scatter_offset(svbool_t, int32_t *, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64offset_u64)))
-void svst1w_scatter_offset(svbool_t, uint32_t *, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_vnum_s64)))
-void svst1w_vnum(svbool_t, int32_t *, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_vnum_u64)))
-void svst1w_vnum(svbool_t, uint32_t *, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u8)))
-void svst2(svbool_t, uint8_t *, svuint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u32)))
-void svst2(svbool_t, uint32_t *, svuint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u64)))
-void svst2(svbool_t, uint64_t *, svuint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u16)))
-void svst2(svbool_t, uint16_t *, svuint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s8)))
-void svst2(svbool_t, int8_t *, svint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_f64)))
-void svst2(svbool_t, float64_t *, svfloat64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_f32)))
-void svst2(svbool_t, float32_t *, svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_f16)))
-void svst2(svbool_t, float16_t *, svfloat16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s32)))
-void svst2(svbool_t, int32_t *, svint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s64)))
-void svst2(svbool_t, int64_t *, svint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s16)))
-void svst2(svbool_t, int16_t *, svint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u8)))
-void svst2_vnum(svbool_t, uint8_t *, int64_t, svuint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u32)))
-void svst2_vnum(svbool_t, uint32_t *, int64_t, svuint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u64)))
-void svst2_vnum(svbool_t, uint64_t *, int64_t, svuint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u16)))
-void svst2_vnum(svbool_t, uint16_t *, int64_t, svuint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s8)))
-void svst2_vnum(svbool_t, int8_t *, int64_t, svint8x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_f64)))
-void svst2_vnum(svbool_t, float64_t *, int64_t, svfloat64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_f32)))
-void svst2_vnum(svbool_t, float32_t *, int64_t, svfloat32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_f16)))
-void svst2_vnum(svbool_t, float16_t *, int64_t, svfloat16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s32)))
-void svst2_vnum(svbool_t, int32_t *, int64_t, svint32x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s64)))
-void svst2_vnum(svbool_t, int64_t *, int64_t, svint64x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s16)))
-void svst2_vnum(svbool_t, int16_t *, int64_t, svint16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u8)))
-void svst3(svbool_t, uint8_t *, svuint8x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u32)))
-void svst3(svbool_t, uint32_t *, svuint32x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u64)))
-void svst3(svbool_t, uint64_t *, svuint64x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u16)))
-void svst3(svbool_t, uint16_t *, svuint16x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s8)))
-void svst3(svbool_t, int8_t *, svint8x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_f64)))
-void svst3(svbool_t, float64_t *, svfloat64x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_f32)))
-void svst3(svbool_t, float32_t *, svfloat32x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_f16)))
-void svst3(svbool_t, float16_t *, svfloat16x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s32)))
-void svst3(svbool_t, int32_t *, svint32x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s64)))
-void svst3(svbool_t, int64_t *, svint64x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s16)))
-void svst3(svbool_t, int16_t *, svint16x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u8)))
-void svst3_vnum(svbool_t, uint8_t *, int64_t, svuint8x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u32)))
-void svst3_vnum(svbool_t, uint32_t *, int64_t, svuint32x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u64)))
-void svst3_vnum(svbool_t, uint64_t *, int64_t, svuint64x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u16)))
-void svst3_vnum(svbool_t, uint16_t *, int64_t, svuint16x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s8)))
-void svst3_vnum(svbool_t, int8_t *, int64_t, svint8x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_f64)))
-void svst3_vnum(svbool_t, float64_t *, int64_t, svfloat64x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_f32)))
-void svst3_vnum(svbool_t, float32_t *, int64_t, svfloat32x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_f16)))
-void svst3_vnum(svbool_t, float16_t *, int64_t, svfloat16x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s32)))
-void svst3_vnum(svbool_t, int32_t *, int64_t, svint32x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s64)))
-void svst3_vnum(svbool_t, int64_t *, int64_t, svint64x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s16)))
-void svst3_vnum(svbool_t, int16_t *, int64_t, svint16x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u8)))
-void svst4(svbool_t, uint8_t *, svuint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u32)))
-void svst4(svbool_t, uint32_t *, svuint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u64)))
-void svst4(svbool_t, uint64_t *, svuint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u16)))
-void svst4(svbool_t, uint16_t *, svuint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s8)))
-void svst4(svbool_t, int8_t *, svint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_f64)))
-void svst4(svbool_t, float64_t *, svfloat64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_f32)))
-void svst4(svbool_t, float32_t *, svfloat32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_f16)))
-void svst4(svbool_t, float16_t *, svfloat16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s32)))
-void svst4(svbool_t, int32_t *, svint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s64)))
-void svst4(svbool_t, int64_t *, svint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s16)))
-void svst4(svbool_t, int16_t *, svint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u8)))
-void svst4_vnum(svbool_t, uint8_t *, int64_t, svuint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u32)))
-void svst4_vnum(svbool_t, uint32_t *, int64_t, svuint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u64)))
-void svst4_vnum(svbool_t, uint64_t *, int64_t, svuint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u16)))
-void svst4_vnum(svbool_t, uint16_t *, int64_t, svuint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s8)))
-void svst4_vnum(svbool_t, int8_t *, int64_t, svint8x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_f64)))
-void svst4_vnum(svbool_t, float64_t *, int64_t, svfloat64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_f32)))
-void svst4_vnum(svbool_t, float32_t *, int64_t, svfloat32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_f16)))
-void svst4_vnum(svbool_t, float16_t *, int64_t, svfloat16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s32)))
-void svst4_vnum(svbool_t, int32_t *, int64_t, svint32x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s64)))
-void svst4_vnum(svbool_t, int64_t *, int64_t, svint64x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s16)))
-void svst4_vnum(svbool_t, int16_t *, int64_t, svint16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u8)))
-void svstnt1(svbool_t, uint8_t *, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u32)))
-void svstnt1(svbool_t, uint32_t *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u64)))
-void svstnt1(svbool_t, uint64_t *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u16)))
-void svstnt1(svbool_t, uint16_t *, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s8)))
-void svstnt1(svbool_t, int8_t *, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f64)))
-void svstnt1(svbool_t, float64_t *, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f32)))
-void svstnt1(svbool_t, float32_t *, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f16)))
-void svstnt1(svbool_t, float16_t *, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s32)))
-void svstnt1(svbool_t, int32_t *, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s64)))
-void svstnt1(svbool_t, int64_t *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s16)))
-void svstnt1(svbool_t, int16_t *, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u8)))
-void svstnt1_vnum(svbool_t, uint8_t *, int64_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u32)))
-void svstnt1_vnum(svbool_t, uint32_t *, int64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u64)))
-void svstnt1_vnum(svbool_t, uint64_t *, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u16)))
-void svstnt1_vnum(svbool_t, uint16_t *, int64_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s8)))
-void svstnt1_vnum(svbool_t, int8_t *, int64_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f64)))
-void svstnt1_vnum(svbool_t, float64_t *, int64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f32)))
-void svstnt1_vnum(svbool_t, float32_t *, int64_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f16)))
-void svstnt1_vnum(svbool_t, float16_t *, int64_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s32)))
-void svstnt1_vnum(svbool_t, int32_t *, int64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s64)))
-void svstnt1_vnum(svbool_t, int64_t *, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s16)))
-void svstnt1_vnum(svbool_t, int16_t *, int64_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f64_m)))
-svfloat64_t svsub_m(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f32_m)))
-svfloat32_t svsub_m(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f16_m)))
-svfloat16_t svsub_m(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f64_x)))
-svfloat64_t svsub_x(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f32_x)))
-svfloat32_t svsub_x(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f16_x)))
-svfloat16_t svsub_x(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f64_z)))
-svfloat64_t svsub_z(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f32_z)))
-svfloat32_t svsub_z(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f16_z)))
-svfloat16_t svsub_z(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u8_m)))
-svuint8_t svsub_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u32_m)))
-svuint32_t svsub_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u64_m)))
-svuint64_t svsub_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u16_m)))
-svuint16_t svsub_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s8_m)))
-svint8_t svsub_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s32_m)))
-svint32_t svsub_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s64_m)))
-svint64_t svsub_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s16_m)))
-svint16_t svsub_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u8_x)))
-svuint8_t svsub_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u32_x)))
-svuint32_t svsub_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u64_x)))
-svuint64_t svsub_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u16_x)))
-svuint16_t svsub_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s8_x)))
-svint8_t svsub_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s32_x)))
-svint32_t svsub_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s64_x)))
-svint64_t svsub_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s16_x)))
-svint16_t svsub_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u8_z)))
-svuint8_t svsub_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u32_z)))
-svuint32_t svsub_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u64_z)))
-svuint64_t svsub_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u16_z)))
-svuint16_t svsub_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s8_z)))
-svint8_t svsub_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s32_z)))
-svint32_t svsub_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s64_z)))
-svint64_t svsub_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s16_z)))
-svint16_t svsub_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f64_m)))
-svfloat64_t svsub_m(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f32_m)))
-svfloat32_t svsub_m(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f16_m)))
-svfloat16_t svsub_m(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f64_x)))
-svfloat64_t svsub_x(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f32_x)))
-svfloat32_t svsub_x(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f16_x)))
-svfloat16_t svsub_x(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f64_z)))
-svfloat64_t svsub_z(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f32_z)))
-svfloat32_t svsub_z(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f16_z)))
-svfloat16_t svsub_z(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u8_m)))
-svuint8_t svsub_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u32_m)))
-svuint32_t svsub_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u64_m)))
-svuint64_t svsub_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u16_m)))
-svuint16_t svsub_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s8_m)))
-svint8_t svsub_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s32_m)))
-svint32_t svsub_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s64_m)))
-svint64_t svsub_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s16_m)))
-svint16_t svsub_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u8_x)))
-svuint8_t svsub_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u32_x)))
-svuint32_t svsub_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u64_x)))
-svuint64_t svsub_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u16_x)))
-svuint16_t svsub_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s8_x)))
-svint8_t svsub_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s32_x)))
-svint32_t svsub_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s64_x)))
-svint64_t svsub_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s16_x)))
-svint16_t svsub_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u8_z)))
-svuint8_t svsub_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u32_z)))
-svuint32_t svsub_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u64_z)))
-svuint64_t svsub_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u16_z)))
-svuint16_t svsub_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s8_z)))
-svint8_t svsub_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s32_z)))
-svint32_t svsub_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s64_z)))
-svint64_t svsub_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s16_z)))
-svint16_t svsub_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f64_m)))
-svfloat64_t svsubr_m(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f32_m)))
-svfloat32_t svsubr_m(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f16_m)))
-svfloat16_t svsubr_m(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f64_x)))
-svfloat64_t svsubr_x(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f32_x)))
-svfloat32_t svsubr_x(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f16_x)))
-svfloat16_t svsubr_x(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f64_z)))
-svfloat64_t svsubr_z(svbool_t, svfloat64_t, float64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f32_z)))
-svfloat32_t svsubr_z(svbool_t, svfloat32_t, float32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f16_z)))
-svfloat16_t svsubr_z(svbool_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u8_m)))
-svuint8_t svsubr_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u32_m)))
-svuint32_t svsubr_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u64_m)))
-svuint64_t svsubr_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u16_m)))
-svuint16_t svsubr_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s8_m)))
-svint8_t svsubr_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s32_m)))
-svint32_t svsubr_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s64_m)))
-svint64_t svsubr_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s16_m)))
-svint16_t svsubr_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u8_x)))
-svuint8_t svsubr_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u32_x)))
-svuint32_t svsubr_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u64_x)))
-svuint64_t svsubr_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u16_x)))
-svuint16_t svsubr_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s8_x)))
-svint8_t svsubr_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s32_x)))
-svint32_t svsubr_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s64_x)))
-svint64_t svsubr_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s16_x)))
-svint16_t svsubr_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u8_z)))
-svuint8_t svsubr_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u32_z)))
-svuint32_t svsubr_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u64_z)))
-svuint64_t svsubr_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u16_z)))
-svuint16_t svsubr_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s8_z)))
-svint8_t svsubr_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s32_z)))
-svint32_t svsubr_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s64_z)))
-svint64_t svsubr_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s16_z)))
-svint16_t svsubr_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f64_m)))
-svfloat64_t svsubr_m(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f32_m)))
-svfloat32_t svsubr_m(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f16_m)))
-svfloat16_t svsubr_m(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f64_x)))
-svfloat64_t svsubr_x(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f32_x)))
-svfloat32_t svsubr_x(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f16_x)))
-svfloat16_t svsubr_x(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f64_z)))
-svfloat64_t svsubr_z(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f32_z)))
-svfloat32_t svsubr_z(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f16_z)))
-svfloat16_t svsubr_z(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u8_m)))
-svuint8_t svsubr_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u32_m)))
-svuint32_t svsubr_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u64_m)))
-svuint64_t svsubr_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u16_m)))
-svuint16_t svsubr_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s8_m)))
-svint8_t svsubr_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s32_m)))
-svint32_t svsubr_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s64_m)))
-svint64_t svsubr_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s16_m)))
-svint16_t svsubr_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u8_x)))
-svuint8_t svsubr_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u32_x)))
-svuint32_t svsubr_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u64_x)))
-svuint64_t svsubr_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u16_x)))
-svuint16_t svsubr_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s8_x)))
-svint8_t svsubr_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s32_x)))
-svint32_t svsubr_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s64_x)))
-svint64_t svsubr_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s16_x)))
-svint16_t svsubr_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u8_z)))
-svuint8_t svsubr_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u32_z)))
-svuint32_t svsubr_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u64_z)))
-svuint64_t svsubr_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u16_z)))
-svuint16_t svsubr_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s8_z)))
-svint8_t svsubr_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s32_z)))
-svint32_t svsubr_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s64_z)))
-svint64_t svsubr_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s16_z)))
-svint16_t svsubr_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u8)))
-svuint8_t svtbl(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u32)))
-svuint32_t svtbl(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u64)))
-svuint64_t svtbl(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u16)))
-svuint16_t svtbl(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s8)))
-svint8_t svtbl(svint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_f64)))
-svfloat64_t svtbl(svfloat64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_f32)))
-svfloat32_t svtbl(svfloat32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_f16)))
-svfloat16_t svtbl(svfloat16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s32)))
-svint32_t svtbl(svint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s64)))
-svint64_t svtbl(svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s16)))
-svint16_t svtbl(svint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtmad_f64)))
-svfloat64_t svtmad(svfloat64_t, svfloat64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtmad_f32)))
-svfloat32_t svtmad(svfloat32_t, svfloat32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtmad_f16)))
-svfloat16_t svtmad(svfloat16_t, svfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u8)))
-svuint8_t svtrn1(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u32)))
-svuint32_t svtrn1(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u64)))
-svuint64_t svtrn1(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u16)))
-svuint16_t svtrn1(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s8)))
-svint8_t svtrn1(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_f64)))
-svfloat64_t svtrn1(svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_f32)))
-svfloat32_t svtrn1(svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_f16)))
-svfloat16_t svtrn1(svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s32)))
-svint32_t svtrn1(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s64)))
-svint64_t svtrn1(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s16)))
-svint16_t svtrn1(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u8)))
-svuint8_t svtrn2(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u32)))
-svuint32_t svtrn2(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u64)))
-svuint64_t svtrn2(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u16)))
-svuint16_t svtrn2(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s8)))
-svint8_t svtrn2(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_f64)))
-svfloat64_t svtrn2(svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_f32)))
-svfloat32_t svtrn2(svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_f16)))
-svfloat16_t svtrn2(svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s32)))
-svint32_t svtrn2(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s64)))
-svint64_t svtrn2(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s16)))
-svint16_t svtrn2(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtsmul_f64)))
-svfloat64_t svtsmul(svfloat64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtsmul_f32)))
-svfloat32_t svtsmul(svfloat32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtsmul_f16)))
-svfloat16_t svtsmul(svfloat16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtssel_f64)))
-svfloat64_t svtssel(svfloat64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtssel_f32)))
-svfloat32_t svtssel(svfloat32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtssel_f16)))
-svfloat16_t svtssel(svfloat16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_b)))
-svbool_t svunpkhi(svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_s32)))
-svint32_t svunpkhi(svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_s64)))
-svint64_t svunpkhi(svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_s16)))
-svint16_t svunpkhi(svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_u32)))
-svuint32_t svunpkhi(svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_u64)))
-svuint64_t svunpkhi(svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_u16)))
-svuint16_t svunpkhi(svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_b)))
-svbool_t svunpklo(svbool_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_s32)))
-svint32_t svunpklo(svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_s64)))
-svint64_t svunpklo(svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_s16)))
-svint16_t svunpklo(svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_u32)))
-svuint32_t svunpklo(svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_u64)))
-svuint64_t svunpklo(svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_u16)))
-svuint16_t svunpklo(svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u8)))
-svuint8_t svuzp1(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u32)))
-svuint32_t svuzp1(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u64)))
-svuint64_t svuzp1(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u16)))
-svuint16_t svuzp1(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s8)))
-svint8_t svuzp1(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_f64)))
-svfloat64_t svuzp1(svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_f32)))
-svfloat32_t svuzp1(svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_f16)))
-svfloat16_t svuzp1(svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s32)))
-svint32_t svuzp1(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s64)))
-svint64_t svuzp1(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s16)))
-svint16_t svuzp1(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u8)))
-svuint8_t svuzp2(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u32)))
-svuint32_t svuzp2(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u64)))
-svuint64_t svuzp2(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u16)))
-svuint16_t svuzp2(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s8)))
-svint8_t svuzp2(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_f64)))
-svfloat64_t svuzp2(svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_f32)))
-svfloat32_t svuzp2(svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_f16)))
-svfloat16_t svuzp2(svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s32)))
-svint32_t svuzp2(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s64)))
-svint64_t svuzp2(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s16)))
-svint16_t svuzp2(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_s32)))
-svbool_t svwhilele_b8(int32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_s32)))
-svbool_t svwhilele_b32(int32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_s32)))
-svbool_t svwhilele_b64(int32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_s32)))
-svbool_t svwhilele_b16(int32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_s64)))
-svbool_t svwhilele_b8(int64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_s64)))
-svbool_t svwhilele_b32(int64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_s64)))
-svbool_t svwhilele_b64(int64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_s64)))
-svbool_t svwhilele_b16(int64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_u32)))
-svbool_t svwhilele_b8(uint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_u32)))
-svbool_t svwhilele_b32(uint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_u32)))
-svbool_t svwhilele_b64(uint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_u32)))
-svbool_t svwhilele_b16(uint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_u64)))
-svbool_t svwhilele_b8(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_u64)))
-svbool_t svwhilele_b32(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_u64)))
-svbool_t svwhilele_b64(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_u64)))
-svbool_t svwhilele_b16(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_u32)))
-svbool_t svwhilelt_b8(uint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_u32)))
-svbool_t svwhilelt_b32(uint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_u32)))
-svbool_t svwhilelt_b64(uint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_u32)))
-svbool_t svwhilelt_b16(uint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_u64)))
-svbool_t svwhilelt_b8(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_u64)))
-svbool_t svwhilelt_b32(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_u64)))
-svbool_t svwhilelt_b64(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_u64)))
-svbool_t svwhilelt_b16(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_s32)))
-svbool_t svwhilelt_b8(int32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_s32)))
-svbool_t svwhilelt_b32(int32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_s32)))
-svbool_t svwhilelt_b64(int32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_s32)))
-svbool_t svwhilelt_b16(int32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_s64)))
-svbool_t svwhilelt_b8(int64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_s64)))
-svbool_t svwhilelt_b32(int64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_s64)))
-svbool_t svwhilelt_b64(int64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_s64)))
-svbool_t svwhilelt_b16(int64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u8)))
-svuint8_t svzip1(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u32)))
-svuint32_t svzip1(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u64)))
-svuint64_t svzip1(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u16)))
-svuint16_t svzip1(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s8)))
-svint8_t svzip1(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_f64)))
-svfloat64_t svzip1(svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_f32)))
-svfloat32_t svzip1(svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_f16)))
-svfloat16_t svzip1(svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s32)))
-svint32_t svzip1(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s64)))
-svint64_t svzip1(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s16)))
-svint16_t svzip1(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u8)))
-svuint8_t svzip2(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u32)))
-svuint32_t svzip2(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u64)))
-svuint64_t svzip2(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u16)))
-svuint16_t svzip2(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s8)))
-svint8_t svzip2(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_f64)))
-svfloat64_t svzip2(svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_f32)))
-svfloat32_t svzip2(svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_f16)))
-svfloat16_t svzip2(svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s32)))
-svint32_t svzip2(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s64)))
-svint64_t svzip2(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s16)))
-svint16_t svzip2(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfdot_n_f32)))
-svfloat32_t svbfdot_n_f32(svfloat32_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfdot_f32)))
-svfloat32_t svbfdot_f32(svfloat32_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfdot_lane_f32)))
-svfloat32_t svbfdot_lane_f32(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalb_n_f32)))
-svfloat32_t svbfmlalb_n_f32(svfloat32_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalb_f32)))
-svfloat32_t svbfmlalb_f32(svfloat32_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalb_lane_f32)))
-svfloat32_t svbfmlalb_lane_f32(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalt_n_f32)))
-svfloat32_t svbfmlalt_n_f32(svfloat32_t, svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalt_f32)))
-svfloat32_t svbfmlalt_f32(svfloat32_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalt_lane_f32)))
-svfloat32_t svbfmlalt_lane_f32(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmmla_f32)))
-svfloat32_t svbfmmla_f32(svfloat32_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_bf16)))
-bfloat16_t svclasta_n_bf16(svbool_t, bfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_bf16)))
-svbfloat16_t svclasta_bf16(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_bf16)))
-bfloat16_t svclastb_n_bf16(svbool_t, bfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_bf16)))
-svbfloat16_t svclastb_bf16(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_bf16_m)))
-svuint16_t svcnt_bf16_m(svuint16_t, svbool_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_bf16_x)))
-svuint16_t svcnt_bf16_x(svbool_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_bf16_z)))
-svuint16_t svcnt_bf16_z(svbool_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_bf16)))
-svbfloat16x2_t svcreate2_bf16(svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_bf16)))
-svbfloat16x3_t svcreate3_bf16(svbfloat16_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_bf16)))
-svbfloat16x4_t svcreate4_bf16(svbfloat16_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_m)))
-svbfloat16_t svcvt_bf16_f32_m(svbfloat16_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_x)))
-svbfloat16_t svcvt_bf16_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_z)))
-svbfloat16_t svcvt_bf16_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtnt_bf16_f32_m)))
-svbfloat16_t svcvtnt_bf16_f32_m(svbfloat16_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16)))
-svbfloat16_t svdup_n_bf16(bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16_m)))
-svbfloat16_t svdup_n_bf16_m(svbfloat16_t, svbool_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16_x)))
-svbfloat16_t svdup_n_bf16_x(svbool_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16_z)))
-svbfloat16_t svdup_n_bf16_z(svbool_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_bf16)))
-svbfloat16_t svdup_lane_bf16(svbfloat16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_bf16)))
-svbfloat16_t svdupq_n_bf16(bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_bf16)))
-svbfloat16_t svdupq_lane_bf16(svbfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_bf16)))
-svbfloat16_t svext_bf16(svbfloat16_t, svbfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_bf16)))
-svbfloat16_t svget2_bf16(svbfloat16x2_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_bf16)))
-svbfloat16_t svget3_bf16(svbfloat16x3_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_bf16)))
-svbfloat16_t svget4_bf16(svbfloat16x4_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_bf16)))
-svbfloat16_t svinsr_n_bf16(svbfloat16_t, bfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_bf16)))
-bfloat16_t svlasta_bf16(svbool_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_bf16)))
-bfloat16_t svlastb_bf16(svbool_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_bf16)))
-svbfloat16_t svld1_bf16(svbool_t, bfloat16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_bf16)))
-svbfloat16_t svld1_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_bf16)))
-svbfloat16_t svld1rq_bf16(svbool_t, bfloat16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_bf16)))
-svbfloat16x2_t svld2_bf16(svbool_t, bfloat16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_bf16)))
-svbfloat16x2_t svld2_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_bf16)))
-svbfloat16x3_t svld3_bf16(svbool_t, bfloat16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_bf16)))
-svbfloat16x3_t svld3_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_bf16)))
-svbfloat16x4_t svld4_bf16(svbool_t, bfloat16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_bf16)))
-svbfloat16x4_t svld4_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_bf16)))
-svbfloat16_t svldff1_bf16(svbool_t, bfloat16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_bf16)))
-svbfloat16_t svldff1_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_bf16)))
-svbfloat16_t svldnf1_bf16(svbool_t, bfloat16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_bf16)))
-svbfloat16_t svldnf1_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_bf16)))
-svbfloat16_t svldnt1_bf16(svbool_t, bfloat16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_bf16)))
-svbfloat16_t svldnt1_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_bf16)))
-uint64_t svlen_bf16(svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_bf16)))
-svbfloat16_t svrev_bf16(svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_bf16)))
-svbfloat16_t svsel_bf16(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_bf16)))
-svbfloat16x2_t svset2_bf16(svbfloat16x2_t, uint64_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_bf16)))
-svbfloat16x3_t svset3_bf16(svbfloat16x3_t, uint64_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_bf16)))
-svbfloat16x4_t svset4_bf16(svbfloat16x4_t, uint64_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_bf16)))
-svbfloat16_t svsplice_bf16(svbool_t, svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_bf16)))
-void svst1_bf16(svbool_t, bfloat16_t *, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_bf16)))
-void svst1_vnum_bf16(svbool_t, bfloat16_t *, int64_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_bf16)))
-void svst2_bf16(svbool_t, bfloat16_t *, svbfloat16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_bf16)))
-void svst2_vnum_bf16(svbool_t, bfloat16_t *, int64_t, svbfloat16x2_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_bf16)))
-void svst3_bf16(svbool_t, bfloat16_t *, svbfloat16x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_bf16)))
-void svst3_vnum_bf16(svbool_t, bfloat16_t *, int64_t, svbfloat16x3_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_bf16)))
-void svst4_bf16(svbool_t, bfloat16_t *, svbfloat16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_bf16)))
-void svst4_vnum_bf16(svbool_t, bfloat16_t *, int64_t, svbfloat16x4_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_bf16)))
-void svstnt1_bf16(svbool_t, bfloat16_t *, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_bf16)))
-void svstnt1_vnum_bf16(svbool_t, bfloat16_t *, int64_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_bf16)))
-svbfloat16_t svtbl_bf16(svbfloat16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_bf16)))
-svbfloat16_t svtrn1_bf16(svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_bf16)))
-svbfloat16_t svtrn2_bf16(svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_bf16)))
-svbfloat16x2_t svundef2_bf16(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_bf16)))
-svbfloat16x3_t svundef3_bf16(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_bf16)))
-svbfloat16x4_t svundef4_bf16(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_bf16)))
-svbfloat16_t svundef_bf16(void);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_bf16)))
-svbfloat16_t svuzp1_bf16(svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_bf16)))
-svbfloat16_t svuzp2_bf16(svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_bf16)))
-svbfloat16_t svzip1_bf16(svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_bf16)))
-svbfloat16_t svzip2_bf16(svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfdot_n_f32)))
-svfloat32_t svbfdot(svfloat32_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfdot_f32)))
-svfloat32_t svbfdot(svfloat32_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfdot_lane_f32)))
-svfloat32_t svbfdot_lane(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalb_n_f32)))
-svfloat32_t svbfmlalb(svfloat32_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalb_f32)))
-svfloat32_t svbfmlalb(svfloat32_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalb_lane_f32)))
-svfloat32_t svbfmlalb_lane(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalt_n_f32)))
-svfloat32_t svbfmlalt(svfloat32_t, svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalt_f32)))
-svfloat32_t svbfmlalt(svfloat32_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalt_lane_f32)))
-svfloat32_t svbfmlalt_lane(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmmla_f32)))
-svfloat32_t svbfmmla(svfloat32_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_bf16)))
-bfloat16_t svclasta(svbool_t, bfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_bf16)))
-svbfloat16_t svclasta(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_bf16)))
-bfloat16_t svclastb(svbool_t, bfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_bf16)))
-svbfloat16_t svclastb(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_bf16_m)))
-svuint16_t svcnt_m(svuint16_t, svbool_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_bf16_x)))
-svuint16_t svcnt_x(svbool_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_bf16_z)))
-svuint16_t svcnt_z(svbool_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_bf16)))
-svbfloat16x2_t svcreate2(svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_bf16)))
-svbfloat16x3_t svcreate3(svbfloat16_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_bf16)))
-svbfloat16x4_t svcreate4(svbfloat16_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_m)))
-svbfloat16_t svcvt_bf16_m(svbfloat16_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_x)))
-svbfloat16_t svcvt_bf16_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_z)))
-svbfloat16_t svcvt_bf16_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtnt_bf16_f32_m)))
-svbfloat16_t svcvtnt_bf16_m(svbfloat16_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16)))
-svbfloat16_t svdup_bf16(bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16_m)))
-svbfloat16_t svdup_bf16_m(svbfloat16_t, svbool_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16_x)))
-svbfloat16_t svdup_bf16_x(svbool_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16_z)))
-svbfloat16_t svdup_bf16_z(svbool_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_bf16)))
-svbfloat16_t svdup_lane(svbfloat16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_bf16)))
-svbfloat16_t svdupq_bf16(bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_bf16)))
-svbfloat16_t svdupq_lane(svbfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_bf16)))
-svbfloat16_t svext(svbfloat16_t, svbfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_bf16)))
-svbfloat16_t svget2(svbfloat16x2_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_bf16)))
-svbfloat16_t svget3(svbfloat16x3_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_bf16)))
-svbfloat16_t svget4(svbfloat16x4_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_bf16)))
-svbfloat16_t svinsr(svbfloat16_t, bfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_bf16)))
-bfloat16_t svlasta(svbool_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_bf16)))
-bfloat16_t svlastb(svbool_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_bf16)))
-svbfloat16_t svld1(svbool_t, bfloat16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_bf16)))
-svbfloat16_t svld1_vnum(svbool_t, bfloat16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_bf16)))
-svbfloat16_t svld1rq(svbool_t, bfloat16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_bf16)))
-svbfloat16x2_t svld2(svbool_t, bfloat16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_bf16)))
-svbfloat16x2_t svld2_vnum(svbool_t, bfloat16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_bf16)))
-svbfloat16x3_t svld3(svbool_t, bfloat16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_bf16)))
-svbfloat16x3_t svld3_vnum(svbool_t, bfloat16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_bf16)))
-svbfloat16x4_t svld4(svbool_t, bfloat16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_bf16)))
-svbfloat16x4_t svld4_vnum(svbool_t, bfloat16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_bf16)))
-svbfloat16_t svldff1(svbool_t, bfloat16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_bf16)))
-svbfloat16_t svldff1_vnum(svbool_t, bfloat16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_bf16)))
-svbfloat16_t svldnf1(svbool_t, bfloat16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_bf16)))
-svbfloat16_t svldnf1_vnum(svbool_t, bfloat16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_bf16)))
-svbfloat16_t svldnt1(svbool_t, bfloat16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_bf16)))
-svbfloat16_t svldnt1_vnum(svbool_t, bfloat16_t const *, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_bf16)))
-uint64_t svlen(svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_bf16)))
-svbfloat16_t svrev(svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_bf16)))
-svbfloat16_t svsel(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_bf16)))
-svbfloat16x2_t svset2(svbfloat16x2_t, uint64_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_bf16)))
-svbfloat16x3_t svset3(svbfloat16x3_t, uint64_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_bf16)))
-svbfloat16x4_t svset4(svbfloat16x4_t, uint64_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_bf16)))
-svbfloat16_t svsplice(svbool_t, svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_bf16)))
-void svst1(svbool_t, bfloat16_t *, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_bf16)))
-void svst1_vnum(svbool_t, bfloat16_t *, int64_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_bf16)))
-void svst2(svbool_t, bfloat16_t *, svbfloat16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_bf16)))
-void svst2_vnum(svbool_t, bfloat16_t *, int64_t, svbfloat16x2_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_bf16)))
-void svst3(svbool_t, bfloat16_t *, svbfloat16x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_bf16)))
-void svst3_vnum(svbool_t, bfloat16_t *, int64_t, svbfloat16x3_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_bf16)))
-void svst4(svbool_t, bfloat16_t *, svbfloat16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_bf16)))
-void svst4_vnum(svbool_t, bfloat16_t *, int64_t, svbfloat16x4_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_bf16)))
-void svstnt1(svbool_t, bfloat16_t *, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_bf16)))
-void svstnt1_vnum(svbool_t, bfloat16_t *, int64_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_bf16)))
-svbfloat16_t svtbl(svbfloat16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_bf16)))
-svbfloat16_t svtrn1(svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_bf16)))
-svbfloat16_t svtrn2(svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_bf16)))
-svbfloat16_t svuzp1(svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_bf16)))
-svbfloat16_t svuzp2(svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_bf16)))
-svbfloat16_t svzip1(svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_bf16)))
-svbfloat16_t svzip2(svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_bf16)))
-svbfloat16_t svtrn1q_bf16(svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_bf16)))
-svbfloat16_t svtrn2q_bf16(svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_bf16)))
-svbfloat16_t svuzp1q_bf16(svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_bf16)))
-svbfloat16_t svuzp2q_bf16(svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_bf16)))
-svbfloat16_t svzip1q_bf16(svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_bf16)))
-svbfloat16_t svzip2q_bf16(svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_bf16)))
-svbfloat16_t svtrn1q(svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_bf16)))
-svbfloat16_t svtrn2q(svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_bf16)))
-svbfloat16_t svuzp1q(svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_bf16)))
-svbfloat16_t svuzp2q(svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_bf16)))
-svbfloat16_t svzip1q(svbfloat16_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_bf16)))
-svbfloat16_t svzip2q(svbfloat16_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_f32)))
-svfloat32_t svmmla_f32(svfloat32_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_f32)))
-svfloat32_t svmmla(svfloat32_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u8)))
-svuint8_t svld1ro_u8(svbool_t, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u32)))
-svuint32_t svld1ro_u32(svbool_t, uint32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u64)))
-svuint64_t svld1ro_u64(svbool_t, uint64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u16)))
-svuint16_t svld1ro_u16(svbool_t, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s8)))
-svint8_t svld1ro_s8(svbool_t, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_f64)))
-svfloat64_t svld1ro_f64(svbool_t, float64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_f32)))
-svfloat32_t svld1ro_f32(svbool_t, float32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_f16)))
-svfloat16_t svld1ro_f16(svbool_t, float16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s32)))
-svint32_t svld1ro_s32(svbool_t, int32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s64)))
-svint64_t svld1ro_s64(svbool_t, int64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s16)))
-svint16_t svld1ro_s16(svbool_t, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_f64)))
-svfloat64_t svmmla_f64(svfloat64_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u8)))
-svuint8_t svtrn1q_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u32)))
-svuint32_t svtrn1q_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u64)))
-svuint64_t svtrn1q_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u16)))
-svuint16_t svtrn1q_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s8)))
-svint8_t svtrn1q_s8(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_f64)))
-svfloat64_t svtrn1q_f64(svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_f32)))
-svfloat32_t svtrn1q_f32(svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_f16)))
-svfloat16_t svtrn1q_f16(svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s32)))
-svint32_t svtrn1q_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s64)))
-svint64_t svtrn1q_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s16)))
-svint16_t svtrn1q_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u8)))
-svuint8_t svtrn2q_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u32)))
-svuint32_t svtrn2q_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u64)))
-svuint64_t svtrn2q_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u16)))
-svuint16_t svtrn2q_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s8)))
-svint8_t svtrn2q_s8(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_f64)))
-svfloat64_t svtrn2q_f64(svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_f32)))
-svfloat32_t svtrn2q_f32(svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_f16)))
-svfloat16_t svtrn2q_f16(svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s32)))
-svint32_t svtrn2q_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s64)))
-svint64_t svtrn2q_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s16)))
-svint16_t svtrn2q_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u8)))
-svuint8_t svuzp1q_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u32)))
-svuint32_t svuzp1q_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u64)))
-svuint64_t svuzp1q_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u16)))
-svuint16_t svuzp1q_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s8)))
-svint8_t svuzp1q_s8(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_f64)))
-svfloat64_t svuzp1q_f64(svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_f32)))
-svfloat32_t svuzp1q_f32(svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_f16)))
-svfloat16_t svuzp1q_f16(svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s32)))
-svint32_t svuzp1q_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s64)))
-svint64_t svuzp1q_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s16)))
-svint16_t svuzp1q_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u8)))
-svuint8_t svuzp2q_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u32)))
-svuint32_t svuzp2q_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u64)))
-svuint64_t svuzp2q_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u16)))
-svuint16_t svuzp2q_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s8)))
-svint8_t svuzp2q_s8(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_f64)))
-svfloat64_t svuzp2q_f64(svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_f32)))
-svfloat32_t svuzp2q_f32(svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_f16)))
-svfloat16_t svuzp2q_f16(svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s32)))
-svint32_t svuzp2q_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s64)))
-svint64_t svuzp2q_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s16)))
-svint16_t svuzp2q_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u8)))
-svuint8_t svzip1q_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u32)))
-svuint32_t svzip1q_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u64)))
-svuint64_t svzip1q_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u16)))
-svuint16_t svzip1q_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s8)))
-svint8_t svzip1q_s8(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_f64)))
-svfloat64_t svzip1q_f64(svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_f32)))
-svfloat32_t svzip1q_f32(svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_f16)))
-svfloat16_t svzip1q_f16(svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s32)))
-svint32_t svzip1q_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s64)))
-svint64_t svzip1q_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s16)))
-svint16_t svzip1q_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u8)))
-svuint8_t svzip2q_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u32)))
-svuint32_t svzip2q_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u64)))
-svuint64_t svzip2q_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u16)))
-svuint16_t svzip2q_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s8)))
-svint8_t svzip2q_s8(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_f64)))
-svfloat64_t svzip2q_f64(svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_f32)))
-svfloat32_t svzip2q_f32(svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_f16)))
-svfloat16_t svzip2q_f16(svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s32)))
-svint32_t svzip2q_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s64)))
-svint64_t svzip2q_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s16)))
-svint16_t svzip2q_s16(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u8)))
-svuint8_t svld1ro(svbool_t, uint8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u32)))
-svuint32_t svld1ro(svbool_t, uint32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u64)))
-svuint64_t svld1ro(svbool_t, uint64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u16)))
-svuint16_t svld1ro(svbool_t, uint16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s8)))
-svint8_t svld1ro(svbool_t, int8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_f64)))
-svfloat64_t svld1ro(svbool_t, float64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_f32)))
-svfloat32_t svld1ro(svbool_t, float32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_f16)))
-svfloat16_t svld1ro(svbool_t, float16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s32)))
-svint32_t svld1ro(svbool_t, int32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s64)))
-svint64_t svld1ro(svbool_t, int64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s16)))
-svint16_t svld1ro(svbool_t, int16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_f64)))
-svfloat64_t svmmla(svfloat64_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u8)))
-svuint8_t svtrn1q(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u32)))
-svuint32_t svtrn1q(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u64)))
-svuint64_t svtrn1q(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u16)))
-svuint16_t svtrn1q(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s8)))
-svint8_t svtrn1q(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_f64)))
-svfloat64_t svtrn1q(svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_f32)))
-svfloat32_t svtrn1q(svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_f16)))
-svfloat16_t svtrn1q(svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s32)))
-svint32_t svtrn1q(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s64)))
-svint64_t svtrn1q(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s16)))
-svint16_t svtrn1q(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u8)))
-svuint8_t svtrn2q(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u32)))
-svuint32_t svtrn2q(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u64)))
-svuint64_t svtrn2q(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u16)))
-svuint16_t svtrn2q(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s8)))
-svint8_t svtrn2q(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_f64)))
-svfloat64_t svtrn2q(svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_f32)))
-svfloat32_t svtrn2q(svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_f16)))
-svfloat16_t svtrn2q(svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s32)))
-svint32_t svtrn2q(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s64)))
-svint64_t svtrn2q(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s16)))
-svint16_t svtrn2q(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u8)))
-svuint8_t svuzp1q(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u32)))
-svuint32_t svuzp1q(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u64)))
-svuint64_t svuzp1q(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u16)))
-svuint16_t svuzp1q(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s8)))
-svint8_t svuzp1q(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_f64)))
-svfloat64_t svuzp1q(svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_f32)))
-svfloat32_t svuzp1q(svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_f16)))
-svfloat16_t svuzp1q(svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s32)))
-svint32_t svuzp1q(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s64)))
-svint64_t svuzp1q(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s16)))
-svint16_t svuzp1q(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u8)))
-svuint8_t svuzp2q(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u32)))
-svuint32_t svuzp2q(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u64)))
-svuint64_t svuzp2q(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u16)))
-svuint16_t svuzp2q(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s8)))
-svint8_t svuzp2q(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_f64)))
-svfloat64_t svuzp2q(svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_f32)))
-svfloat32_t svuzp2q(svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_f16)))
-svfloat16_t svuzp2q(svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s32)))
-svint32_t svuzp2q(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s64)))
-svint64_t svuzp2q(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s16)))
-svint16_t svuzp2q(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u8)))
-svuint8_t svzip1q(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u32)))
-svuint32_t svzip1q(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u64)))
-svuint64_t svzip1q(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u16)))
-svuint16_t svzip1q(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s8)))
-svint8_t svzip1q(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_f64)))
-svfloat64_t svzip1q(svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_f32)))
-svfloat32_t svzip1q(svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_f16)))
-svfloat16_t svzip1q(svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s32)))
-svint32_t svzip1q(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s64)))
-svint64_t svzip1q(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s16)))
-svint16_t svzip1q(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u8)))
-svuint8_t svzip2q(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u32)))
-svuint32_t svzip2q(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u64)))
-svuint64_t svzip2q(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u16)))
-svuint16_t svzip2q(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s8)))
-svint8_t svzip2q(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_f64)))
-svfloat64_t svzip2q(svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_f32)))
-svfloat32_t svzip2q(svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_f16)))
-svfloat16_t svzip2q(svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s32)))
-svint32_t svzip2q(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s64)))
-svint64_t svzip2q(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s16)))
-svint16_t svzip2q(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_bf16)))
-svbfloat16_t svld1ro_bf16(svbool_t, bfloat16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_bf16)))
-svbfloat16_t svld1ro(svbool_t, bfloat16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_s32)))
-svint32_t svmmla_s32(svint32_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_u32)))
-svuint32_t svmmla_u32(svuint32_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsudot_n_s32)))
-svint32_t svsudot_n_s32(svint32_t, svint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsudot_s32)))
-svint32_t svsudot_s32(svint32_t, svint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsudot_lane_s32)))
-svint32_t svsudot_lane_s32(svint32_t, svint8_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusdot_n_s32)))
-svint32_t svusdot_n_s32(svint32_t, svuint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusdot_s32)))
-svint32_t svusdot_s32(svint32_t, svuint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusdot_lane_s32)))
-svint32_t svusdot_lane_s32(svint32_t, svuint8_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusmmla_s32)))
-svint32_t svusmmla_s32(svint32_t, svuint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_s32)))
-svint32_t svmmla(svint32_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_u32)))
-svuint32_t svmmla(svuint32_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsudot_n_s32)))
-svint32_t svsudot(svint32_t, svint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsudot_s32)))
-svint32_t svsudot(svint32_t, svint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsudot_lane_s32)))
-svint32_t svsudot_lane(svint32_t, svint8_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusdot_n_s32)))
-svint32_t svusdot(svint32_t, svuint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusdot_s32)))
-svint32_t svusdot(svint32_t, svuint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusdot_lane_s32)))
-svint32_t svusdot_lane(svint32_t, svuint8_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusmmla_s32)))
-svint32_t svusmmla(svint32_t, svuint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s8)))
-svint8_t svaba_n_s8(svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s32)))
-svint32_t svaba_n_s32(svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s64)))
-svint64_t svaba_n_s64(svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s16)))
-svint16_t svaba_n_s16(svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u8)))
-svuint8_t svaba_n_u8(svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u32)))
-svuint32_t svaba_n_u32(svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u64)))
-svuint64_t svaba_n_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u16)))
-svuint16_t svaba_n_u16(svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s8)))
-svint8_t svaba_s8(svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s32)))
-svint32_t svaba_s32(svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s64)))
-svint64_t svaba_s64(svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s16)))
-svint16_t svaba_s16(svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u8)))
-svuint8_t svaba_u8(svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u32)))
-svuint32_t svaba_u32(svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u64)))
-svuint64_t svaba_u64(svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u16)))
-svuint16_t svaba_u16(svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_s32)))
-svint32_t svabalb_n_s32(svint32_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_s64)))
-svint64_t svabalb_n_s64(svint64_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_s16)))
-svint16_t svabalb_n_s16(svint16_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_u32)))
-svuint32_t svabalb_n_u32(svuint32_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_u64)))
-svuint64_t svabalb_n_u64(svuint64_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_u16)))
-svuint16_t svabalb_n_u16(svuint16_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_s32)))
-svint32_t svabalb_s32(svint32_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_s64)))
-svint64_t svabalb_s64(svint64_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_s16)))
-svint16_t svabalb_s16(svint16_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_u32)))
-svuint32_t svabalb_u32(svuint32_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_u64)))
-svuint64_t svabalb_u64(svuint64_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_u16)))
-svuint16_t svabalb_u16(svuint16_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_s32)))
-svint32_t svabalt_n_s32(svint32_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_s64)))
-svint64_t svabalt_n_s64(svint64_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_s16)))
-svint16_t svabalt_n_s16(svint16_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_u32)))
-svuint32_t svabalt_n_u32(svuint32_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_u64)))
-svuint64_t svabalt_n_u64(svuint64_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_u16)))
-svuint16_t svabalt_n_u16(svuint16_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_s32)))
-svint32_t svabalt_s32(svint32_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_s64)))
-svint64_t svabalt_s64(svint64_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_s16)))
-svint16_t svabalt_s16(svint16_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_u32)))
-svuint32_t svabalt_u32(svuint32_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_u64)))
-svuint64_t svabalt_u64(svuint64_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_u16)))
-svuint16_t svabalt_u16(svuint16_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_s32)))
-svint32_t svabdlb_n_s32(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_s64)))
-svint64_t svabdlb_n_s64(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_s16)))
-svint16_t svabdlb_n_s16(svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_u32)))
-svuint32_t svabdlb_n_u32(svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_u64)))
-svuint64_t svabdlb_n_u64(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_u16)))
-svuint16_t svabdlb_n_u16(svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_s32)))
-svint32_t svabdlb_s32(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_s64)))
-svint64_t svabdlb_s64(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_s16)))
-svint16_t svabdlb_s16(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_u32)))
-svuint32_t svabdlb_u32(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_u64)))
-svuint64_t svabdlb_u64(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_u16)))
-svuint16_t svabdlb_u16(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_s32)))
-svint32_t svabdlt_n_s32(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_s64)))
-svint64_t svabdlt_n_s64(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_s16)))
-svint16_t svabdlt_n_s16(svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_u32)))
-svuint32_t svabdlt_n_u32(svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_u64)))
-svuint64_t svabdlt_n_u64(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_u16)))
-svuint16_t svabdlt_n_u16(svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_s32)))
-svint32_t svabdlt_s32(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_s64)))
-svint64_t svabdlt_s64(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_s16)))
-svint16_t svabdlt_s16(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_u32)))
-svuint32_t svabdlt_u32(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_u64)))
-svuint64_t svabdlt_u64(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_u16)))
-svuint16_t svabdlt_u16(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s32_m)))
-svint32_t svadalp_s32_m(svbool_t, svint32_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s64_m)))
-svint64_t svadalp_s64_m(svbool_t, svint64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s16_m)))
-svint16_t svadalp_s16_m(svbool_t, svint16_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s32_x)))
-svint32_t svadalp_s32_x(svbool_t, svint32_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s64_x)))
-svint64_t svadalp_s64_x(svbool_t, svint64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s16_x)))
-svint16_t svadalp_s16_x(svbool_t, svint16_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s32_z)))
-svint32_t svadalp_s32_z(svbool_t, svint32_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s64_z)))
-svint64_t svadalp_s64_z(svbool_t, svint64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s16_z)))
-svint16_t svadalp_s16_z(svbool_t, svint16_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u32_m)))
-svuint32_t svadalp_u32_m(svbool_t, svuint32_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u64_m)))
-svuint64_t svadalp_u64_m(svbool_t, svuint64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u16_m)))
-svuint16_t svadalp_u16_m(svbool_t, svuint16_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u32_x)))
-svuint32_t svadalp_u32_x(svbool_t, svuint32_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u64_x)))
-svuint64_t svadalp_u64_x(svbool_t, svuint64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u16_x)))
-svuint16_t svadalp_u16_x(svbool_t, svuint16_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u32_z)))
-svuint32_t svadalp_u32_z(svbool_t, svuint32_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u64_z)))
-svuint64_t svadalp_u64_z(svbool_t, svuint64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u16_z)))
-svuint16_t svadalp_u16_z(svbool_t, svuint16_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_n_u32)))
-svuint32_t svadclb_n_u32(svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_n_u64)))
-svuint64_t svadclb_n_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_u32)))
-svuint32_t svadclb_u32(svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_u64)))
-svuint64_t svadclb_u64(svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_n_u32)))
-svuint32_t svadclt_n_u32(svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_n_u64)))
-svuint64_t svadclt_n_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_u32)))
-svuint32_t svadclt_u32(svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_u64)))
-svuint64_t svadclt_u64(svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_u32)))
-svuint16_t svaddhnb_n_u32(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_u64)))
-svuint32_t svaddhnb_n_u64(svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_u16)))
-svuint8_t svaddhnb_n_u16(svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_s32)))
-svint16_t svaddhnb_n_s32(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_s64)))
-svint32_t svaddhnb_n_s64(svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_s16)))
-svint8_t svaddhnb_n_s16(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_u32)))
-svuint16_t svaddhnb_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_u64)))
-svuint32_t svaddhnb_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_u16)))
-svuint8_t svaddhnb_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_s32)))
-svint16_t svaddhnb_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_s64)))
-svint32_t svaddhnb_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_s16)))
-svint8_t svaddhnb_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_u32)))
-svuint16_t svaddhnt_n_u32(svuint16_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_u64)))
-svuint32_t svaddhnt_n_u64(svuint32_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_u16)))
-svuint8_t svaddhnt_n_u16(svuint8_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_s32)))
-svint16_t svaddhnt_n_s32(svint16_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_s64)))
-svint32_t svaddhnt_n_s64(svint32_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_s16)))
-svint8_t svaddhnt_n_s16(svint8_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_u32)))
-svuint16_t svaddhnt_u32(svuint16_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_u64)))
-svuint32_t svaddhnt_u64(svuint32_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_u16)))
-svuint8_t svaddhnt_u16(svuint8_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_s32)))
-svint16_t svaddhnt_s32(svint16_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_s64)))
-svint32_t svaddhnt_s64(svint32_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_s16)))
-svint8_t svaddhnt_s16(svint8_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_s32)))
-svint32_t svaddlb_n_s32(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_s64)))
-svint64_t svaddlb_n_s64(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_s16)))
-svint16_t svaddlb_n_s16(svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_u32)))
-svuint32_t svaddlb_n_u32(svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_u64)))
-svuint64_t svaddlb_n_u64(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_u16)))
-svuint16_t svaddlb_n_u16(svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_s32)))
-svint32_t svaddlb_s32(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_s64)))
-svint64_t svaddlb_s64(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_s16)))
-svint16_t svaddlb_s16(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_u32)))
-svuint32_t svaddlb_u32(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_u64)))
-svuint64_t svaddlb_u64(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_u16)))
-svuint16_t svaddlb_u16(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_n_s32)))
-svint32_t svaddlbt_n_s32(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_n_s64)))
-svint64_t svaddlbt_n_s64(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_n_s16)))
-svint16_t svaddlbt_n_s16(svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_s32)))
-svint32_t svaddlbt_s32(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_s64)))
-svint64_t svaddlbt_s64(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_s16)))
-svint16_t svaddlbt_s16(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_s32)))
-svint32_t svaddlt_n_s32(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_s64)))
-svint64_t svaddlt_n_s64(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_s16)))
-svint16_t svaddlt_n_s16(svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_u32)))
-svuint32_t svaddlt_n_u32(svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_u64)))
-svuint64_t svaddlt_n_u64(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_u16)))
-svuint16_t svaddlt_n_u16(svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_s32)))
-svint32_t svaddlt_s32(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_s64)))
-svint64_t svaddlt_s64(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_s16)))
-svint16_t svaddlt_s16(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_u32)))
-svuint32_t svaddlt_u32(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_u64)))
-svuint64_t svaddlt_u64(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_u16)))
-svuint16_t svaddlt_u16(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f64_m)))
-svfloat64_t svaddp_f64_m(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f32_m)))
-svfloat32_t svaddp_f32_m(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f16_m)))
-svfloat16_t svaddp_f16_m(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f64_x)))
-svfloat64_t svaddp_f64_x(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f32_x)))
-svfloat32_t svaddp_f32_x(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f16_x)))
-svfloat16_t svaddp_f16_x(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u8_m)))
-svuint8_t svaddp_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u32_m)))
-svuint32_t svaddp_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u64_m)))
-svuint64_t svaddp_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u16_m)))
-svuint16_t svaddp_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s8_m)))
-svint8_t svaddp_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s32_m)))
-svint32_t svaddp_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s64_m)))
-svint64_t svaddp_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s16_m)))
-svint16_t svaddp_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u8_x)))
-svuint8_t svaddp_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u32_x)))
-svuint32_t svaddp_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u64_x)))
-svuint64_t svaddp_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u16_x)))
-svuint16_t svaddp_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s8_x)))
-svint8_t svaddp_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s32_x)))
-svint32_t svaddp_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s64_x)))
-svint64_t svaddp_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s16_x)))
-svint16_t svaddp_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_s32)))
-svint32_t svaddwb_n_s32(svint32_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_s64)))
-svint64_t svaddwb_n_s64(svint64_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_s16)))
-svint16_t svaddwb_n_s16(svint16_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_u32)))
-svuint32_t svaddwb_n_u32(svuint32_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_u64)))
-svuint64_t svaddwb_n_u64(svuint64_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_u16)))
-svuint16_t svaddwb_n_u16(svuint16_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_s32)))
-svint32_t svaddwb_s32(svint32_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_s64)))
-svint64_t svaddwb_s64(svint64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_s16)))
-svint16_t svaddwb_s16(svint16_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_u32)))
-svuint32_t svaddwb_u32(svuint32_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_u64)))
-svuint64_t svaddwb_u64(svuint64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_u16)))
-svuint16_t svaddwb_u16(svuint16_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_s32)))
-svint32_t svaddwt_n_s32(svint32_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_s64)))
-svint64_t svaddwt_n_s64(svint64_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_s16)))
-svint16_t svaddwt_n_s16(svint16_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_u32)))
-svuint32_t svaddwt_n_u32(svuint32_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_u64)))
-svuint64_t svaddwt_n_u64(svuint64_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_u16)))
-svuint16_t svaddwt_n_u16(svuint16_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_s32)))
-svint32_t svaddwt_s32(svint32_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_s64)))
-svint64_t svaddwt_s64(svint64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_s16)))
-svint16_t svaddwt_s16(svint16_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_u32)))
-svuint32_t svaddwt_u32(svuint32_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_u64)))
-svuint64_t svaddwt_u64(svuint64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_u16)))
-svuint16_t svaddwt_u16(svuint16_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u8)))
-svuint8_t svbcax_n_u8(svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u32)))
-svuint32_t svbcax_n_u32(svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u64)))
-svuint64_t svbcax_n_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u16)))
-svuint16_t svbcax_n_u16(svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s8)))
-svint8_t svbcax_n_s8(svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s32)))
-svint32_t svbcax_n_s32(svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s64)))
-svint64_t svbcax_n_s64(svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s16)))
-svint16_t svbcax_n_s16(svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u8)))
-svuint8_t svbcax_u8(svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u32)))
-svuint32_t svbcax_u32(svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u64)))
-svuint64_t svbcax_u64(svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u16)))
-svuint16_t svbcax_u16(svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s8)))
-svint8_t svbcax_s8(svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s32)))
-svint32_t svbcax_s32(svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s64)))
-svint64_t svbcax_s64(svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s16)))
-svint16_t svbcax_s16(svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u8)))
-svuint8_t svbsl1n_n_u8(svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u32)))
-svuint32_t svbsl1n_n_u32(svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u64)))
-svuint64_t svbsl1n_n_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u16)))
-svuint16_t svbsl1n_n_u16(svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s8)))
-svint8_t svbsl1n_n_s8(svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s32)))
-svint32_t svbsl1n_n_s32(svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s64)))
-svint64_t svbsl1n_n_s64(svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s16)))
-svint16_t svbsl1n_n_s16(svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u8)))
-svuint8_t svbsl1n_u8(svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u32)))
-svuint32_t svbsl1n_u32(svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u64)))
-svuint64_t svbsl1n_u64(svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u16)))
-svuint16_t svbsl1n_u16(svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s8)))
-svint8_t svbsl1n_s8(svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s32)))
-svint32_t svbsl1n_s32(svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s64)))
-svint64_t svbsl1n_s64(svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s16)))
-svint16_t svbsl1n_s16(svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u8)))
-svuint8_t svbsl2n_n_u8(svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u32)))
-svuint32_t svbsl2n_n_u32(svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u64)))
-svuint64_t svbsl2n_n_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u16)))
-svuint16_t svbsl2n_n_u16(svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s8)))
-svint8_t svbsl2n_n_s8(svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s32)))
-svint32_t svbsl2n_n_s32(svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s64)))
-svint64_t svbsl2n_n_s64(svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s16)))
-svint16_t svbsl2n_n_s16(svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u8)))
-svuint8_t svbsl2n_u8(svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u32)))
-svuint32_t svbsl2n_u32(svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u64)))
-svuint64_t svbsl2n_u64(svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u16)))
-svuint16_t svbsl2n_u16(svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s8)))
-svint8_t svbsl2n_s8(svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s32)))
-svint32_t svbsl2n_s32(svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s64)))
-svint64_t svbsl2n_s64(svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s16)))
-svint16_t svbsl2n_s16(svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u8)))
-svuint8_t svbsl_n_u8(svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u32)))
-svuint32_t svbsl_n_u32(svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u64)))
-svuint64_t svbsl_n_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u16)))
-svuint16_t svbsl_n_u16(svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s8)))
-svint8_t svbsl_n_s8(svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s32)))
-svint32_t svbsl_n_s32(svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s64)))
-svint64_t svbsl_n_s64(svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s16)))
-svint16_t svbsl_n_s16(svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u8)))
-svuint8_t svbsl_u8(svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u32)))
-svuint32_t svbsl_u32(svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u64)))
-svuint64_t svbsl_u64(svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u16)))
-svuint16_t svbsl_u16(svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s8)))
-svint8_t svbsl_s8(svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s32)))
-svint32_t svbsl_s32(svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s64)))
-svint64_t svbsl_s64(svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s16)))
-svint16_t svbsl_s16(svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u8)))
-svuint8_t svcadd_u8(svuint8_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u32)))
-svuint32_t svcadd_u32(svuint32_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u64)))
-svuint64_t svcadd_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u16)))
-svuint16_t svcadd_u16(svuint16_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s8)))
-svint8_t svcadd_s8(svint8_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s32)))
-svint32_t svcadd_s32(svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s64)))
-svint64_t svcadd_s64(svint64_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s16)))
-svint16_t svcadd_s16(svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_s32)))
-svint32_t svcdot_s32(svint32_t, svint8_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_s64)))
-svint64_t svcdot_s64(svint64_t, svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_lane_s32)))
-svint32_t svcdot_lane_s32(svint32_t, svint8_t, svint8_t, uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_lane_s64)))
-svint64_t svcdot_lane_s64(svint64_t, svint16_t, svint16_t, uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u8)))
-svuint8_t svcmla_u8(svuint8_t, svuint8_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u32)))
-svuint32_t svcmla_u32(svuint32_t, svuint32_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u64)))
-svuint64_t svcmla_u64(svuint64_t, svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u16)))
-svuint16_t svcmla_u16(svuint16_t, svuint16_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s8)))
-svint8_t svcmla_s8(svint8_t, svint8_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s32)))
-svint32_t svcmla_s32(svint32_t, svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s64)))
-svint64_t svcmla_s64(svint64_t, svint64_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s16)))
-svint16_t svcmla_s16(svint16_t, svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_u32)))
-svuint32_t svcmla_lane_u32(svuint32_t, svuint32_t, svuint32_t, uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_u16)))
-svuint16_t svcmla_lane_u16(svuint16_t, svuint16_t, svuint16_t, uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_s32)))
-svint32_t svcmla_lane_s32(svint32_t, svint32_t, svint32_t, uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_s16)))
-svint16_t svcmla_lane_s16(svint16_t, svint16_t, svint16_t, uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f32_f16_m)))
-svfloat32_t svcvtlt_f32_f16_m(svfloat32_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f32_f16_x)))
-svfloat32_t svcvtlt_f32_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f64_f32_m)))
-svfloat64_t svcvtlt_f64_f32_m(svfloat64_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f64_f32_x)))
-svfloat64_t svcvtlt_f64_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtnt_f16_f32_m)))
-svfloat16_t svcvtnt_f16_f32_m(svfloat16_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtnt_f32_f64_m)))
-svfloat32_t svcvtnt_f32_f64_m(svfloat32_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtx_f32_f64_m)))
-svfloat32_t svcvtx_f32_f64_m(svfloat32_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtx_f32_f64_x)))
-svfloat32_t svcvtx_f32_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtx_f32_f64_z)))
-svfloat32_t svcvtx_f32_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtxnt_f32_f64_m)))
-svfloat32_t svcvtxnt_f32_f64_m(svfloat32_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u8)))
-svuint8_t sveor3_n_u8(svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u32)))
-svuint32_t sveor3_n_u32(svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u64)))
-svuint64_t sveor3_n_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u16)))
-svuint16_t sveor3_n_u16(svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s8)))
-svint8_t sveor3_n_s8(svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s32)))
-svint32_t sveor3_n_s32(svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s64)))
-svint64_t sveor3_n_s64(svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s16)))
-svint16_t sveor3_n_s16(svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u8)))
-svuint8_t sveor3_u8(svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u32)))
-svuint32_t sveor3_u32(svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u64)))
-svuint64_t sveor3_u64(svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u16)))
-svuint16_t sveor3_u16(svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s8)))
-svint8_t sveor3_s8(svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s32)))
-svint32_t sveor3_s32(svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s64)))
-svint64_t sveor3_s64(svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s16)))
-svint16_t sveor3_s16(svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u8)))
-svuint8_t sveorbt_n_u8(svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u32)))
-svuint32_t sveorbt_n_u32(svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u64)))
-svuint64_t sveorbt_n_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u16)))
-svuint16_t sveorbt_n_u16(svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s8)))
-svint8_t sveorbt_n_s8(svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s32)))
-svint32_t sveorbt_n_s32(svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s64)))
-svint64_t sveorbt_n_s64(svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s16)))
-svint16_t sveorbt_n_s16(svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u8)))
-svuint8_t sveorbt_u8(svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u32)))
-svuint32_t sveorbt_u32(svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u64)))
-svuint64_t sveorbt_u64(svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u16)))
-svuint16_t sveorbt_u16(svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s8)))
-svint8_t sveorbt_s8(svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s32)))
-svint32_t sveorbt_s32(svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s64)))
-svint64_t sveorbt_s64(svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s16)))
-svint16_t sveorbt_s16(svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u8)))
-svuint8_t sveortb_n_u8(svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u32)))
-svuint32_t sveortb_n_u32(svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u64)))
-svuint64_t sveortb_n_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u16)))
-svuint16_t sveortb_n_u16(svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s8)))
-svint8_t sveortb_n_s8(svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s32)))
-svint32_t sveortb_n_s32(svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s64)))
-svint64_t sveortb_n_s64(svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s16)))
-svint16_t sveortb_n_s16(svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u8)))
-svuint8_t sveortb_u8(svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u32)))
-svuint32_t sveortb_u32(svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u64)))
-svuint64_t sveortb_u64(svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u16)))
-svuint16_t sveortb_u16(svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s8)))
-svint8_t sveortb_s8(svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s32)))
-svint32_t sveortb_s32(svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s64)))
-svint64_t sveortb_s64(svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s16)))
-svint16_t sveortb_s16(svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s8_m)))
-svint8_t svhadd_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s32_m)))
-svint32_t svhadd_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s64_m)))
-svint64_t svhadd_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s16_m)))
-svint16_t svhadd_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s8_x)))
-svint8_t svhadd_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s32_x)))
-svint32_t svhadd_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s64_x)))
-svint64_t svhadd_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s16_x)))
-svint16_t svhadd_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s8_z)))
-svint8_t svhadd_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s32_z)))
-svint32_t svhadd_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s64_z)))
-svint64_t svhadd_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s16_z)))
-svint16_t svhadd_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u8_m)))
-svuint8_t svhadd_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u32_m)))
-svuint32_t svhadd_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u64_m)))
-svuint64_t svhadd_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u16_m)))
-svuint16_t svhadd_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u8_x)))
-svuint8_t svhadd_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u32_x)))
-svuint32_t svhadd_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u64_x)))
-svuint64_t svhadd_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u16_x)))
-svuint16_t svhadd_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u8_z)))
-svuint8_t svhadd_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u32_z)))
-svuint32_t svhadd_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u64_z)))
-svuint64_t svhadd_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u16_z)))
-svuint16_t svhadd_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s8_m)))
-svint8_t svhadd_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s32_m)))
-svint32_t svhadd_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s64_m)))
-svint64_t svhadd_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s16_m)))
-svint16_t svhadd_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s8_x)))
-svint8_t svhadd_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s32_x)))
-svint32_t svhadd_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s64_x)))
-svint64_t svhadd_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s16_x)))
-svint16_t svhadd_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s8_z)))
-svint8_t svhadd_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s32_z)))
-svint32_t svhadd_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s64_z)))
-svint64_t svhadd_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s16_z)))
-svint16_t svhadd_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u8_m)))
-svuint8_t svhadd_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u32_m)))
-svuint32_t svhadd_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u64_m)))
-svuint64_t svhadd_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u16_m)))
-svuint16_t svhadd_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u8_x)))
-svuint8_t svhadd_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u32_x)))
-svuint32_t svhadd_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u64_x)))
-svuint64_t svhadd_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u16_x)))
-svuint16_t svhadd_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u8_z)))
-svuint8_t svhadd_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u32_z)))
-svuint32_t svhadd_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u64_z)))
-svuint64_t svhadd_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u16_z)))
-svuint16_t svhadd_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_u32_z)))
-svuint32_t svhistcnt_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_u64_z)))
-svuint64_t svhistcnt_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_s32_z)))
-svuint32_t svhistcnt_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_s64_z)))
-svuint64_t svhistcnt_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistseg_u8)))
-svuint8_t svhistseg_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistseg_s8)))
-svuint8_t svhistseg_s8(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s8_m)))
-svint8_t svhsub_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s32_m)))
-svint32_t svhsub_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s64_m)))
-svint64_t svhsub_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s16_m)))
-svint16_t svhsub_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s8_x)))
-svint8_t svhsub_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s32_x)))
-svint32_t svhsub_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s64_x)))
-svint64_t svhsub_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s16_x)))
-svint16_t svhsub_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s8_z)))
-svint8_t svhsub_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s32_z)))
-svint32_t svhsub_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s64_z)))
-svint64_t svhsub_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s16_z)))
-svint16_t svhsub_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u8_m)))
-svuint8_t svhsub_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u32_m)))
-svuint32_t svhsub_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u64_m)))
-svuint64_t svhsub_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u16_m)))
-svuint16_t svhsub_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u8_x)))
-svuint8_t svhsub_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u32_x)))
-svuint32_t svhsub_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u64_x)))
-svuint64_t svhsub_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u16_x)))
-svuint16_t svhsub_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u8_z)))
-svuint8_t svhsub_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u32_z)))
-svuint32_t svhsub_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u64_z)))
-svuint64_t svhsub_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u16_z)))
-svuint16_t svhsub_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s8_m)))
-svint8_t svhsub_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s32_m)))
-svint32_t svhsub_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s64_m)))
-svint64_t svhsub_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s16_m)))
-svint16_t svhsub_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s8_x)))
-svint8_t svhsub_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s32_x)))
-svint32_t svhsub_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s64_x)))
-svint64_t svhsub_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s16_x)))
-svint16_t svhsub_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s8_z)))
-svint8_t svhsub_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s32_z)))
-svint32_t svhsub_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s64_z)))
-svint64_t svhsub_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s16_z)))
-svint16_t svhsub_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u8_m)))
-svuint8_t svhsub_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u32_m)))
-svuint32_t svhsub_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u64_m)))
-svuint64_t svhsub_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u16_m)))
-svuint16_t svhsub_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u8_x)))
-svuint8_t svhsub_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u32_x)))
-svuint32_t svhsub_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u64_x)))
-svuint64_t svhsub_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u16_x)))
-svuint16_t svhsub_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u8_z)))
-svuint8_t svhsub_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u32_z)))
-svuint32_t svhsub_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u64_z)))
-svuint64_t svhsub_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u16_z)))
-svuint16_t svhsub_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s8_m)))
-svint8_t svhsubr_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s32_m)))
-svint32_t svhsubr_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s64_m)))
-svint64_t svhsubr_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s16_m)))
-svint16_t svhsubr_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s8_x)))
-svint8_t svhsubr_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s32_x)))
-svint32_t svhsubr_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s64_x)))
-svint64_t svhsubr_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s16_x)))
-svint16_t svhsubr_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s8_z)))
-svint8_t svhsubr_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s32_z)))
-svint32_t svhsubr_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s64_z)))
-svint64_t svhsubr_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s16_z)))
-svint16_t svhsubr_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u8_m)))
-svuint8_t svhsubr_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u32_m)))
-svuint32_t svhsubr_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u64_m)))
-svuint64_t svhsubr_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u16_m)))
-svuint16_t svhsubr_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u8_x)))
-svuint8_t svhsubr_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u32_x)))
-svuint32_t svhsubr_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u64_x)))
-svuint64_t svhsubr_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u16_x)))
-svuint16_t svhsubr_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u8_z)))
-svuint8_t svhsubr_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u32_z)))
-svuint32_t svhsubr_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u64_z)))
-svuint64_t svhsubr_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u16_z)))
-svuint16_t svhsubr_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s8_m)))
-svint8_t svhsubr_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s32_m)))
-svint32_t svhsubr_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s64_m)))
-svint64_t svhsubr_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s16_m)))
-svint16_t svhsubr_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s8_x)))
-svint8_t svhsubr_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s32_x)))
-svint32_t svhsubr_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s64_x)))
-svint64_t svhsubr_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s16_x)))
-svint16_t svhsubr_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s8_z)))
-svint8_t svhsubr_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s32_z)))
-svint32_t svhsubr_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s64_z)))
-svint64_t svhsubr_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s16_z)))
-svint16_t svhsubr_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u8_m)))
-svuint8_t svhsubr_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u32_m)))
-svuint32_t svhsubr_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u64_m)))
-svuint64_t svhsubr_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u16_m)))
-svuint16_t svhsubr_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u8_x)))
-svuint8_t svhsubr_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u32_x)))
-svuint32_t svhsubr_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u64_x)))
-svuint64_t svhsubr_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u16_x)))
-svuint16_t svhsubr_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u8_z)))
-svuint8_t svhsubr_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u32_z)))
-svuint32_t svhsubr_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u64_z)))
-svuint64_t svhsubr_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u16_z)))
-svuint16_t svhsubr_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_index_u32)))
-svuint32_t svldnt1_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_index_u64)))
-svuint64_t svldnt1_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_index_f64)))
-svfloat64_t svldnt1_gather_u64base_index_f64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_index_f32)))
-svfloat32_t svldnt1_gather_u32base_index_f32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_index_s32)))
-svint32_t svldnt1_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_index_s64)))
-svint64_t svldnt1_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_offset_u32)))
-svuint32_t svldnt1_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_offset_u64)))
-svuint64_t svldnt1_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_offset_f64)))
-svfloat64_t svldnt1_gather_u64base_offset_f64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_offset_f32)))
-svfloat32_t svldnt1_gather_u32base_offset_f32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_offset_s32)))
-svint32_t svldnt1_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_offset_s64)))
-svint64_t svldnt1_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_u32)))
-svuint32_t svldnt1_gather_u32base_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_u64)))
-svuint64_t svldnt1_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_f64)))
-svfloat64_t svldnt1_gather_u64base_f64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_f32)))
-svfloat32_t svldnt1_gather_u32base_f32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_s32)))
-svint32_t svldnt1_gather_u32base_s32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_s64)))
-svint64_t svldnt1_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64index_u64)))
-svuint64_t svldnt1_gather_s64index_u64(svbool_t, uint64_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64index_f64)))
-svfloat64_t svldnt1_gather_s64index_f64(svbool_t, float64_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64index_s64)))
-svint64_t svldnt1_gather_s64index_s64(svbool_t, int64_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64index_u64)))
-svuint64_t svldnt1_gather_u64index_u64(svbool_t, uint64_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64index_f64)))
-svfloat64_t svldnt1_gather_u64index_f64(svbool_t, float64_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64index_s64)))
-svint64_t svldnt1_gather_u64index_s64(svbool_t, int64_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32offset_u32)))
-svuint32_t svldnt1_gather_u32offset_u32(svbool_t, uint32_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32offset_f32)))
-svfloat32_t svldnt1_gather_u32offset_f32(svbool_t, float32_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32offset_s32)))
-svint32_t svldnt1_gather_u32offset_s32(svbool_t, int32_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64offset_u64)))
-svuint64_t svldnt1_gather_s64offset_u64(svbool_t, uint64_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64offset_f64)))
-svfloat64_t svldnt1_gather_s64offset_f64(svbool_t, float64_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64offset_s64)))
-svint64_t svldnt1_gather_s64offset_s64(svbool_t, int64_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64offset_u64)))
-svuint64_t svldnt1_gather_u64offset_u64(svbool_t, uint64_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64offset_f64)))
-svfloat64_t svldnt1_gather_u64offset_f64(svbool_t, float64_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64offset_s64)))
-svint64_t svldnt1_gather_u64offset_s64(svbool_t, int64_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_offset_u32)))
-svuint32_t svldnt1sb_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_offset_u64)))
-svuint64_t svldnt1sb_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_offset_s32)))
-svint32_t svldnt1sb_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_offset_s64)))
-svint64_t svldnt1sb_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_u32)))
-svuint32_t svldnt1sb_gather_u32base_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_u64)))
-svuint64_t svldnt1sb_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_s32)))
-svint32_t svldnt1sb_gather_u32base_s32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_s64)))
-svint64_t svldnt1sb_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32offset_u32)))
-svuint32_t svldnt1sb_gather_u32offset_u32(svbool_t, int8_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32offset_s32)))
-svint32_t svldnt1sb_gather_u32offset_s32(svbool_t, int8_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_s64offset_u64)))
-svuint64_t svldnt1sb_gather_s64offset_u64(svbool_t, int8_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_s64offset_s64)))
-svint64_t svldnt1sb_gather_s64offset_s64(svbool_t, int8_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64offset_u64)))
-svuint64_t svldnt1sb_gather_u64offset_u64(svbool_t, int8_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64offset_s64)))
-svint64_t svldnt1sb_gather_u64offset_s64(svbool_t, int8_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_index_u32)))
-svuint32_t svldnt1sh_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_index_u64)))
-svuint64_t svldnt1sh_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_index_s32)))
-svint32_t svldnt1sh_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_index_s64)))
-svint64_t svldnt1sh_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_offset_u32)))
-svuint32_t svldnt1sh_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_offset_u64)))
-svuint64_t svldnt1sh_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_offset_s32)))
-svint32_t svldnt1sh_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_offset_s64)))
-svint64_t svldnt1sh_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_u32)))
-svuint32_t svldnt1sh_gather_u32base_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_u64)))
-svuint64_t svldnt1sh_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_s32)))
-svint32_t svldnt1sh_gather_u32base_s32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_s64)))
-svint64_t svldnt1sh_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64index_u64)))
-svuint64_t svldnt1sh_gather_s64index_u64(svbool_t, int16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64index_s64)))
-svint64_t svldnt1sh_gather_s64index_s64(svbool_t, int16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64index_u64)))
-svuint64_t svldnt1sh_gather_u64index_u64(svbool_t, int16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64index_s64)))
-svint64_t svldnt1sh_gather_u64index_s64(svbool_t, int16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32offset_u32)))
-svuint32_t svldnt1sh_gather_u32offset_u32(svbool_t, int16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32offset_s32)))
-svint32_t svldnt1sh_gather_u32offset_s32(svbool_t, int16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64offset_u64)))
-svuint64_t svldnt1sh_gather_s64offset_u64(svbool_t, int16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64offset_s64)))
-svint64_t svldnt1sh_gather_s64offset_s64(svbool_t, int16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64offset_u64)))
-svuint64_t svldnt1sh_gather_u64offset_u64(svbool_t, int16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64offset_s64)))
-svint64_t svldnt1sh_gather_u64offset_s64(svbool_t, int16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_index_u64)))
-svuint64_t svldnt1sw_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_index_s64)))
-svint64_t svldnt1sw_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_offset_u64)))
-svuint64_t svldnt1sw_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_offset_s64)))
-svint64_t svldnt1sw_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_u64)))
-svuint64_t svldnt1sw_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_s64)))
-svint64_t svldnt1sw_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64index_u64)))
-svuint64_t svldnt1sw_gather_s64index_u64(svbool_t, int32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64index_s64)))
-svint64_t svldnt1sw_gather_s64index_s64(svbool_t, int32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64index_u64)))
-svuint64_t svldnt1sw_gather_u64index_u64(svbool_t, int32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64index_s64)))
-svint64_t svldnt1sw_gather_u64index_s64(svbool_t, int32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64offset_u64)))
-svuint64_t svldnt1sw_gather_s64offset_u64(svbool_t, int32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64offset_s64)))
-svint64_t svldnt1sw_gather_s64offset_s64(svbool_t, int32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64offset_u64)))
-svuint64_t svldnt1sw_gather_u64offset_u64(svbool_t, int32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64offset_s64)))
-svint64_t svldnt1sw_gather_u64offset_s64(svbool_t, int32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_offset_u32)))
-svuint32_t svldnt1ub_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_offset_u64)))
-svuint64_t svldnt1ub_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_offset_s32)))
-svint32_t svldnt1ub_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_offset_s64)))
-svint64_t svldnt1ub_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_u32)))
-svuint32_t svldnt1ub_gather_u32base_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_u64)))
-svuint64_t svldnt1ub_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_s32)))
-svint32_t svldnt1ub_gather_u32base_s32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_s64)))
-svint64_t svldnt1ub_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32offset_u32)))
-svuint32_t svldnt1ub_gather_u32offset_u32(svbool_t, uint8_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32offset_s32)))
-svint32_t svldnt1ub_gather_u32offset_s32(svbool_t, uint8_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_s64offset_u64)))
-svuint64_t svldnt1ub_gather_s64offset_u64(svbool_t, uint8_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_s64offset_s64)))
-svint64_t svldnt1ub_gather_s64offset_s64(svbool_t, uint8_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64offset_u64)))
-svuint64_t svldnt1ub_gather_u64offset_u64(svbool_t, uint8_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64offset_s64)))
-svint64_t svldnt1ub_gather_u64offset_s64(svbool_t, uint8_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_index_u32)))
-svuint32_t svldnt1uh_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_index_u64)))
-svuint64_t svldnt1uh_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_index_s32)))
-svint32_t svldnt1uh_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_index_s64)))
-svint64_t svldnt1uh_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_offset_u32)))
-svuint32_t svldnt1uh_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_offset_u64)))
-svuint64_t svldnt1uh_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_offset_s32)))
-svint32_t svldnt1uh_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_offset_s64)))
-svint64_t svldnt1uh_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_u32)))
-svuint32_t svldnt1uh_gather_u32base_u32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_u64)))
-svuint64_t svldnt1uh_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_s32)))
-svint32_t svldnt1uh_gather_u32base_s32(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_s64)))
-svint64_t svldnt1uh_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64index_u64)))
-svuint64_t svldnt1uh_gather_s64index_u64(svbool_t, uint16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64index_s64)))
-svint64_t svldnt1uh_gather_s64index_s64(svbool_t, uint16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64index_u64)))
-svuint64_t svldnt1uh_gather_u64index_u64(svbool_t, uint16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64index_s64)))
-svint64_t svldnt1uh_gather_u64index_s64(svbool_t, uint16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32offset_u32)))
-svuint32_t svldnt1uh_gather_u32offset_u32(svbool_t, uint16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32offset_s32)))
-svint32_t svldnt1uh_gather_u32offset_s32(svbool_t, uint16_t const *, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64offset_u64)))
-svuint64_t svldnt1uh_gather_s64offset_u64(svbool_t, uint16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64offset_s64)))
-svint64_t svldnt1uh_gather_s64offset_s64(svbool_t, uint16_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64offset_u64)))
-svuint64_t svldnt1uh_gather_u64offset_u64(svbool_t, uint16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64offset_s64)))
-svint64_t svldnt1uh_gather_u64offset_s64(svbool_t, uint16_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_index_u64)))
-svuint64_t svldnt1uw_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_index_s64)))
-svint64_t svldnt1uw_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_offset_u64)))
-svuint64_t svldnt1uw_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_offset_s64)))
-svint64_t svldnt1uw_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_u64)))
-svuint64_t svldnt1uw_gather_u64base_u64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_s64)))
-svint64_t svldnt1uw_gather_u64base_s64(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64index_u64)))
-svuint64_t svldnt1uw_gather_s64index_u64(svbool_t, uint32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64index_s64)))
-svint64_t svldnt1uw_gather_s64index_s64(svbool_t, uint32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64index_u64)))
-svuint64_t svldnt1uw_gather_u64index_u64(svbool_t, uint32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64index_s64)))
-svint64_t svldnt1uw_gather_u64index_s64(svbool_t, uint32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64offset_u64)))
-svuint64_t svldnt1uw_gather_s64offset_u64(svbool_t, uint32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64offset_s64)))
-svint64_t svldnt1uw_gather_s64offset_s64(svbool_t, uint32_t const *, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64offset_u64)))
-svuint64_t svldnt1uw_gather_u64offset_u64(svbool_t, uint32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64offset_s64)))
-svint64_t svldnt1uw_gather_u64offset_s64(svbool_t, uint32_t const *, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f64_m)))
-svint64_t svlogb_f64_m(svint64_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f32_m)))
-svint32_t svlogb_f32_m(svint32_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f16_m)))
-svint16_t svlogb_f16_m(svint16_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f64_x)))
-svint64_t svlogb_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f32_x)))
-svint32_t svlogb_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f16_x)))
-svint16_t svlogb_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f64_z)))
-svint64_t svlogb_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f32_z)))
-svint32_t svlogb_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f16_z)))
-svint16_t svlogb_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_u8)))
-svbool_t svmatch_u8(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_u16)))
-svbool_t svmatch_u16(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_s8)))
-svbool_t svmatch_s8(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_s16)))
-svbool_t svmatch_s16(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f64_m)))
-svfloat64_t svmaxnmp_f64_m(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f32_m)))
-svfloat32_t svmaxnmp_f32_m(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f16_m)))
-svfloat16_t svmaxnmp_f16_m(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f64_x)))
-svfloat64_t svmaxnmp_f64_x(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f32_x)))
-svfloat32_t svmaxnmp_f32_x(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f16_x)))
-svfloat16_t svmaxnmp_f16_x(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f64_m)))
-svfloat64_t svmaxp_f64_m(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f32_m)))
-svfloat32_t svmaxp_f32_m(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f16_m)))
-svfloat16_t svmaxp_f16_m(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f64_x)))
-svfloat64_t svmaxp_f64_x(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f32_x)))
-svfloat32_t svmaxp_f32_x(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f16_x)))
-svfloat16_t svmaxp_f16_x(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s8_m)))
-svint8_t svmaxp_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s32_m)))
-svint32_t svmaxp_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s64_m)))
-svint64_t svmaxp_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s16_m)))
-svint16_t svmaxp_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s8_x)))
-svint8_t svmaxp_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s32_x)))
-svint32_t svmaxp_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s64_x)))
-svint64_t svmaxp_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s16_x)))
-svint16_t svmaxp_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u8_m)))
-svuint8_t svmaxp_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u32_m)))
-svuint32_t svmaxp_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u64_m)))
-svuint64_t svmaxp_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u16_m)))
-svuint16_t svmaxp_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u8_x)))
-svuint8_t svmaxp_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u32_x)))
-svuint32_t svmaxp_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u64_x)))
-svuint64_t svmaxp_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u16_x)))
-svuint16_t svmaxp_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f64_m)))
-svfloat64_t svminnmp_f64_m(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f32_m)))
-svfloat32_t svminnmp_f32_m(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f16_m)))
-svfloat16_t svminnmp_f16_m(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f64_x)))
-svfloat64_t svminnmp_f64_x(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f32_x)))
-svfloat32_t svminnmp_f32_x(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f16_x)))
-svfloat16_t svminnmp_f16_x(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f64_m)))
-svfloat64_t svminp_f64_m(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f32_m)))
-svfloat32_t svminp_f32_m(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f16_m)))
-svfloat16_t svminp_f16_m(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f64_x)))
-svfloat64_t svminp_f64_x(svbool_t, svfloat64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f32_x)))
-svfloat32_t svminp_f32_x(svbool_t, svfloat32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f16_x)))
-svfloat16_t svminp_f16_x(svbool_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s8_m)))
-svint8_t svminp_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s32_m)))
-svint32_t svminp_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s64_m)))
-svint64_t svminp_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s16_m)))
-svint16_t svminp_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s8_x)))
-svint8_t svminp_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s32_x)))
-svint32_t svminp_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s64_x)))
-svint64_t svminp_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s16_x)))
-svint16_t svminp_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u8_m)))
-svuint8_t svminp_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u32_m)))
-svuint32_t svminp_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u64_m)))
-svuint64_t svminp_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u16_m)))
-svuint16_t svminp_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u8_x)))
-svuint8_t svminp_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u32_x)))
-svuint32_t svminp_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u64_x)))
-svuint64_t svminp_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u16_x)))
-svuint16_t svminp_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_u32)))
-svuint32_t svmla_lane_u32(svuint32_t, svuint32_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_u64)))
-svuint64_t svmla_lane_u64(svuint64_t, svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_u16)))
-svuint16_t svmla_lane_u16(svuint16_t, svuint16_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_s32)))
-svint32_t svmla_lane_s32(svint32_t, svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_s64)))
-svint64_t svmla_lane_s64(svint64_t, svint64_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_s16)))
-svint16_t svmla_lane_s16(svint16_t, svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_f32)))
-svfloat32_t svmlalb_n_f32(svfloat32_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_s32)))
-svint32_t svmlalb_n_s32(svint32_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_s64)))
-svint64_t svmlalb_n_s64(svint64_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_s16)))
-svint16_t svmlalb_n_s16(svint16_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_u32)))
-svuint32_t svmlalb_n_u32(svuint32_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_u64)))
-svuint64_t svmlalb_n_u64(svuint64_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_u16)))
-svuint16_t svmlalb_n_u16(svuint16_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_f32)))
-svfloat32_t svmlalb_f32(svfloat32_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_s32)))
-svint32_t svmlalb_s32(svint32_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_s64)))
-svint64_t svmlalb_s64(svint64_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_s16)))
-svint16_t svmlalb_s16(svint16_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_u32)))
-svuint32_t svmlalb_u32(svuint32_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_u64)))
-svuint64_t svmlalb_u64(svuint64_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_u16)))
-svuint16_t svmlalb_u16(svuint16_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_f32)))
-svfloat32_t svmlalb_lane_f32(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_s32)))
-svint32_t svmlalb_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_s64)))
-svint64_t svmlalb_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_u32)))
-svuint32_t svmlalb_lane_u32(svuint32_t, svuint16_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_u64)))
-svuint64_t svmlalb_lane_u64(svuint64_t, svuint32_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_f32)))
-svfloat32_t svmlalt_n_f32(svfloat32_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_s32)))
-svint32_t svmlalt_n_s32(svint32_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_s64)))
-svint64_t svmlalt_n_s64(svint64_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_s16)))
-svint16_t svmlalt_n_s16(svint16_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_u32)))
-svuint32_t svmlalt_n_u32(svuint32_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_u64)))
-svuint64_t svmlalt_n_u64(svuint64_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_u16)))
-svuint16_t svmlalt_n_u16(svuint16_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_f32)))
-svfloat32_t svmlalt_f32(svfloat32_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_s32)))
-svint32_t svmlalt_s32(svint32_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_s64)))
-svint64_t svmlalt_s64(svint64_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_s16)))
-svint16_t svmlalt_s16(svint16_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_u32)))
-svuint32_t svmlalt_u32(svuint32_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_u64)))
-svuint64_t svmlalt_u64(svuint64_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_u16)))
-svuint16_t svmlalt_u16(svuint16_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_f32)))
-svfloat32_t svmlalt_lane_f32(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_s32)))
-svint32_t svmlalt_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_s64)))
-svint64_t svmlalt_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_u32)))
-svuint32_t svmlalt_lane_u32(svuint32_t, svuint16_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_u64)))
-svuint64_t svmlalt_lane_u64(svuint64_t, svuint32_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_u32)))
-svuint32_t svmls_lane_u32(svuint32_t, svuint32_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_u64)))
-svuint64_t svmls_lane_u64(svuint64_t, svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_u16)))
-svuint16_t svmls_lane_u16(svuint16_t, svuint16_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_s32)))
-svint32_t svmls_lane_s32(svint32_t, svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_s64)))
-svint64_t svmls_lane_s64(svint64_t, svint64_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_s16)))
-svint16_t svmls_lane_s16(svint16_t, svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_f32)))
-svfloat32_t svmlslb_n_f32(svfloat32_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_s32)))
-svint32_t svmlslb_n_s32(svint32_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_s64)))
-svint64_t svmlslb_n_s64(svint64_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_s16)))
-svint16_t svmlslb_n_s16(svint16_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_u32)))
-svuint32_t svmlslb_n_u32(svuint32_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_u64)))
-svuint64_t svmlslb_n_u64(svuint64_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_u16)))
-svuint16_t svmlslb_n_u16(svuint16_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_f32)))
-svfloat32_t svmlslb_f32(svfloat32_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_s32)))
-svint32_t svmlslb_s32(svint32_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_s64)))
-svint64_t svmlslb_s64(svint64_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_s16)))
-svint16_t svmlslb_s16(svint16_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_u32)))
-svuint32_t svmlslb_u32(svuint32_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_u64)))
-svuint64_t svmlslb_u64(svuint64_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_u16)))
-svuint16_t svmlslb_u16(svuint16_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_f32)))
-svfloat32_t svmlslb_lane_f32(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_s32)))
-svint32_t svmlslb_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_s64)))
-svint64_t svmlslb_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_u32)))
-svuint32_t svmlslb_lane_u32(svuint32_t, svuint16_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_u64)))
-svuint64_t svmlslb_lane_u64(svuint64_t, svuint32_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_f32)))
-svfloat32_t svmlslt_n_f32(svfloat32_t, svfloat16_t, float16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_s32)))
-svint32_t svmlslt_n_s32(svint32_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_s64)))
-svint64_t svmlslt_n_s64(svint64_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_s16)))
-svint16_t svmlslt_n_s16(svint16_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_u32)))
-svuint32_t svmlslt_n_u32(svuint32_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_u64)))
-svuint64_t svmlslt_n_u64(svuint64_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_u16)))
-svuint16_t svmlslt_n_u16(svuint16_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_f32)))
-svfloat32_t svmlslt_f32(svfloat32_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_s32)))
-svint32_t svmlslt_s32(svint32_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_s64)))
-svint64_t svmlslt_s64(svint64_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_s16)))
-svint16_t svmlslt_s16(svint16_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_u32)))
-svuint32_t svmlslt_u32(svuint32_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_u64)))
-svuint64_t svmlslt_u64(svuint64_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_u16)))
-svuint16_t svmlslt_u16(svuint16_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_f32)))
-svfloat32_t svmlslt_lane_f32(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_s32)))
-svint32_t svmlslt_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_s64)))
-svint64_t svmlslt_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_u32)))
-svuint32_t svmlslt_lane_u32(svuint32_t, svuint16_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_u64)))
-svuint64_t svmlslt_lane_u64(svuint64_t, svuint32_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_s32)))
-svint32_t svmovlb_s32(svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_s64)))
-svint64_t svmovlb_s64(svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_s16)))
-svint16_t svmovlb_s16(svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_u32)))
-svuint32_t svmovlb_u32(svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_u64)))
-svuint64_t svmovlb_u64(svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_u16)))
-svuint16_t svmovlb_u16(svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_s32)))
-svint32_t svmovlt_s32(svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_s64)))
-svint64_t svmovlt_s64(svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_s16)))
-svint16_t svmovlt_s16(svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_u32)))
-svuint32_t svmovlt_u32(svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_u64)))
-svuint64_t svmovlt_u64(svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_u16)))
-svuint16_t svmovlt_u16(svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_u32)))
-svuint32_t svmul_lane_u32(svuint32_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_u64)))
-svuint64_t svmul_lane_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_u16)))
-svuint16_t svmul_lane_u16(svuint16_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_s32)))
-svint32_t svmul_lane_s32(svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_s64)))
-svint64_t svmul_lane_s64(svint64_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_s16)))
-svint16_t svmul_lane_s16(svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_s32)))
-svint32_t svmullb_n_s32(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_s64)))
-svint64_t svmullb_n_s64(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_s16)))
-svint16_t svmullb_n_s16(svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_u32)))
-svuint32_t svmullb_n_u32(svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_u64)))
-svuint64_t svmullb_n_u64(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_u16)))
-svuint16_t svmullb_n_u16(svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_s32)))
-svint32_t svmullb_s32(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_s64)))
-svint64_t svmullb_s64(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_s16)))
-svint16_t svmullb_s16(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_u32)))
-svuint32_t svmullb_u32(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_u64)))
-svuint64_t svmullb_u64(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_u16)))
-svuint16_t svmullb_u16(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_s32)))
-svint32_t svmullb_lane_s32(svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_s64)))
-svint64_t svmullb_lane_s64(svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_u32)))
-svuint32_t svmullb_lane_u32(svuint16_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_u64)))
-svuint64_t svmullb_lane_u64(svuint32_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_s32)))
-svint32_t svmullt_n_s32(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_s64)))
-svint64_t svmullt_n_s64(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_s16)))
-svint16_t svmullt_n_s16(svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_u32)))
-svuint32_t svmullt_n_u32(svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_u64)))
-svuint64_t svmullt_n_u64(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_u16)))
-svuint16_t svmullt_n_u16(svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_s32)))
-svint32_t svmullt_s32(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_s64)))
-svint64_t svmullt_s64(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_s16)))
-svint16_t svmullt_s16(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_u32)))
-svuint32_t svmullt_u32(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_u64)))
-svuint64_t svmullt_u64(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_u16)))
-svuint16_t svmullt_u16(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_s32)))
-svint32_t svmullt_lane_s32(svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_s64)))
-svint64_t svmullt_lane_s64(svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_u32)))
-svuint32_t svmullt_lane_u32(svuint16_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_u64)))
-svuint64_t svmullt_lane_u64(svuint32_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u8)))
-svuint8_t svnbsl_n_u8(svuint8_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u32)))
-svuint32_t svnbsl_n_u32(svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u64)))
-svuint64_t svnbsl_n_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u16)))
-svuint16_t svnbsl_n_u16(svuint16_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s8)))
-svint8_t svnbsl_n_s8(svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s32)))
-svint32_t svnbsl_n_s32(svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s64)))
-svint64_t svnbsl_n_s64(svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s16)))
-svint16_t svnbsl_n_s16(svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u8)))
-svuint8_t svnbsl_u8(svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u32)))
-svuint32_t svnbsl_u32(svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u64)))
-svuint64_t svnbsl_u64(svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u16)))
-svuint16_t svnbsl_u16(svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s8)))
-svint8_t svnbsl_s8(svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s32)))
-svint32_t svnbsl_s32(svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s64)))
-svint64_t svnbsl_s64(svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s16)))
-svint16_t svnbsl_s16(svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_u8)))
-svbool_t svnmatch_u8(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_u16)))
-svbool_t svnmatch_u16(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_s8)))
-svbool_t svnmatch_s8(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_s16)))
-svbool_t svnmatch_s16(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmul_n_u8)))
-svuint8_t svpmul_n_u8(svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmul_u8)))
-svuint8_t svpmul_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_n_u64)))
-svuint64_t svpmullb_n_u64(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_n_u16)))
-svuint16_t svpmullb_n_u16(svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_u64)))
-svuint64_t svpmullb_u64(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_u16)))
-svuint16_t svpmullb_u16(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_n_u8)))
-svuint8_t svpmullb_pair_n_u8(svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_n_u32)))
-svuint32_t svpmullb_pair_n_u32(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_u8)))
-svuint8_t svpmullb_pair_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_u32)))
-svuint32_t svpmullb_pair_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_n_u64)))
-svuint64_t svpmullt_n_u64(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_n_u16)))
-svuint16_t svpmullt_n_u16(svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_u64)))
-svuint64_t svpmullt_u64(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_u16)))
-svuint16_t svpmullt_u16(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_n_u8)))
-svuint8_t svpmullt_pair_n_u8(svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_n_u32)))
-svuint32_t svpmullt_pair_n_u32(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_u8)))
-svuint8_t svpmullt_pair_u8(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_u32)))
-svuint32_t svpmullt_pair_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s8_m)))
-svint8_t svqabs_s8_m(svint8_t, svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s32_m)))
-svint32_t svqabs_s32_m(svint32_t, svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s64_m)))
-svint64_t svqabs_s64_m(svint64_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s16_m)))
-svint16_t svqabs_s16_m(svint16_t, svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s8_x)))
-svint8_t svqabs_s8_x(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s32_x)))
-svint32_t svqabs_s32_x(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s64_x)))
-svint64_t svqabs_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s16_x)))
-svint16_t svqabs_s16_x(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s8_z)))
-svint8_t svqabs_s8_z(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s32_z)))
-svint32_t svqabs_s32_z(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s64_z)))
-svint64_t svqabs_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s16_z)))
-svint16_t svqabs_s16_z(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8_m)))
-svint8_t svqadd_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32_m)))
-svint32_t svqadd_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64_m)))
-svint64_t svqadd_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16_m)))
-svint16_t svqadd_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8_x)))
-svint8_t svqadd_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32_x)))
-svint32_t svqadd_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64_x)))
-svint64_t svqadd_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16_x)))
-svint16_t svqadd_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8_z)))
-svint8_t svqadd_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32_z)))
-svint32_t svqadd_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64_z)))
-svint64_t svqadd_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16_z)))
-svint16_t svqadd_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8_m)))
-svuint8_t svqadd_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32_m)))
-svuint32_t svqadd_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64_m)))
-svuint64_t svqadd_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16_m)))
-svuint16_t svqadd_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8_x)))
-svuint8_t svqadd_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32_x)))
-svuint32_t svqadd_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64_x)))
-svuint64_t svqadd_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16_x)))
-svuint16_t svqadd_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8_z)))
-svuint8_t svqadd_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32_z)))
-svuint32_t svqadd_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64_z)))
-svuint64_t svqadd_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16_z)))
-svuint16_t svqadd_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8_m)))
-svint8_t svqadd_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32_m)))
-svint32_t svqadd_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64_m)))
-svint64_t svqadd_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16_m)))
-svint16_t svqadd_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8_x)))
-svint8_t svqadd_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32_x)))
-svint32_t svqadd_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64_x)))
-svint64_t svqadd_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16_x)))
-svint16_t svqadd_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8_z)))
-svint8_t svqadd_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32_z)))
-svint32_t svqadd_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64_z)))
-svint64_t svqadd_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16_z)))
-svint16_t svqadd_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8_m)))
-svuint8_t svqadd_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32_m)))
-svuint32_t svqadd_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64_m)))
-svuint64_t svqadd_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16_m)))
-svuint16_t svqadd_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8_x)))
-svuint8_t svqadd_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32_x)))
-svuint32_t svqadd_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64_x)))
-svuint64_t svqadd_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16_x)))
-svuint16_t svqadd_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8_z)))
-svuint8_t svqadd_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32_z)))
-svuint32_t svqadd_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64_z)))
-svuint64_t svqadd_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16_z)))
-svuint16_t svqadd_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s8)))
-svint8_t svqcadd_s8(svint8_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s32)))
-svint32_t svqcadd_s32(svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s64)))
-svint64_t svqcadd_s64(svint64_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s16)))
-svint16_t svqcadd_s16(svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_n_s32)))
-svint32_t svqdmlalb_n_s32(svint32_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_n_s64)))
-svint64_t svqdmlalb_n_s64(svint64_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_n_s16)))
-svint16_t svqdmlalb_n_s16(svint16_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_s32)))
-svint32_t svqdmlalb_s32(svint32_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_s64)))
-svint64_t svqdmlalb_s64(svint64_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_s16)))
-svint16_t svqdmlalb_s16(svint16_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_lane_s32)))
-svint32_t svqdmlalb_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_lane_s64)))
-svint64_t svqdmlalb_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_n_s32)))
-svint32_t svqdmlalbt_n_s32(svint32_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_n_s64)))
-svint64_t svqdmlalbt_n_s64(svint64_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_n_s16)))
-svint16_t svqdmlalbt_n_s16(svint16_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_s32)))
-svint32_t svqdmlalbt_s32(svint32_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_s64)))
-svint64_t svqdmlalbt_s64(svint64_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_s16)))
-svint16_t svqdmlalbt_s16(svint16_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_n_s32)))
-svint32_t svqdmlalt_n_s32(svint32_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_n_s64)))
-svint64_t svqdmlalt_n_s64(svint64_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_n_s16)))
-svint16_t svqdmlalt_n_s16(svint16_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_s32)))
-svint32_t svqdmlalt_s32(svint32_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_s64)))
-svint64_t svqdmlalt_s64(svint64_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_s16)))
-svint16_t svqdmlalt_s16(svint16_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_lane_s32)))
-svint32_t svqdmlalt_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_lane_s64)))
-svint64_t svqdmlalt_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_n_s32)))
-svint32_t svqdmlslb_n_s32(svint32_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_n_s64)))
-svint64_t svqdmlslb_n_s64(svint64_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_n_s16)))
-svint16_t svqdmlslb_n_s16(svint16_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_s32)))
-svint32_t svqdmlslb_s32(svint32_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_s64)))
-svint64_t svqdmlslb_s64(svint64_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_s16)))
-svint16_t svqdmlslb_s16(svint16_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_lane_s32)))
-svint32_t svqdmlslb_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_lane_s64)))
-svint64_t svqdmlslb_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_n_s32)))
-svint32_t svqdmlslbt_n_s32(svint32_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_n_s64)))
-svint64_t svqdmlslbt_n_s64(svint64_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_n_s16)))
-svint16_t svqdmlslbt_n_s16(svint16_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_s32)))
-svint32_t svqdmlslbt_s32(svint32_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_s64)))
-svint64_t svqdmlslbt_s64(svint64_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_s16)))
-svint16_t svqdmlslbt_s16(svint16_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_n_s32)))
-svint32_t svqdmlslt_n_s32(svint32_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_n_s64)))
-svint64_t svqdmlslt_n_s64(svint64_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_n_s16)))
-svint16_t svqdmlslt_n_s16(svint16_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_s32)))
-svint32_t svqdmlslt_s32(svint32_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_s64)))
-svint64_t svqdmlslt_s64(svint64_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_s16)))
-svint16_t svqdmlslt_s16(svint16_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_lane_s32)))
-svint32_t svqdmlslt_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_lane_s64)))
-svint64_t svqdmlslt_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s8)))
-svint8_t svqdmulh_n_s8(svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s32)))
-svint32_t svqdmulh_n_s32(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s64)))
-svint64_t svqdmulh_n_s64(svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s16)))
-svint16_t svqdmulh_n_s16(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s8)))
-svint8_t svqdmulh_s8(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s32)))
-svint32_t svqdmulh_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s64)))
-svint64_t svqdmulh_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s16)))
-svint16_t svqdmulh_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_lane_s32)))
-svint32_t svqdmulh_lane_s32(svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_lane_s64)))
-svint64_t svqdmulh_lane_s64(svint64_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_lane_s16)))
-svint16_t svqdmulh_lane_s16(svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_n_s32)))
-svint32_t svqdmullb_n_s32(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_n_s64)))
-svint64_t svqdmullb_n_s64(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_n_s16)))
-svint16_t svqdmullb_n_s16(svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_s32)))
-svint32_t svqdmullb_s32(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_s64)))
-svint64_t svqdmullb_s64(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_s16)))
-svint16_t svqdmullb_s16(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_lane_s32)))
-svint32_t svqdmullb_lane_s32(svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_lane_s64)))
-svint64_t svqdmullb_lane_s64(svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_n_s32)))
-svint32_t svqdmullt_n_s32(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_n_s64)))
-svint64_t svqdmullt_n_s64(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_n_s16)))
-svint16_t svqdmullt_n_s16(svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_s32)))
-svint32_t svqdmullt_s32(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_s64)))
-svint64_t svqdmullt_s64(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_s16)))
-svint16_t svqdmullt_s16(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_lane_s32)))
-svint32_t svqdmullt_lane_s32(svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_lane_s64)))
-svint64_t svqdmullt_lane_s64(svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s8_m)))
-svint8_t svqneg_s8_m(svint8_t, svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s32_m)))
-svint32_t svqneg_s32_m(svint32_t, svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s64_m)))
-svint64_t svqneg_s64_m(svint64_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s16_m)))
-svint16_t svqneg_s16_m(svint16_t, svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s8_x)))
-svint8_t svqneg_s8_x(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s32_x)))
-svint32_t svqneg_s32_x(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s64_x)))
-svint64_t svqneg_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s16_x)))
-svint16_t svqneg_s16_x(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s8_z)))
-svint8_t svqneg_s8_z(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s32_z)))
-svint32_t svqneg_s32_z(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s64_z)))
-svint64_t svqneg_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s16_z)))
-svint16_t svqneg_s16_z(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s8)))
-svint8_t svqrdcmlah_s8(svint8_t, svint8_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s32)))
-svint32_t svqrdcmlah_s32(svint32_t, svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s64)))
-svint64_t svqrdcmlah_s64(svint64_t, svint64_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s16)))
-svint16_t svqrdcmlah_s16(svint16_t, svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_lane_s32)))
-svint32_t svqrdcmlah_lane_s32(svint32_t, svint32_t, svint32_t, uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_lane_s16)))
-svint16_t svqrdcmlah_lane_s16(svint16_t, svint16_t, svint16_t, uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s8)))
-svint8_t svqrdmlah_n_s8(svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s32)))
-svint32_t svqrdmlah_n_s32(svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s64)))
-svint64_t svqrdmlah_n_s64(svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s16)))
-svint16_t svqrdmlah_n_s16(svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s8)))
-svint8_t svqrdmlah_s8(svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s32)))
-svint32_t svqrdmlah_s32(svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s64)))
-svint64_t svqrdmlah_s64(svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s16)))
-svint16_t svqrdmlah_s16(svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_lane_s32)))
-svint32_t svqrdmlah_lane_s32(svint32_t, svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_lane_s64)))
-svint64_t svqrdmlah_lane_s64(svint64_t, svint64_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_lane_s16)))
-svint16_t svqrdmlah_lane_s16(svint16_t, svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s8)))
-svint8_t svqrdmlsh_n_s8(svint8_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s32)))
-svint32_t svqrdmlsh_n_s32(svint32_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s64)))
-svint64_t svqrdmlsh_n_s64(svint64_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s16)))
-svint16_t svqrdmlsh_n_s16(svint16_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s8)))
-svint8_t svqrdmlsh_s8(svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s32)))
-svint32_t svqrdmlsh_s32(svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s64)))
-svint64_t svqrdmlsh_s64(svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s16)))
-svint16_t svqrdmlsh_s16(svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_lane_s32)))
-svint32_t svqrdmlsh_lane_s32(svint32_t, svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_lane_s64)))
-svint64_t svqrdmlsh_lane_s64(svint64_t, svint64_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_lane_s16)))
-svint16_t svqrdmlsh_lane_s16(svint16_t, svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s8)))
-svint8_t svqrdmulh_n_s8(svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s32)))
-svint32_t svqrdmulh_n_s32(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s64)))
-svint64_t svqrdmulh_n_s64(svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s16)))
-svint16_t svqrdmulh_n_s16(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s8)))
-svint8_t svqrdmulh_s8(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s32)))
-svint32_t svqrdmulh_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s64)))
-svint64_t svqrdmulh_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s16)))
-svint16_t svqrdmulh_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_lane_s32)))
-svint32_t svqrdmulh_lane_s32(svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_lane_s64)))
-svint64_t svqrdmulh_lane_s64(svint64_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_lane_s16)))
-svint16_t svqrdmulh_lane_s16(svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s8_m)))
-svint8_t svqrshl_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s32_m)))
-svint32_t svqrshl_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s64_m)))
-svint64_t svqrshl_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s16_m)))
-svint16_t svqrshl_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s8_x)))
-svint8_t svqrshl_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s32_x)))
-svint32_t svqrshl_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s64_x)))
-svint64_t svqrshl_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s16_x)))
-svint16_t svqrshl_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s8_z)))
-svint8_t svqrshl_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s32_z)))
-svint32_t svqrshl_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s64_z)))
-svint64_t svqrshl_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s16_z)))
-svint16_t svqrshl_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u8_m)))
-svuint8_t svqrshl_n_u8_m(svbool_t, svuint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u32_m)))
-svuint32_t svqrshl_n_u32_m(svbool_t, svuint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u64_m)))
-svuint64_t svqrshl_n_u64_m(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u16_m)))
-svuint16_t svqrshl_n_u16_m(svbool_t, svuint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u8_x)))
-svuint8_t svqrshl_n_u8_x(svbool_t, svuint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u32_x)))
-svuint32_t svqrshl_n_u32_x(svbool_t, svuint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u64_x)))
-svuint64_t svqrshl_n_u64_x(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u16_x)))
-svuint16_t svqrshl_n_u16_x(svbool_t, svuint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u8_z)))
-svuint8_t svqrshl_n_u8_z(svbool_t, svuint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u32_z)))
-svuint32_t svqrshl_n_u32_z(svbool_t, svuint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u64_z)))
-svuint64_t svqrshl_n_u64_z(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u16_z)))
-svuint16_t svqrshl_n_u16_z(svbool_t, svuint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s8_m)))
-svint8_t svqrshl_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s32_m)))
-svint32_t svqrshl_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s64_m)))
-svint64_t svqrshl_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s16_m)))
-svint16_t svqrshl_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s8_x)))
-svint8_t svqrshl_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s32_x)))
-svint32_t svqrshl_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s64_x)))
-svint64_t svqrshl_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s16_x)))
-svint16_t svqrshl_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s8_z)))
-svint8_t svqrshl_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s32_z)))
-svint32_t svqrshl_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s64_z)))
-svint64_t svqrshl_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s16_z)))
-svint16_t svqrshl_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u8_m)))
-svuint8_t svqrshl_u8_m(svbool_t, svuint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u32_m)))
-svuint32_t svqrshl_u32_m(svbool_t, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u64_m)))
-svuint64_t svqrshl_u64_m(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u16_m)))
-svuint16_t svqrshl_u16_m(svbool_t, svuint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u8_x)))
-svuint8_t svqrshl_u8_x(svbool_t, svuint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u32_x)))
-svuint32_t svqrshl_u32_x(svbool_t, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u64_x)))
-svuint64_t svqrshl_u64_x(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u16_x)))
-svuint16_t svqrshl_u16_x(svbool_t, svuint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u8_z)))
-svuint8_t svqrshl_u8_z(svbool_t, svuint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u32_z)))
-svuint32_t svqrshl_u32_z(svbool_t, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u64_z)))
-svuint64_t svqrshl_u64_z(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u16_z)))
-svuint16_t svqrshl_u16_z(svbool_t, svuint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_s32)))
-svint16_t svqrshrnb_n_s32(svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_s64)))
-svint32_t svqrshrnb_n_s64(svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_s16)))
-svint8_t svqrshrnb_n_s16(svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_u32)))
-svuint16_t svqrshrnb_n_u32(svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_u64)))
-svuint32_t svqrshrnb_n_u64(svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_u16)))
-svuint8_t svqrshrnb_n_u16(svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_s32)))
-svint16_t svqrshrnt_n_s32(svint16_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_s64)))
-svint32_t svqrshrnt_n_s64(svint32_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_s16)))
-svint8_t svqrshrnt_n_s16(svint8_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_u32)))
-svuint16_t svqrshrnt_n_u32(svuint16_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_u64)))
-svuint32_t svqrshrnt_n_u64(svuint32_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_u16)))
-svuint8_t svqrshrnt_n_u16(svuint8_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunb_n_s32)))
-svuint16_t svqrshrunb_n_s32(svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunb_n_s64)))
-svuint32_t svqrshrunb_n_s64(svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunb_n_s16)))
-svuint8_t svqrshrunb_n_s16(svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunt_n_s32)))
-svuint16_t svqrshrunt_n_s32(svuint16_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunt_n_s64)))
-svuint32_t svqrshrunt_n_s64(svuint32_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunt_n_s16)))
-svuint8_t svqrshrunt_n_s16(svuint8_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s8_m)))
-svint8_t svqshl_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s32_m)))
-svint32_t svqshl_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s64_m)))
-svint64_t svqshl_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s16_m)))
-svint16_t svqshl_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s8_x)))
-svint8_t svqshl_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s32_x)))
-svint32_t svqshl_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s64_x)))
-svint64_t svqshl_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s16_x)))
-svint16_t svqshl_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s8_z)))
-svint8_t svqshl_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s32_z)))
-svint32_t svqshl_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s64_z)))
-svint64_t svqshl_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s16_z)))
-svint16_t svqshl_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u8_m)))
-svuint8_t svqshl_n_u8_m(svbool_t, svuint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u32_m)))
-svuint32_t svqshl_n_u32_m(svbool_t, svuint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u64_m)))
-svuint64_t svqshl_n_u64_m(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u16_m)))
-svuint16_t svqshl_n_u16_m(svbool_t, svuint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u8_x)))
-svuint8_t svqshl_n_u8_x(svbool_t, svuint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u32_x)))
-svuint32_t svqshl_n_u32_x(svbool_t, svuint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u64_x)))
-svuint64_t svqshl_n_u64_x(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u16_x)))
-svuint16_t svqshl_n_u16_x(svbool_t, svuint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u8_z)))
-svuint8_t svqshl_n_u8_z(svbool_t, svuint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u32_z)))
-svuint32_t svqshl_n_u32_z(svbool_t, svuint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u64_z)))
-svuint64_t svqshl_n_u64_z(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u16_z)))
-svuint16_t svqshl_n_u16_z(svbool_t, svuint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s8_m)))
-svint8_t svqshl_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s32_m)))
-svint32_t svqshl_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s64_m)))
-svint64_t svqshl_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s16_m)))
-svint16_t svqshl_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s8_x)))
-svint8_t svqshl_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s32_x)))
-svint32_t svqshl_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s64_x)))
-svint64_t svqshl_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s16_x)))
-svint16_t svqshl_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s8_z)))
-svint8_t svqshl_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s32_z)))
-svint32_t svqshl_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s64_z)))
-svint64_t svqshl_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s16_z)))
-svint16_t svqshl_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u8_m)))
-svuint8_t svqshl_u8_m(svbool_t, svuint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u32_m)))
-svuint32_t svqshl_u32_m(svbool_t, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u64_m)))
-svuint64_t svqshl_u64_m(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u16_m)))
-svuint16_t svqshl_u16_m(svbool_t, svuint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u8_x)))
-svuint8_t svqshl_u8_x(svbool_t, svuint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u32_x)))
-svuint32_t svqshl_u32_x(svbool_t, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u64_x)))
-svuint64_t svqshl_u64_x(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u16_x)))
-svuint16_t svqshl_u16_x(svbool_t, svuint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u8_z)))
-svuint8_t svqshl_u8_z(svbool_t, svuint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u32_z)))
-svuint32_t svqshl_u32_z(svbool_t, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u64_z)))
-svuint64_t svqshl_u64_z(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u16_z)))
-svuint16_t svqshl_u16_z(svbool_t, svuint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s8_m)))
-svuint8_t svqshlu_n_s8_m(svbool_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s32_m)))
-svuint32_t svqshlu_n_s32_m(svbool_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s64_m)))
-svuint64_t svqshlu_n_s64_m(svbool_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s16_m)))
-svuint16_t svqshlu_n_s16_m(svbool_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s8_x)))
-svuint8_t svqshlu_n_s8_x(svbool_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s32_x)))
-svuint32_t svqshlu_n_s32_x(svbool_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s64_x)))
-svuint64_t svqshlu_n_s64_x(svbool_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s16_x)))
-svuint16_t svqshlu_n_s16_x(svbool_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s8_z)))
-svuint8_t svqshlu_n_s8_z(svbool_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s32_z)))
-svuint32_t svqshlu_n_s32_z(svbool_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s64_z)))
-svuint64_t svqshlu_n_s64_z(svbool_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s16_z)))
-svuint16_t svqshlu_n_s16_z(svbool_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_s32)))
-svint16_t svqshrnb_n_s32(svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_s64)))
-svint32_t svqshrnb_n_s64(svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_s16)))
-svint8_t svqshrnb_n_s16(svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_u32)))
-svuint16_t svqshrnb_n_u32(svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_u64)))
-svuint32_t svqshrnb_n_u64(svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_u16)))
-svuint8_t svqshrnb_n_u16(svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_s32)))
-svint16_t svqshrnt_n_s32(svint16_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_s64)))
-svint32_t svqshrnt_n_s64(svint32_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_s16)))
-svint8_t svqshrnt_n_s16(svint8_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_u32)))
-svuint16_t svqshrnt_n_u32(svuint16_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_u64)))
-svuint32_t svqshrnt_n_u64(svuint32_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_u16)))
-svuint8_t svqshrnt_n_u16(svuint8_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunb_n_s32)))
-svuint16_t svqshrunb_n_s32(svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunb_n_s64)))
-svuint32_t svqshrunb_n_s64(svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunb_n_s16)))
-svuint8_t svqshrunb_n_s16(svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunt_n_s32)))
-svuint16_t svqshrunt_n_s32(svuint16_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunt_n_s64)))
-svuint32_t svqshrunt_n_s64(svuint32_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunt_n_s16)))
-svuint8_t svqshrunt_n_s16(svuint8_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8_m)))
-svint8_t svqsub_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32_m)))
-svint32_t svqsub_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64_m)))
-svint64_t svqsub_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16_m)))
-svint16_t svqsub_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8_x)))
-svint8_t svqsub_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32_x)))
-svint32_t svqsub_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64_x)))
-svint64_t svqsub_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16_x)))
-svint16_t svqsub_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8_z)))
-svint8_t svqsub_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32_z)))
-svint32_t svqsub_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64_z)))
-svint64_t svqsub_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16_z)))
-svint16_t svqsub_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8_m)))
-svuint8_t svqsub_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32_m)))
-svuint32_t svqsub_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64_m)))
-svuint64_t svqsub_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16_m)))
-svuint16_t svqsub_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8_x)))
-svuint8_t svqsub_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32_x)))
-svuint32_t svqsub_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64_x)))
-svuint64_t svqsub_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16_x)))
-svuint16_t svqsub_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8_z)))
-svuint8_t svqsub_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32_z)))
-svuint32_t svqsub_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64_z)))
-svuint64_t svqsub_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16_z)))
-svuint16_t svqsub_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8_m)))
-svint8_t svqsub_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32_m)))
-svint32_t svqsub_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64_m)))
-svint64_t svqsub_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16_m)))
-svint16_t svqsub_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8_x)))
-svint8_t svqsub_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32_x)))
-svint32_t svqsub_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64_x)))
-svint64_t svqsub_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16_x)))
-svint16_t svqsub_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8_z)))
-svint8_t svqsub_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32_z)))
-svint32_t svqsub_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64_z)))
-svint64_t svqsub_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16_z)))
-svint16_t svqsub_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8_m)))
-svuint8_t svqsub_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32_m)))
-svuint32_t svqsub_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64_m)))
-svuint64_t svqsub_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16_m)))
-svuint16_t svqsub_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8_x)))
-svuint8_t svqsub_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32_x)))
-svuint32_t svqsub_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64_x)))
-svuint64_t svqsub_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16_x)))
-svuint16_t svqsub_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8_z)))
-svuint8_t svqsub_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32_z)))
-svuint32_t svqsub_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64_z)))
-svuint64_t svqsub_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16_z)))
-svuint16_t svqsub_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s8_m)))
-svint8_t svqsubr_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s32_m)))
-svint32_t svqsubr_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s64_m)))
-svint64_t svqsubr_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s16_m)))
-svint16_t svqsubr_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s8_x)))
-svint8_t svqsubr_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s32_x)))
-svint32_t svqsubr_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s64_x)))
-svint64_t svqsubr_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s16_x)))
-svint16_t svqsubr_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s8_z)))
-svint8_t svqsubr_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s32_z)))
-svint32_t svqsubr_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s64_z)))
-svint64_t svqsubr_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s16_z)))
-svint16_t svqsubr_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u8_m)))
-svuint8_t svqsubr_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u32_m)))
-svuint32_t svqsubr_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u64_m)))
-svuint64_t svqsubr_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u16_m)))
-svuint16_t svqsubr_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u8_x)))
-svuint8_t svqsubr_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u32_x)))
-svuint32_t svqsubr_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u64_x)))
-svuint64_t svqsubr_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u16_x)))
-svuint16_t svqsubr_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u8_z)))
-svuint8_t svqsubr_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u32_z)))
-svuint32_t svqsubr_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u64_z)))
-svuint64_t svqsubr_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u16_z)))
-svuint16_t svqsubr_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s8_m)))
-svint8_t svqsubr_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s32_m)))
-svint32_t svqsubr_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s64_m)))
-svint64_t svqsubr_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s16_m)))
-svint16_t svqsubr_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s8_x)))
-svint8_t svqsubr_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s32_x)))
-svint32_t svqsubr_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s64_x)))
-svint64_t svqsubr_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s16_x)))
-svint16_t svqsubr_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s8_z)))
-svint8_t svqsubr_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s32_z)))
-svint32_t svqsubr_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s64_z)))
-svint64_t svqsubr_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s16_z)))
-svint16_t svqsubr_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u8_m)))
-svuint8_t svqsubr_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u32_m)))
-svuint32_t svqsubr_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u64_m)))
-svuint64_t svqsubr_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u16_m)))
-svuint16_t svqsubr_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u8_x)))
-svuint8_t svqsubr_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u32_x)))
-svuint32_t svqsubr_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u64_x)))
-svuint64_t svqsubr_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u16_x)))
-svuint16_t svqsubr_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u8_z)))
-svuint8_t svqsubr_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u32_z)))
-svuint32_t svqsubr_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u64_z)))
-svuint64_t svqsubr_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u16_z)))
-svuint16_t svqsubr_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_s32)))
-svint16_t svqxtnb_s32(svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_s64)))
-svint32_t svqxtnb_s64(svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_s16)))
-svint8_t svqxtnb_s16(svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_u32)))
-svuint16_t svqxtnb_u32(svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_u64)))
-svuint32_t svqxtnb_u64(svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_u16)))
-svuint8_t svqxtnb_u16(svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_s32)))
-svint16_t svqxtnt_s32(svint16_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_s64)))
-svint32_t svqxtnt_s64(svint32_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_s16)))
-svint8_t svqxtnt_s16(svint8_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_u32)))
-svuint16_t svqxtnt_u32(svuint16_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_u64)))
-svuint32_t svqxtnt_u64(svuint32_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_u16)))
-svuint8_t svqxtnt_u16(svuint8_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunb_s32)))
-svuint16_t svqxtunb_s32(svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunb_s64)))
-svuint32_t svqxtunb_s64(svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunb_s16)))
-svuint8_t svqxtunb_s16(svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunt_s32)))
-svuint16_t svqxtunt_s32(svuint16_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunt_s64)))
-svuint32_t svqxtunt_s64(svuint32_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunt_s16)))
-svuint8_t svqxtunt_s16(svuint8_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_u32)))
-svuint16_t svraddhnb_n_u32(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_u64)))
-svuint32_t svraddhnb_n_u64(svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_u16)))
-svuint8_t svraddhnb_n_u16(svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_s32)))
-svint16_t svraddhnb_n_s32(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_s64)))
-svint32_t svraddhnb_n_s64(svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_s16)))
-svint8_t svraddhnb_n_s16(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_u32)))
-svuint16_t svraddhnb_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_u64)))
-svuint32_t svraddhnb_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_u16)))
-svuint8_t svraddhnb_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_s32)))
-svint16_t svraddhnb_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_s64)))
-svint32_t svraddhnb_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_s16)))
-svint8_t svraddhnb_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_u32)))
-svuint16_t svraddhnt_n_u32(svuint16_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_u64)))
-svuint32_t svraddhnt_n_u64(svuint32_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_u16)))
-svuint8_t svraddhnt_n_u16(svuint8_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_s32)))
-svint16_t svraddhnt_n_s32(svint16_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_s64)))
-svint32_t svraddhnt_n_s64(svint32_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_s16)))
-svint8_t svraddhnt_n_s16(svint8_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_u32)))
-svuint16_t svraddhnt_u32(svuint16_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_u64)))
-svuint32_t svraddhnt_u64(svuint32_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_u16)))
-svuint8_t svraddhnt_u16(svuint8_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_s32)))
-svint16_t svraddhnt_s32(svint16_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_s64)))
-svint32_t svraddhnt_s64(svint32_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_s16)))
-svint8_t svraddhnt_s16(svint8_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_u32_m)))
-svuint32_t svrecpe_u32_m(svuint32_t, svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_u32_x)))
-svuint32_t svrecpe_u32_x(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_u32_z)))
-svuint32_t svrecpe_u32_z(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s8_m)))
-svint8_t svrhadd_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s32_m)))
-svint32_t svrhadd_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s64_m)))
-svint64_t svrhadd_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s16_m)))
-svint16_t svrhadd_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s8_x)))
-svint8_t svrhadd_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s32_x)))
-svint32_t svrhadd_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s64_x)))
-svint64_t svrhadd_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s16_x)))
-svint16_t svrhadd_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s8_z)))
-svint8_t svrhadd_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s32_z)))
-svint32_t svrhadd_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s64_z)))
-svint64_t svrhadd_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s16_z)))
-svint16_t svrhadd_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u8_m)))
-svuint8_t svrhadd_n_u8_m(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u32_m)))
-svuint32_t svrhadd_n_u32_m(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u64_m)))
-svuint64_t svrhadd_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u16_m)))
-svuint16_t svrhadd_n_u16_m(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u8_x)))
-svuint8_t svrhadd_n_u8_x(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u32_x)))
-svuint32_t svrhadd_n_u32_x(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u64_x)))
-svuint64_t svrhadd_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u16_x)))
-svuint16_t svrhadd_n_u16_x(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u8_z)))
-svuint8_t svrhadd_n_u8_z(svbool_t, svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u32_z)))
-svuint32_t svrhadd_n_u32_z(svbool_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u64_z)))
-svuint64_t svrhadd_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u16_z)))
-svuint16_t svrhadd_n_u16_z(svbool_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s8_m)))
-svint8_t svrhadd_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s32_m)))
-svint32_t svrhadd_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s64_m)))
-svint64_t svrhadd_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s16_m)))
-svint16_t svrhadd_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s8_x)))
-svint8_t svrhadd_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s32_x)))
-svint32_t svrhadd_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s64_x)))
-svint64_t svrhadd_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s16_x)))
-svint16_t svrhadd_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s8_z)))
-svint8_t svrhadd_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s32_z)))
-svint32_t svrhadd_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s64_z)))
-svint64_t svrhadd_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s16_z)))
-svint16_t svrhadd_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u8_m)))
-svuint8_t svrhadd_u8_m(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u32_m)))
-svuint32_t svrhadd_u32_m(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u64_m)))
-svuint64_t svrhadd_u64_m(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u16_m)))
-svuint16_t svrhadd_u16_m(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u8_x)))
-svuint8_t svrhadd_u8_x(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u32_x)))
-svuint32_t svrhadd_u32_x(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u64_x)))
-svuint64_t svrhadd_u64_x(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u16_x)))
-svuint16_t svrhadd_u16_x(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u8_z)))
-svuint8_t svrhadd_u8_z(svbool_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u32_z)))
-svuint32_t svrhadd_u32_z(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u64_z)))
-svuint64_t svrhadd_u64_z(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u16_z)))
-svuint16_t svrhadd_u16_z(svbool_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s8_m)))
-svint8_t svrshl_n_s8_m(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s32_m)))
-svint32_t svrshl_n_s32_m(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s64_m)))
-svint64_t svrshl_n_s64_m(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s16_m)))
-svint16_t svrshl_n_s16_m(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s8_x)))
-svint8_t svrshl_n_s8_x(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s32_x)))
-svint32_t svrshl_n_s32_x(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s64_x)))
-svint64_t svrshl_n_s64_x(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s16_x)))
-svint16_t svrshl_n_s16_x(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s8_z)))
-svint8_t svrshl_n_s8_z(svbool_t, svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s32_z)))
-svint32_t svrshl_n_s32_z(svbool_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s64_z)))
-svint64_t svrshl_n_s64_z(svbool_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s16_z)))
-svint16_t svrshl_n_s16_z(svbool_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u8_m)))
-svuint8_t svrshl_n_u8_m(svbool_t, svuint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u32_m)))
-svuint32_t svrshl_n_u32_m(svbool_t, svuint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u64_m)))
-svuint64_t svrshl_n_u64_m(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u16_m)))
-svuint16_t svrshl_n_u16_m(svbool_t, svuint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u8_x)))
-svuint8_t svrshl_n_u8_x(svbool_t, svuint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u32_x)))
-svuint32_t svrshl_n_u32_x(svbool_t, svuint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u64_x)))
-svuint64_t svrshl_n_u64_x(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u16_x)))
-svuint16_t svrshl_n_u16_x(svbool_t, svuint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u8_z)))
-svuint8_t svrshl_n_u8_z(svbool_t, svuint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u32_z)))
-svuint32_t svrshl_n_u32_z(svbool_t, svuint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u64_z)))
-svuint64_t svrshl_n_u64_z(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u16_z)))
-svuint16_t svrshl_n_u16_z(svbool_t, svuint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_m)))
-svint8_t svrshl_s8_m(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_m)))
-svint32_t svrshl_s32_m(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_m)))
-svint64_t svrshl_s64_m(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_m)))
-svint16_t svrshl_s16_m(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_x)))
-svint8_t svrshl_s8_x(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_x)))
-svint32_t svrshl_s32_x(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_x)))
-svint64_t svrshl_s64_x(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_x)))
-svint16_t svrshl_s16_x(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_z)))
-svint8_t svrshl_s8_z(svbool_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_z)))
-svint32_t svrshl_s32_z(svbool_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_z)))
-svint64_t svrshl_s64_z(svbool_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_z)))
-svint16_t svrshl_s16_z(svbool_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_m)))
-svuint8_t svrshl_u8_m(svbool_t, svuint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_m)))
-svuint32_t svrshl_u32_m(svbool_t, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_m)))
-svuint64_t svrshl_u64_m(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_m)))
-svuint16_t svrshl_u16_m(svbool_t, svuint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_x)))
-svuint8_t svrshl_u8_x(svbool_t, svuint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_x)))
-svuint32_t svrshl_u32_x(svbool_t, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_x)))
-svuint64_t svrshl_u64_x(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_x)))
-svuint16_t svrshl_u16_x(svbool_t, svuint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_z)))
-svuint8_t svrshl_u8_z(svbool_t, svuint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_z)))
-svuint32_t svrshl_u32_z(svbool_t, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_z)))
-svuint64_t svrshl_u64_z(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_z)))
-svuint16_t svrshl_u16_z(svbool_t, svuint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s8_m)))
-svint8_t svrshr_n_s8_m(svbool_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s32_m)))
-svint32_t svrshr_n_s32_m(svbool_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s64_m)))
-svint64_t svrshr_n_s64_m(svbool_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s16_m)))
-svint16_t svrshr_n_s16_m(svbool_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u8_m)))
-svuint8_t svrshr_n_u8_m(svbool_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u32_m)))
-svuint32_t svrshr_n_u32_m(svbool_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u64_m)))
-svuint64_t svrshr_n_u64_m(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u16_m)))
-svuint16_t svrshr_n_u16_m(svbool_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s8_x)))
-svint8_t svrshr_n_s8_x(svbool_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s32_x)))
-svint32_t svrshr_n_s32_x(svbool_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s64_x)))
-svint64_t svrshr_n_s64_x(svbool_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s16_x)))
-svint16_t svrshr_n_s16_x(svbool_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u8_x)))
-svuint8_t svrshr_n_u8_x(svbool_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u32_x)))
-svuint32_t svrshr_n_u32_x(svbool_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u64_x)))
-svuint64_t svrshr_n_u64_x(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u16_x)))
-svuint16_t svrshr_n_u16_x(svbool_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s8_z)))
-svint8_t svrshr_n_s8_z(svbool_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s32_z)))
-svint32_t svrshr_n_s32_z(svbool_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s64_z)))
-svint64_t svrshr_n_s64_z(svbool_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s16_z)))
-svint16_t svrshr_n_s16_z(svbool_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u8_z)))
-svuint8_t svrshr_n_u8_z(svbool_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u32_z)))
-svuint32_t svrshr_n_u32_z(svbool_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u64_z)))
-svuint64_t svrshr_n_u64_z(svbool_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u16_z)))
-svuint16_t svrshr_n_u16_z(svbool_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_u32)))
-svuint16_t svrshrnb_n_u32(svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_u64)))
-svuint32_t svrshrnb_n_u64(svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_u16)))
-svuint8_t svrshrnb_n_u16(svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_s32)))
-svint16_t svrshrnb_n_s32(svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_s64)))
-svint32_t svrshrnb_n_s64(svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_s16)))
-svint8_t svrshrnb_n_s16(svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_u32)))
-svuint16_t svrshrnt_n_u32(svuint16_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_u64)))
-svuint32_t svrshrnt_n_u64(svuint32_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_u16)))
-svuint8_t svrshrnt_n_u16(svuint8_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_s32)))
-svint16_t svrshrnt_n_s32(svint16_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_s64)))
-svint32_t svrshrnt_n_s64(svint32_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_s16)))
-svint8_t svrshrnt_n_s16(svint8_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_u32_m)))
-svuint32_t svrsqrte_u32_m(svuint32_t, svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_u32_x)))
-svuint32_t svrsqrte_u32_x(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_u32_z)))
-svuint32_t svrsqrte_u32_z(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s8)))
-svint8_t svrsra_n_s8(svint8_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s32)))
-svint32_t svrsra_n_s32(svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s64)))
-svint64_t svrsra_n_s64(svint64_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s16)))
-svint16_t svrsra_n_s16(svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u8)))
-svuint8_t svrsra_n_u8(svuint8_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u32)))
-svuint32_t svrsra_n_u32(svuint32_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u64)))
-svuint64_t svrsra_n_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u16)))
-svuint16_t svrsra_n_u16(svuint16_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_u32)))
-svuint16_t svrsubhnb_n_u32(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_u64)))
-svuint32_t svrsubhnb_n_u64(svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_u16)))
-svuint8_t svrsubhnb_n_u16(svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_s32)))
-svint16_t svrsubhnb_n_s32(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_s64)))
-svint32_t svrsubhnb_n_s64(svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_s16)))
-svint8_t svrsubhnb_n_s16(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_u32)))
-svuint16_t svrsubhnb_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_u64)))
-svuint32_t svrsubhnb_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_u16)))
-svuint8_t svrsubhnb_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_s32)))
-svint16_t svrsubhnb_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_s64)))
-svint32_t svrsubhnb_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_s16)))
-svint8_t svrsubhnb_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_u32)))
-svuint16_t svrsubhnt_n_u32(svuint16_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_u64)))
-svuint32_t svrsubhnt_n_u64(svuint32_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_u16)))
-svuint8_t svrsubhnt_n_u16(svuint8_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_s32)))
-svint16_t svrsubhnt_n_s32(svint16_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_s64)))
-svint32_t svrsubhnt_n_s64(svint32_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_s16)))
-svint8_t svrsubhnt_n_s16(svint8_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_u32)))
-svuint16_t svrsubhnt_u32(svuint16_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_u64)))
-svuint32_t svrsubhnt_u64(svuint32_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_u16)))
-svuint8_t svrsubhnt_u16(svuint8_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_s32)))
-svint16_t svrsubhnt_s32(svint16_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_s64)))
-svint32_t svrsubhnt_s64(svint32_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_s16)))
-svint8_t svrsubhnt_s16(svint8_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_n_u32)))
-svuint32_t svsbclb_n_u32(svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_n_u64)))
-svuint64_t svsbclb_n_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_u32)))
-svuint32_t svsbclb_u32(svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_u64)))
-svuint64_t svsbclb_u64(svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_n_u32)))
-svuint32_t svsbclt_n_u32(svuint32_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_n_u64)))
-svuint64_t svsbclt_n_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_u32)))
-svuint32_t svsbclt_u32(svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_u64)))
-svuint64_t svsbclt_u64(svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_s32)))
-svint32_t svshllb_n_s32(svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_s64)))
-svint64_t svshllb_n_s64(svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_s16)))
-svint16_t svshllb_n_s16(svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_u32)))
-svuint32_t svshllb_n_u32(svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_u64)))
-svuint64_t svshllb_n_u64(svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_u16)))
-svuint16_t svshllb_n_u16(svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_s32)))
-svint32_t svshllt_n_s32(svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_s64)))
-svint64_t svshllt_n_s64(svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_s16)))
-svint16_t svshllt_n_s16(svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_u32)))
-svuint32_t svshllt_n_u32(svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_u64)))
-svuint64_t svshllt_n_u64(svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_u16)))
-svuint16_t svshllt_n_u16(svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_u32)))
-svuint16_t svshrnb_n_u32(svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_u64)))
-svuint32_t svshrnb_n_u64(svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_u16)))
-svuint8_t svshrnb_n_u16(svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_s32)))
-svint16_t svshrnb_n_s32(svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_s64)))
-svint32_t svshrnb_n_s64(svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_s16)))
-svint8_t svshrnb_n_s16(svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_u32)))
-svuint16_t svshrnt_n_u32(svuint16_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_u64)))
-svuint32_t svshrnt_n_u64(svuint32_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_u16)))
-svuint8_t svshrnt_n_u16(svuint8_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_s32)))
-svint16_t svshrnt_n_s32(svint16_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_s64)))
-svint32_t svshrnt_n_s64(svint32_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_s16)))
-svint8_t svshrnt_n_s16(svint8_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u8)))
-svuint8_t svsli_n_u8(svuint8_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u32)))
-svuint32_t svsli_n_u32(svuint32_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u64)))
-svuint64_t svsli_n_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u16)))
-svuint16_t svsli_n_u16(svuint16_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s8)))
-svint8_t svsli_n_s8(svint8_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s32)))
-svint32_t svsli_n_s32(svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s64)))
-svint64_t svsli_n_s64(svint64_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s16)))
-svint16_t svsli_n_s16(svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u8_m)))
-svuint8_t svsqadd_n_u8_m(svbool_t, svuint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u32_m)))
-svuint32_t svsqadd_n_u32_m(svbool_t, svuint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u64_m)))
-svuint64_t svsqadd_n_u64_m(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u16_m)))
-svuint16_t svsqadd_n_u16_m(svbool_t, svuint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u8_x)))
-svuint8_t svsqadd_n_u8_x(svbool_t, svuint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u32_x)))
-svuint32_t svsqadd_n_u32_x(svbool_t, svuint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u64_x)))
-svuint64_t svsqadd_n_u64_x(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u16_x)))
-svuint16_t svsqadd_n_u16_x(svbool_t, svuint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u8_z)))
-svuint8_t svsqadd_n_u8_z(svbool_t, svuint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u32_z)))
-svuint32_t svsqadd_n_u32_z(svbool_t, svuint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u64_z)))
-svuint64_t svsqadd_n_u64_z(svbool_t, svuint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u16_z)))
-svuint16_t svsqadd_n_u16_z(svbool_t, svuint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u8_m)))
-svuint8_t svsqadd_u8_m(svbool_t, svuint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u32_m)))
-svuint32_t svsqadd_u32_m(svbool_t, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u64_m)))
-svuint64_t svsqadd_u64_m(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u16_m)))
-svuint16_t svsqadd_u16_m(svbool_t, svuint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u8_x)))
-svuint8_t svsqadd_u8_x(svbool_t, svuint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u32_x)))
-svuint32_t svsqadd_u32_x(svbool_t, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u64_x)))
-svuint64_t svsqadd_u64_x(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u16_x)))
-svuint16_t svsqadd_u16_x(svbool_t, svuint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u8_z)))
-svuint8_t svsqadd_u8_z(svbool_t, svuint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u32_z)))
-svuint32_t svsqadd_u32_z(svbool_t, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u64_z)))
-svuint64_t svsqadd_u64_z(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u16_z)))
-svuint16_t svsqadd_u16_z(svbool_t, svuint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s8)))
-svint8_t svsra_n_s8(svint8_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s32)))
-svint32_t svsra_n_s32(svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s64)))
-svint64_t svsra_n_s64(svint64_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s16)))
-svint16_t svsra_n_s16(svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u8)))
-svuint8_t svsra_n_u8(svuint8_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u32)))
-svuint32_t svsra_n_u32(svuint32_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u64)))
-svuint64_t svsra_n_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u16)))
-svuint16_t svsra_n_u16(svuint16_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u8)))
-svuint8_t svsri_n_u8(svuint8_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u32)))
-svuint32_t svsri_n_u32(svuint32_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u64)))
-svuint64_t svsri_n_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u16)))
-svuint16_t svsri_n_u16(svuint16_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s8)))
-svint8_t svsri_n_s8(svint8_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s32)))
-svint32_t svsri_n_s32(svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s64)))
-svint64_t svsri_n_s64(svint64_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s16)))
-svint16_t svsri_n_s16(svint16_t, svint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_index_u32)))
-void svstnt1_scatter_u32base_index_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_index_u64)))
-void svstnt1_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_index_f64)))
-void svstnt1_scatter_u64base_index_f64(svbool_t, svuint64_t, int64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_index_f32)))
-void svstnt1_scatter_u32base_index_f32(svbool_t, svuint32_t, int64_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_index_s32)))
-void svstnt1_scatter_u32base_index_s32(svbool_t, svuint32_t, int64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_index_s64)))
-void svstnt1_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_offset_u32)))
-void svstnt1_scatter_u32base_offset_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_offset_u64)))
-void svstnt1_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_offset_f64)))
-void svstnt1_scatter_u64base_offset_f64(svbool_t, svuint64_t, int64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_offset_f32)))
-void svstnt1_scatter_u32base_offset_f32(svbool_t, svuint32_t, int64_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_offset_s32)))
-void svstnt1_scatter_u32base_offset_s32(svbool_t, svuint32_t, int64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_offset_s64)))
-void svstnt1_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_u32)))
-void svstnt1_scatter_u32base_u32(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_u64)))
-void svstnt1_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_f64)))
-void svstnt1_scatter_u64base_f64(svbool_t, svuint64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_f32)))
-void svstnt1_scatter_u32base_f32(svbool_t, svuint32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_s32)))
-void svstnt1_scatter_u32base_s32(svbool_t, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_s64)))
-void svstnt1_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64index_u64)))
-void svstnt1_scatter_s64index_u64(svbool_t, uint64_t *, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64index_f64)))
-void svstnt1_scatter_s64index_f64(svbool_t, float64_t *, svint64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64index_s64)))
-void svstnt1_scatter_s64index_s64(svbool_t, int64_t *, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64index_u64)))
-void svstnt1_scatter_u64index_u64(svbool_t, uint64_t *, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64index_f64)))
-void svstnt1_scatter_u64index_f64(svbool_t, float64_t *, svuint64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64index_s64)))
-void svstnt1_scatter_u64index_s64(svbool_t, int64_t *, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32offset_u32)))
-void svstnt1_scatter_u32offset_u32(svbool_t, uint32_t *, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32offset_f32)))
-void svstnt1_scatter_u32offset_f32(svbool_t, float32_t *, svuint32_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32offset_s32)))
-void svstnt1_scatter_u32offset_s32(svbool_t, int32_t *, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64offset_u64)))
-void svstnt1_scatter_s64offset_u64(svbool_t, uint64_t *, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64offset_f64)))
-void svstnt1_scatter_s64offset_f64(svbool_t, float64_t *, svint64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64offset_s64)))
-void svstnt1_scatter_s64offset_s64(svbool_t, int64_t *, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64offset_u64)))
-void svstnt1_scatter_u64offset_u64(svbool_t, uint64_t *, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64offset_f64)))
-void svstnt1_scatter_u64offset_f64(svbool_t, float64_t *, svuint64_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64offset_s64)))
-void svstnt1_scatter_u64offset_s64(svbool_t, int64_t *, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_offset_u32)))
-void svstnt1b_scatter_u32base_offset_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_offset_u64)))
-void svstnt1b_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_offset_s32)))
-void svstnt1b_scatter_u32base_offset_s32(svbool_t, svuint32_t, int64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_offset_s64)))
-void svstnt1b_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_u32)))
-void svstnt1b_scatter_u32base_u32(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_u64)))
-void svstnt1b_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_s32)))
-void svstnt1b_scatter_u32base_s32(svbool_t, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_s64)))
-void svstnt1b_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32offset_s32)))
-void svstnt1b_scatter_u32offset_s32(svbool_t, int8_t *, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32offset_u32)))
-void svstnt1b_scatter_u32offset_u32(svbool_t, uint8_t *, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_s64offset_s64)))
-void svstnt1b_scatter_s64offset_s64(svbool_t, int8_t *, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_s64offset_u64)))
-void svstnt1b_scatter_s64offset_u64(svbool_t, uint8_t *, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64offset_s64)))
-void svstnt1b_scatter_u64offset_s64(svbool_t, int8_t *, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64offset_u64)))
-void svstnt1b_scatter_u64offset_u64(svbool_t, uint8_t *, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_index_u32)))
-void svstnt1h_scatter_u32base_index_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_index_u64)))
-void svstnt1h_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_index_s32)))
-void svstnt1h_scatter_u32base_index_s32(svbool_t, svuint32_t, int64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_index_s64)))
-void svstnt1h_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_offset_u32)))
-void svstnt1h_scatter_u32base_offset_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_offset_u64)))
-void svstnt1h_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_offset_s32)))
-void svstnt1h_scatter_u32base_offset_s32(svbool_t, svuint32_t, int64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_offset_s64)))
-void svstnt1h_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_u32)))
-void svstnt1h_scatter_u32base_u32(svbool_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_u64)))
-void svstnt1h_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_s32)))
-void svstnt1h_scatter_u32base_s32(svbool_t, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_s64)))
-void svstnt1h_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64index_s64)))
-void svstnt1h_scatter_s64index_s64(svbool_t, int16_t *, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64index_u64)))
-void svstnt1h_scatter_s64index_u64(svbool_t, uint16_t *, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64index_s64)))
-void svstnt1h_scatter_u64index_s64(svbool_t, int16_t *, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64index_u64)))
-void svstnt1h_scatter_u64index_u64(svbool_t, uint16_t *, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32offset_s32)))
-void svstnt1h_scatter_u32offset_s32(svbool_t, int16_t *, svuint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32offset_u32)))
-void svstnt1h_scatter_u32offset_u32(svbool_t, uint16_t *, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64offset_s64)))
-void svstnt1h_scatter_s64offset_s64(svbool_t, int16_t *, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64offset_u64)))
-void svstnt1h_scatter_s64offset_u64(svbool_t, uint16_t *, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64offset_s64)))
-void svstnt1h_scatter_u64offset_s64(svbool_t, int16_t *, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64offset_u64)))
-void svstnt1h_scatter_u64offset_u64(svbool_t, uint16_t *, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_index_u64)))
-void svstnt1w_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_index_s64)))
-void svstnt1w_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_offset_u64)))
-void svstnt1w_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_offset_s64)))
-void svstnt1w_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_u64)))
-void svstnt1w_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_s64)))
-void svstnt1w_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64index_s64)))
-void svstnt1w_scatter_s64index_s64(svbool_t, int32_t *, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64index_u64)))
-void svstnt1w_scatter_s64index_u64(svbool_t, uint32_t *, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64index_s64)))
-void svstnt1w_scatter_u64index_s64(svbool_t, int32_t *, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64index_u64)))
-void svstnt1w_scatter_u64index_u64(svbool_t, uint32_t *, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64offset_s64)))
-void svstnt1w_scatter_s64offset_s64(svbool_t, int32_t *, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64offset_u64)))
-void svstnt1w_scatter_s64offset_u64(svbool_t, uint32_t *, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64offset_s64)))
-void svstnt1w_scatter_u64offset_s64(svbool_t, int32_t *, svuint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64offset_u64)))
-void svstnt1w_scatter_u64offset_u64(svbool_t, uint32_t *, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_u32)))
-svuint16_t svsubhnb_n_u32(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_u64)))
-svuint32_t svsubhnb_n_u64(svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_u16)))
-svuint8_t svsubhnb_n_u16(svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_s32)))
-svint16_t svsubhnb_n_s32(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_s64)))
-svint32_t svsubhnb_n_s64(svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_s16)))
-svint8_t svsubhnb_n_s16(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_u32)))
-svuint16_t svsubhnb_u32(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_u64)))
-svuint32_t svsubhnb_u64(svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_u16)))
-svuint8_t svsubhnb_u16(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_s32)))
-svint16_t svsubhnb_s32(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_s64)))
-svint32_t svsubhnb_s64(svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_s16)))
-svint8_t svsubhnb_s16(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_u32)))
-svuint16_t svsubhnt_n_u32(svuint16_t, svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_u64)))
-svuint32_t svsubhnt_n_u64(svuint32_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_u16)))
-svuint8_t svsubhnt_n_u16(svuint8_t, svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_s32)))
-svint16_t svsubhnt_n_s32(svint16_t, svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_s64)))
-svint32_t svsubhnt_n_s64(svint32_t, svint64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_s16)))
-svint8_t svsubhnt_n_s16(svint8_t, svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_u32)))
-svuint16_t svsubhnt_u32(svuint16_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_u64)))
-svuint32_t svsubhnt_u64(svuint32_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_u16)))
-svuint8_t svsubhnt_u16(svuint8_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_s32)))
-svint16_t svsubhnt_s32(svint16_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_s64)))
-svint32_t svsubhnt_s64(svint32_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_s16)))
-svint8_t svsubhnt_s16(svint8_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_s32)))
-svint32_t svsublb_n_s32(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_s64)))
-svint64_t svsublb_n_s64(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_s16)))
-svint16_t svsublb_n_s16(svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_u32)))
-svuint32_t svsublb_n_u32(svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_u64)))
-svuint64_t svsublb_n_u64(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_u16)))
-svuint16_t svsublb_n_u16(svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_s32)))
-svint32_t svsublb_s32(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_s64)))
-svint64_t svsublb_s64(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_s16)))
-svint16_t svsublb_s16(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_u32)))
-svuint32_t svsublb_u32(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_u64)))
-svuint64_t svsublb_u64(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_u16)))
-svuint16_t svsublb_u16(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_n_s32)))
-svint32_t svsublbt_n_s32(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_n_s64)))
-svint64_t svsublbt_n_s64(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_n_s16)))
-svint16_t svsublbt_n_s16(svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_s32)))
-svint32_t svsublbt_s32(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_s64)))
-svint64_t svsublbt_s64(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_s16)))
-svint16_t svsublbt_s16(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_s32)))
-svint32_t svsublt_n_s32(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_s64)))
-svint64_t svsublt_n_s64(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_s16)))
-svint16_t svsublt_n_s16(svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_u32)))
-svuint32_t svsublt_n_u32(svuint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_u64)))
-svuint64_t svsublt_n_u64(svuint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_u16)))
-svuint16_t svsublt_n_u16(svuint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_s32)))
-svint32_t svsublt_s32(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_s64)))
-svint64_t svsublt_s64(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_s16)))
-svint16_t svsublt_s16(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_u32)))
-svuint32_t svsublt_u32(svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_u64)))
-svuint64_t svsublt_u64(svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_u16)))
-svuint16_t svsublt_u16(svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_n_s32)))
-svint32_t svsubltb_n_s32(svint16_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_n_s64)))
-svint64_t svsubltb_n_s64(svint32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_n_s16)))
-svint16_t svsubltb_n_s16(svint8_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_s32)))
-svint32_t svsubltb_s32(svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_s64)))
-svint64_t svsubltb_s64(svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_s16)))
-svint16_t svsubltb_s16(svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_s32)))
-svint32_t svsubwb_n_s32(svint32_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_s64)))
-svint64_t svsubwb_n_s64(svint64_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_s16)))
-svint16_t svsubwb_n_s16(svint16_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_u32)))
-svuint32_t svsubwb_n_u32(svuint32_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_u64)))
-svuint64_t svsubwb_n_u64(svuint64_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_u16)))
-svuint16_t svsubwb_n_u16(svuint16_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_s32)))
-svint32_t svsubwb_s32(svint32_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_s64)))
-svint64_t svsubwb_s64(svint64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_s16)))
-svint16_t svsubwb_s16(svint16_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_u32)))
-svuint32_t svsubwb_u32(svuint32_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_u64)))
-svuint64_t svsubwb_u64(svuint64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_u16)))
-svuint16_t svsubwb_u16(svuint16_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_s32)))
-svint32_t svsubwt_n_s32(svint32_t, int16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_s64)))
-svint64_t svsubwt_n_s64(svint64_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_s16)))
-svint16_t svsubwt_n_s16(svint16_t, int8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_u32)))
-svuint32_t svsubwt_n_u32(svuint32_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_u64)))
-svuint64_t svsubwt_n_u64(svuint64_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_u16)))
-svuint16_t svsubwt_n_u16(svuint16_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_s32)))
-svint32_t svsubwt_s32(svint32_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_s64)))
-svint64_t svsubwt_s64(svint64_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_s16)))
-svint16_t svsubwt_s16(svint16_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_u32)))
-svuint32_t svsubwt_u32(svuint32_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_u64)))
-svuint64_t svsubwt_u64(svuint64_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_u16)))
-svuint16_t svsubwt_u16(svuint16_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u8)))
-svuint8_t svtbl2_u8(svuint8x2_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u32)))
-svuint32_t svtbl2_u32(svuint32x2_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u64)))
-svuint64_t svtbl2_u64(svuint64x2_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u16)))
-svuint16_t svtbl2_u16(svuint16x2_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s8)))
-svint8_t svtbl2_s8(svint8x2_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_f64)))
-svfloat64_t svtbl2_f64(svfloat64x2_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_f32)))
-svfloat32_t svtbl2_f32(svfloat32x2_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_f16)))
-svfloat16_t svtbl2_f16(svfloat16x2_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s32)))
-svint32_t svtbl2_s32(svint32x2_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s64)))
-svint64_t svtbl2_s64(svint64x2_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s16)))
-svint16_t svtbl2_s16(svint16x2_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u8)))
-svuint8_t svtbx_u8(svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u32)))
-svuint32_t svtbx_u32(svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u64)))
-svuint64_t svtbx_u64(svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u16)))
-svuint16_t svtbx_u16(svuint16_t, svuint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s8)))
-svint8_t svtbx_s8(svint8_t, svint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_f64)))
-svfloat64_t svtbx_f64(svfloat64_t, svfloat64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_f32)))
-svfloat32_t svtbx_f32(svfloat32_t, svfloat32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_f16)))
-svfloat16_t svtbx_f16(svfloat16_t, svfloat16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s32)))
-svint32_t svtbx_s32(svint32_t, svint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s64)))
-svint64_t svtbx_s64(svint64_t, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s16)))
-svint16_t svtbx_s16(svint16_t, svint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s8_m)))
-svint8_t svuqadd_n_s8_m(svbool_t, svint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s32_m)))
-svint32_t svuqadd_n_s32_m(svbool_t, svint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s64_m)))
-svint64_t svuqadd_n_s64_m(svbool_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s16_m)))
-svint16_t svuqadd_n_s16_m(svbool_t, svint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s8_x)))
-svint8_t svuqadd_n_s8_x(svbool_t, svint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s32_x)))
-svint32_t svuqadd_n_s32_x(svbool_t, svint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s64_x)))
-svint64_t svuqadd_n_s64_x(svbool_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s16_x)))
-svint16_t svuqadd_n_s16_x(svbool_t, svint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s8_z)))
-svint8_t svuqadd_n_s8_z(svbool_t, svint8_t, uint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s32_z)))
-svint32_t svuqadd_n_s32_z(svbool_t, svint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s64_z)))
-svint64_t svuqadd_n_s64_z(svbool_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s16_z)))
-svint16_t svuqadd_n_s16_z(svbool_t, svint16_t, uint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s8_m)))
-svint8_t svuqadd_s8_m(svbool_t, svint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s32_m)))
-svint32_t svuqadd_s32_m(svbool_t, svint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s64_m)))
-svint64_t svuqadd_s64_m(svbool_t, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s16_m)))
-svint16_t svuqadd_s16_m(svbool_t, svint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s8_x)))
-svint8_t svuqadd_s8_x(svbool_t, svint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s32_x)))
-svint32_t svuqadd_s32_x(svbool_t, svint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s64_x)))
-svint64_t svuqadd_s64_x(svbool_t, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s16_x)))
-svint16_t svuqadd_s16_x(svbool_t, svint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s8_z)))
-svint8_t svuqadd_s8_z(svbool_t, svint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s32_z)))
-svint32_t svuqadd_s32_z(svbool_t, svint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s64_z)))
-svint64_t svuqadd_s64_z(svbool_t, svint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s16_z)))
-svint16_t svuqadd_s16_z(svbool_t, svint16_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_s32)))
-svbool_t svwhilege_b8_s32(int32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_s32)))
-svbool_t svwhilege_b32_s32(int32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_s32)))
-svbool_t svwhilege_b64_s32(int32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_s32)))
-svbool_t svwhilege_b16_s32(int32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_s64)))
-svbool_t svwhilege_b8_s64(int64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_s64)))
-svbool_t svwhilege_b32_s64(int64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_s64)))
-svbool_t svwhilege_b64_s64(int64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_s64)))
-svbool_t svwhilege_b16_s64(int64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_u32)))
-svbool_t svwhilege_b8_u32(uint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_u32)))
-svbool_t svwhilege_b32_u32(uint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_u32)))
-svbool_t svwhilege_b64_u32(uint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_u32)))
-svbool_t svwhilege_b16_u32(uint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_u64)))
-svbool_t svwhilege_b8_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_u64)))
-svbool_t svwhilege_b32_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_u64)))
-svbool_t svwhilege_b64_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_u64)))
-svbool_t svwhilege_b16_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_s32)))
-svbool_t svwhilegt_b8_s32(int32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_s32)))
-svbool_t svwhilegt_b32_s32(int32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_s32)))
-svbool_t svwhilegt_b64_s32(int32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_s32)))
-svbool_t svwhilegt_b16_s32(int32_t, int32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_s64)))
-svbool_t svwhilegt_b8_s64(int64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_s64)))
-svbool_t svwhilegt_b32_s64(int64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_s64)))
-svbool_t svwhilegt_b64_s64(int64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_s64)))
-svbool_t svwhilegt_b16_s64(int64_t, int64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_u32)))
-svbool_t svwhilegt_b8_u32(uint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_u32)))
-svbool_t svwhilegt_b32_u32(uint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_u32)))
-svbool_t svwhilegt_b64_u32(uint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_u32)))
-svbool_t svwhilegt_b16_u32(uint32_t, uint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_u64)))
-svbool_t svwhilegt_b8_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_u64)))
-svbool_t svwhilegt_b32_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_u64)))
-svbool_t svwhilegt_b64_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_u64)))
-svbool_t svwhilegt_b16_u64(uint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u8)))
-svbool_t svwhilerw_u8(uint8_t const *, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s8)))
-svbool_t svwhilerw_s8(int8_t const *, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u64)))
-svbool_t svwhilerw_u64(uint64_t const *, uint64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_f64)))
-svbool_t svwhilerw_f64(float64_t const *, float64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s64)))
-svbool_t svwhilerw_s64(int64_t const *, int64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u16)))
-svbool_t svwhilerw_u16(uint16_t const *, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_f16)))
-svbool_t svwhilerw_f16(float16_t const *, float16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s16)))
-svbool_t svwhilerw_s16(int16_t const *, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u32)))
-svbool_t svwhilerw_u32(uint32_t const *, uint32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_f32)))
-svbool_t svwhilerw_f32(float32_t const *, float32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s32)))
-svbool_t svwhilerw_s32(int32_t const *, int32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u8)))
-svbool_t svwhilewr_u8(uint8_t const *, uint8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s8)))
-svbool_t svwhilewr_s8(int8_t const *, int8_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u64)))
-svbool_t svwhilewr_u64(uint64_t const *, uint64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_f64)))
-svbool_t svwhilewr_f64(float64_t const *, float64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s64)))
-svbool_t svwhilewr_s64(int64_t const *, int64_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u16)))
-svbool_t svwhilewr_u16(uint16_t const *, uint16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_f16)))
-svbool_t svwhilewr_f16(float16_t const *, float16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s16)))
-svbool_t svwhilewr_s16(int16_t const *, int16_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u32)))
-svbool_t svwhilewr_u32(uint32_t const *, uint32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_f32)))
-svbool_t svwhilewr_f32(float32_t const *, float32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s32)))
-svbool_t svwhilewr_s32(int32_t const *, int32_t const *);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u8)))
-svuint8_t svxar_n_u8(svuint8_t, svuint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u32)))
-svuint32_t svxar_n_u32(svuint32_t, svuint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u64)))
-svuint64_t svxar_n_u64(svuint64_t, svuint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u16)))
-svuint16_t svxar_n_u16(svuint16_t, svuint16_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s8)))
-svint8_t svxar_n_s8(svint8_t, svint8_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s32)))
-svint32_t svxar_n_s32(svint32_t, svint32_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s64)))
-svint64_t svxar_n_s64(svint64_t, svint64_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s16)))
-svint16_t svxar_n_s16(svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s8)))
-svint8_t svaba(svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s32)))
-svint32_t svaba(svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s64)))
-svint64_t svaba(svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s16)))
-svint16_t svaba(svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u8)))
-svuint8_t svaba(svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u32)))
-svuint32_t svaba(svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u64)))
-svuint64_t svaba(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u16)))
-svuint16_t svaba(svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s8)))
-svint8_t svaba(svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s32)))
-svint32_t svaba(svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s64)))
-svint64_t svaba(svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s16)))
-svint16_t svaba(svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u8)))
-svuint8_t svaba(svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u32)))
-svuint32_t svaba(svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u64)))
-svuint64_t svaba(svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u16)))
-svuint16_t svaba(svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_s32)))
-svint32_t svabalb(svint32_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_s64)))
-svint64_t svabalb(svint64_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_s16)))
-svint16_t svabalb(svint16_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_u32)))
-svuint32_t svabalb(svuint32_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_u64)))
-svuint64_t svabalb(svuint64_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_u16)))
-svuint16_t svabalb(svuint16_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_s32)))
-svint32_t svabalb(svint32_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_s64)))
-svint64_t svabalb(svint64_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_s16)))
-svint16_t svabalb(svint16_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_u32)))
-svuint32_t svabalb(svuint32_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_u64)))
-svuint64_t svabalb(svuint64_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_u16)))
-svuint16_t svabalb(svuint16_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_s32)))
-svint32_t svabalt(svint32_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_s64)))
-svint64_t svabalt(svint64_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_s16)))
-svint16_t svabalt(svint16_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_u32)))
-svuint32_t svabalt(svuint32_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_u64)))
-svuint64_t svabalt(svuint64_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_u16)))
-svuint16_t svabalt(svuint16_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_s32)))
-svint32_t svabalt(svint32_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_s64)))
-svint64_t svabalt(svint64_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_s16)))
-svint16_t svabalt(svint16_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_u32)))
-svuint32_t svabalt(svuint32_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_u64)))
-svuint64_t svabalt(svuint64_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_u16)))
-svuint16_t svabalt(svuint16_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_s32)))
-svint32_t svabdlb(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_s64)))
-svint64_t svabdlb(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_s16)))
-svint16_t svabdlb(svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_u32)))
-svuint32_t svabdlb(svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_u64)))
-svuint64_t svabdlb(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_u16)))
-svuint16_t svabdlb(svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_s32)))
-svint32_t svabdlb(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_s64)))
-svint64_t svabdlb(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_s16)))
-svint16_t svabdlb(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_u32)))
-svuint32_t svabdlb(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_u64)))
-svuint64_t svabdlb(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_u16)))
-svuint16_t svabdlb(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_s32)))
-svint32_t svabdlt(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_s64)))
-svint64_t svabdlt(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_s16)))
-svint16_t svabdlt(svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_u32)))
-svuint32_t svabdlt(svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_u64)))
-svuint64_t svabdlt(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_u16)))
-svuint16_t svabdlt(svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_s32)))
-svint32_t svabdlt(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_s64)))
-svint64_t svabdlt(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_s16)))
-svint16_t svabdlt(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_u32)))
-svuint32_t svabdlt(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_u64)))
-svuint64_t svabdlt(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_u16)))
-svuint16_t svabdlt(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s32_m)))
-svint32_t svadalp_m(svbool_t, svint32_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s64_m)))
-svint64_t svadalp_m(svbool_t, svint64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s16_m)))
-svint16_t svadalp_m(svbool_t, svint16_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s32_x)))
-svint32_t svadalp_x(svbool_t, svint32_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s64_x)))
-svint64_t svadalp_x(svbool_t, svint64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s16_x)))
-svint16_t svadalp_x(svbool_t, svint16_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s32_z)))
-svint32_t svadalp_z(svbool_t, svint32_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s64_z)))
-svint64_t svadalp_z(svbool_t, svint64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s16_z)))
-svint16_t svadalp_z(svbool_t, svint16_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u32_m)))
-svuint32_t svadalp_m(svbool_t, svuint32_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u64_m)))
-svuint64_t svadalp_m(svbool_t, svuint64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u16_m)))
-svuint16_t svadalp_m(svbool_t, svuint16_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u32_x)))
-svuint32_t svadalp_x(svbool_t, svuint32_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u64_x)))
-svuint64_t svadalp_x(svbool_t, svuint64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u16_x)))
-svuint16_t svadalp_x(svbool_t, svuint16_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u32_z)))
-svuint32_t svadalp_z(svbool_t, svuint32_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u64_z)))
-svuint64_t svadalp_z(svbool_t, svuint64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u16_z)))
-svuint16_t svadalp_z(svbool_t, svuint16_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_n_u32)))
-svuint32_t svadclb(svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_n_u64)))
-svuint64_t svadclb(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_u32)))
-svuint32_t svadclb(svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_u64)))
-svuint64_t svadclb(svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_n_u32)))
-svuint32_t svadclt(svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_n_u64)))
-svuint64_t svadclt(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_u32)))
-svuint32_t svadclt(svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_u64)))
-svuint64_t svadclt(svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_u32)))
-svuint16_t svaddhnb(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_u64)))
-svuint32_t svaddhnb(svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_u16)))
-svuint8_t svaddhnb(svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_s32)))
-svint16_t svaddhnb(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_s64)))
-svint32_t svaddhnb(svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_s16)))
-svint8_t svaddhnb(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_u32)))
-svuint16_t svaddhnb(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_u64)))
-svuint32_t svaddhnb(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_u16)))
-svuint8_t svaddhnb(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_s32)))
-svint16_t svaddhnb(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_s64)))
-svint32_t svaddhnb(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_s16)))
-svint8_t svaddhnb(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_u32)))
-svuint16_t svaddhnt(svuint16_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_u64)))
-svuint32_t svaddhnt(svuint32_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_u16)))
-svuint8_t svaddhnt(svuint8_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_s32)))
-svint16_t svaddhnt(svint16_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_s64)))
-svint32_t svaddhnt(svint32_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_s16)))
-svint8_t svaddhnt(svint8_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_u32)))
-svuint16_t svaddhnt(svuint16_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_u64)))
-svuint32_t svaddhnt(svuint32_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_u16)))
-svuint8_t svaddhnt(svuint8_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_s32)))
-svint16_t svaddhnt(svint16_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_s64)))
-svint32_t svaddhnt(svint32_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_s16)))
-svint8_t svaddhnt(svint8_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_s32)))
-svint32_t svaddlb(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_s64)))
-svint64_t svaddlb(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_s16)))
-svint16_t svaddlb(svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_u32)))
-svuint32_t svaddlb(svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_u64)))
-svuint64_t svaddlb(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_u16)))
-svuint16_t svaddlb(svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_s32)))
-svint32_t svaddlb(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_s64)))
-svint64_t svaddlb(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_s16)))
-svint16_t svaddlb(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_u32)))
-svuint32_t svaddlb(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_u64)))
-svuint64_t svaddlb(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_u16)))
-svuint16_t svaddlb(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_n_s32)))
-svint32_t svaddlbt(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_n_s64)))
-svint64_t svaddlbt(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_n_s16)))
-svint16_t svaddlbt(svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_s32)))
-svint32_t svaddlbt(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_s64)))
-svint64_t svaddlbt(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_s16)))
-svint16_t svaddlbt(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_s32)))
-svint32_t svaddlt(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_s64)))
-svint64_t svaddlt(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_s16)))
-svint16_t svaddlt(svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_u32)))
-svuint32_t svaddlt(svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_u64)))
-svuint64_t svaddlt(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_u16)))
-svuint16_t svaddlt(svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_s32)))
-svint32_t svaddlt(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_s64)))
-svint64_t svaddlt(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_s16)))
-svint16_t svaddlt(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_u32)))
-svuint32_t svaddlt(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_u64)))
-svuint64_t svaddlt(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_u16)))
-svuint16_t svaddlt(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f64_m)))
-svfloat64_t svaddp_m(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f32_m)))
-svfloat32_t svaddp_m(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f16_m)))
-svfloat16_t svaddp_m(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f64_x)))
-svfloat64_t svaddp_x(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f32_x)))
-svfloat32_t svaddp_x(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f16_x)))
-svfloat16_t svaddp_x(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u8_m)))
-svuint8_t svaddp_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u32_m)))
-svuint32_t svaddp_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u64_m)))
-svuint64_t svaddp_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u16_m)))
-svuint16_t svaddp_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s8_m)))
-svint8_t svaddp_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s32_m)))
-svint32_t svaddp_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s64_m)))
-svint64_t svaddp_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s16_m)))
-svint16_t svaddp_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u8_x)))
-svuint8_t svaddp_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u32_x)))
-svuint32_t svaddp_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u64_x)))
-svuint64_t svaddp_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u16_x)))
-svuint16_t svaddp_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s8_x)))
-svint8_t svaddp_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s32_x)))
-svint32_t svaddp_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s64_x)))
-svint64_t svaddp_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s16_x)))
-svint16_t svaddp_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_s32)))
-svint32_t svaddwb(svint32_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_s64)))
-svint64_t svaddwb(svint64_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_s16)))
-svint16_t svaddwb(svint16_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_u32)))
-svuint32_t svaddwb(svuint32_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_u64)))
-svuint64_t svaddwb(svuint64_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_u16)))
-svuint16_t svaddwb(svuint16_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_s32)))
-svint32_t svaddwb(svint32_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_s64)))
-svint64_t svaddwb(svint64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_s16)))
-svint16_t svaddwb(svint16_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_u32)))
-svuint32_t svaddwb(svuint32_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_u64)))
-svuint64_t svaddwb(svuint64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_u16)))
-svuint16_t svaddwb(svuint16_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_s32)))
-svint32_t svaddwt(svint32_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_s64)))
-svint64_t svaddwt(svint64_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_s16)))
-svint16_t svaddwt(svint16_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_u32)))
-svuint32_t svaddwt(svuint32_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_u64)))
-svuint64_t svaddwt(svuint64_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_u16)))
-svuint16_t svaddwt(svuint16_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_s32)))
-svint32_t svaddwt(svint32_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_s64)))
-svint64_t svaddwt(svint64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_s16)))
-svint16_t svaddwt(svint16_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_u32)))
-svuint32_t svaddwt(svuint32_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_u64)))
-svuint64_t svaddwt(svuint64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_u16)))
-svuint16_t svaddwt(svuint16_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u8)))
-svuint8_t svbcax(svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u32)))
-svuint32_t svbcax(svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u64)))
-svuint64_t svbcax(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u16)))
-svuint16_t svbcax(svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s8)))
-svint8_t svbcax(svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s32)))
-svint32_t svbcax(svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s64)))
-svint64_t svbcax(svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s16)))
-svint16_t svbcax(svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u8)))
-svuint8_t svbcax(svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u32)))
-svuint32_t svbcax(svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u64)))
-svuint64_t svbcax(svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u16)))
-svuint16_t svbcax(svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s8)))
-svint8_t svbcax(svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s32)))
-svint32_t svbcax(svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s64)))
-svint64_t svbcax(svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s16)))
-svint16_t svbcax(svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u8)))
-svuint8_t svbsl1n(svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u32)))
-svuint32_t svbsl1n(svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u64)))
-svuint64_t svbsl1n(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u16)))
-svuint16_t svbsl1n(svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s8)))
-svint8_t svbsl1n(svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s32)))
-svint32_t svbsl1n(svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s64)))
-svint64_t svbsl1n(svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s16)))
-svint16_t svbsl1n(svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u8)))
-svuint8_t svbsl1n(svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u32)))
-svuint32_t svbsl1n(svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u64)))
-svuint64_t svbsl1n(svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u16)))
-svuint16_t svbsl1n(svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s8)))
-svint8_t svbsl1n(svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s32)))
-svint32_t svbsl1n(svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s64)))
-svint64_t svbsl1n(svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s16)))
-svint16_t svbsl1n(svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u8)))
-svuint8_t svbsl2n(svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u32)))
-svuint32_t svbsl2n(svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u64)))
-svuint64_t svbsl2n(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u16)))
-svuint16_t svbsl2n(svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s8)))
-svint8_t svbsl2n(svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s32)))
-svint32_t svbsl2n(svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s64)))
-svint64_t svbsl2n(svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s16)))
-svint16_t svbsl2n(svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u8)))
-svuint8_t svbsl2n(svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u32)))
-svuint32_t svbsl2n(svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u64)))
-svuint64_t svbsl2n(svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u16)))
-svuint16_t svbsl2n(svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s8)))
-svint8_t svbsl2n(svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s32)))
-svint32_t svbsl2n(svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s64)))
-svint64_t svbsl2n(svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s16)))
-svint16_t svbsl2n(svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u8)))
-svuint8_t svbsl(svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u32)))
-svuint32_t svbsl(svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u64)))
-svuint64_t svbsl(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u16)))
-svuint16_t svbsl(svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s8)))
-svint8_t svbsl(svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s32)))
-svint32_t svbsl(svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s64)))
-svint64_t svbsl(svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s16)))
-svint16_t svbsl(svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u8)))
-svuint8_t svbsl(svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u32)))
-svuint32_t svbsl(svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u64)))
-svuint64_t svbsl(svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u16)))
-svuint16_t svbsl(svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s8)))
-svint8_t svbsl(svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s32)))
-svint32_t svbsl(svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s64)))
-svint64_t svbsl(svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s16)))
-svint16_t svbsl(svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u8)))
-svuint8_t svcadd(svuint8_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u32)))
-svuint32_t svcadd(svuint32_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u64)))
-svuint64_t svcadd(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u16)))
-svuint16_t svcadd(svuint16_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s8)))
-svint8_t svcadd(svint8_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s32)))
-svint32_t svcadd(svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s64)))
-svint64_t svcadd(svint64_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s16)))
-svint16_t svcadd(svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_s32)))
-svint32_t svcdot(svint32_t, svint8_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_s64)))
-svint64_t svcdot(svint64_t, svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_lane_s32)))
-svint32_t svcdot_lane(svint32_t, svint8_t, svint8_t, uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_lane_s64)))
-svint64_t svcdot_lane(svint64_t, svint16_t, svint16_t, uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u8)))
-svuint8_t svcmla(svuint8_t, svuint8_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u32)))
-svuint32_t svcmla(svuint32_t, svuint32_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u64)))
-svuint64_t svcmla(svuint64_t, svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u16)))
-svuint16_t svcmla(svuint16_t, svuint16_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s8)))
-svint8_t svcmla(svint8_t, svint8_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s32)))
-svint32_t svcmla(svint32_t, svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s64)))
-svint64_t svcmla(svint64_t, svint64_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s16)))
-svint16_t svcmla(svint16_t, svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_u32)))
-svuint32_t svcmla_lane(svuint32_t, svuint32_t, svuint32_t, uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_u16)))
-svuint16_t svcmla_lane(svuint16_t, svuint16_t, svuint16_t, uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_s32)))
-svint32_t svcmla_lane(svint32_t, svint32_t, svint32_t, uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_s16)))
-svint16_t svcmla_lane(svint16_t, svint16_t, svint16_t, uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f32_f16_m)))
-svfloat32_t svcvtlt_f32_m(svfloat32_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f32_f16_x)))
-svfloat32_t svcvtlt_f32_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f64_f32_m)))
-svfloat64_t svcvtlt_f64_m(svfloat64_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f64_f32_x)))
-svfloat64_t svcvtlt_f64_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtnt_f16_f32_m)))
-svfloat16_t svcvtnt_f16_m(svfloat16_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtnt_f32_f64_m)))
-svfloat32_t svcvtnt_f32_m(svfloat32_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtx_f32_f64_m)))
-svfloat32_t svcvtx_f32_m(svfloat32_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtx_f32_f64_x)))
-svfloat32_t svcvtx_f32_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtx_f32_f64_z)))
-svfloat32_t svcvtx_f32_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtxnt_f32_f64_m)))
-svfloat32_t svcvtxnt_f32_m(svfloat32_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u8)))
-svuint8_t sveor3(svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u32)))
-svuint32_t sveor3(svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u64)))
-svuint64_t sveor3(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u16)))
-svuint16_t sveor3(svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s8)))
-svint8_t sveor3(svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s32)))
-svint32_t sveor3(svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s64)))
-svint64_t sveor3(svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s16)))
-svint16_t sveor3(svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u8)))
-svuint8_t sveor3(svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u32)))
-svuint32_t sveor3(svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u64)))
-svuint64_t sveor3(svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u16)))
-svuint16_t sveor3(svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s8)))
-svint8_t sveor3(svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s32)))
-svint32_t sveor3(svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s64)))
-svint64_t sveor3(svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s16)))
-svint16_t sveor3(svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u8)))
-svuint8_t sveorbt(svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u32)))
-svuint32_t sveorbt(svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u64)))
-svuint64_t sveorbt(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u16)))
-svuint16_t sveorbt(svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s8)))
-svint8_t sveorbt(svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s32)))
-svint32_t sveorbt(svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s64)))
-svint64_t sveorbt(svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s16)))
-svint16_t sveorbt(svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u8)))
-svuint8_t sveorbt(svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u32)))
-svuint32_t sveorbt(svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u64)))
-svuint64_t sveorbt(svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u16)))
-svuint16_t sveorbt(svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s8)))
-svint8_t sveorbt(svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s32)))
-svint32_t sveorbt(svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s64)))
-svint64_t sveorbt(svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s16)))
-svint16_t sveorbt(svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u8)))
-svuint8_t sveortb(svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u32)))
-svuint32_t sveortb(svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u64)))
-svuint64_t sveortb(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u16)))
-svuint16_t sveortb(svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s8)))
-svint8_t sveortb(svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s32)))
-svint32_t sveortb(svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s64)))
-svint64_t sveortb(svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s16)))
-svint16_t sveortb(svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u8)))
-svuint8_t sveortb(svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u32)))
-svuint32_t sveortb(svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u64)))
-svuint64_t sveortb(svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u16)))
-svuint16_t sveortb(svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s8)))
-svint8_t sveortb(svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s32)))
-svint32_t sveortb(svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s64)))
-svint64_t sveortb(svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s16)))
-svint16_t sveortb(svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s8_m)))
-svint8_t svhadd_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s32_m)))
-svint32_t svhadd_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s64_m)))
-svint64_t svhadd_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s16_m)))
-svint16_t svhadd_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s8_x)))
-svint8_t svhadd_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s32_x)))
-svint32_t svhadd_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s64_x)))
-svint64_t svhadd_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s16_x)))
-svint16_t svhadd_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s8_z)))
-svint8_t svhadd_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s32_z)))
-svint32_t svhadd_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s64_z)))
-svint64_t svhadd_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s16_z)))
-svint16_t svhadd_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u8_m)))
-svuint8_t svhadd_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u32_m)))
-svuint32_t svhadd_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u64_m)))
-svuint64_t svhadd_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u16_m)))
-svuint16_t svhadd_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u8_x)))
-svuint8_t svhadd_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u32_x)))
-svuint32_t svhadd_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u64_x)))
-svuint64_t svhadd_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u16_x)))
-svuint16_t svhadd_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u8_z)))
-svuint8_t svhadd_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u32_z)))
-svuint32_t svhadd_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u64_z)))
-svuint64_t svhadd_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u16_z)))
-svuint16_t svhadd_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s8_m)))
-svint8_t svhadd_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s32_m)))
-svint32_t svhadd_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s64_m)))
-svint64_t svhadd_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s16_m)))
-svint16_t svhadd_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s8_x)))
-svint8_t svhadd_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s32_x)))
-svint32_t svhadd_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s64_x)))
-svint64_t svhadd_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s16_x)))
-svint16_t svhadd_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s8_z)))
-svint8_t svhadd_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s32_z)))
-svint32_t svhadd_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s64_z)))
-svint64_t svhadd_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s16_z)))
-svint16_t svhadd_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u8_m)))
-svuint8_t svhadd_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u32_m)))
-svuint32_t svhadd_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u64_m)))
-svuint64_t svhadd_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u16_m)))
-svuint16_t svhadd_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u8_x)))
-svuint8_t svhadd_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u32_x)))
-svuint32_t svhadd_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u64_x)))
-svuint64_t svhadd_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u16_x)))
-svuint16_t svhadd_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u8_z)))
-svuint8_t svhadd_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u32_z)))
-svuint32_t svhadd_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u64_z)))
-svuint64_t svhadd_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u16_z)))
-svuint16_t svhadd_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_u32_z)))
-svuint32_t svhistcnt_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_u64_z)))
-svuint64_t svhistcnt_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_s32_z)))
-svuint32_t svhistcnt_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_s64_z)))
-svuint64_t svhistcnt_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistseg_u8)))
-svuint8_t svhistseg(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistseg_s8)))
-svuint8_t svhistseg(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s8_m)))
-svint8_t svhsub_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s32_m)))
-svint32_t svhsub_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s64_m)))
-svint64_t svhsub_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s16_m)))
-svint16_t svhsub_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s8_x)))
-svint8_t svhsub_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s32_x)))
-svint32_t svhsub_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s64_x)))
-svint64_t svhsub_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s16_x)))
-svint16_t svhsub_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s8_z)))
-svint8_t svhsub_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s32_z)))
-svint32_t svhsub_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s64_z)))
-svint64_t svhsub_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s16_z)))
-svint16_t svhsub_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u8_m)))
-svuint8_t svhsub_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u32_m)))
-svuint32_t svhsub_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u64_m)))
-svuint64_t svhsub_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u16_m)))
-svuint16_t svhsub_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u8_x)))
-svuint8_t svhsub_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u32_x)))
-svuint32_t svhsub_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u64_x)))
-svuint64_t svhsub_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u16_x)))
-svuint16_t svhsub_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u8_z)))
-svuint8_t svhsub_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u32_z)))
-svuint32_t svhsub_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u64_z)))
-svuint64_t svhsub_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u16_z)))
-svuint16_t svhsub_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s8_m)))
-svint8_t svhsub_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s32_m)))
-svint32_t svhsub_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s64_m)))
-svint64_t svhsub_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s16_m)))
-svint16_t svhsub_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s8_x)))
-svint8_t svhsub_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s32_x)))
-svint32_t svhsub_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s64_x)))
-svint64_t svhsub_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s16_x)))
-svint16_t svhsub_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s8_z)))
-svint8_t svhsub_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s32_z)))
-svint32_t svhsub_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s64_z)))
-svint64_t svhsub_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s16_z)))
-svint16_t svhsub_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u8_m)))
-svuint8_t svhsub_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u32_m)))
-svuint32_t svhsub_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u64_m)))
-svuint64_t svhsub_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u16_m)))
-svuint16_t svhsub_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u8_x)))
-svuint8_t svhsub_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u32_x)))
-svuint32_t svhsub_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u64_x)))
-svuint64_t svhsub_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u16_x)))
-svuint16_t svhsub_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u8_z)))
-svuint8_t svhsub_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u32_z)))
-svuint32_t svhsub_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u64_z)))
-svuint64_t svhsub_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u16_z)))
-svuint16_t svhsub_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s8_m)))
-svint8_t svhsubr_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s32_m)))
-svint32_t svhsubr_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s64_m)))
-svint64_t svhsubr_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s16_m)))
-svint16_t svhsubr_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s8_x)))
-svint8_t svhsubr_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s32_x)))
-svint32_t svhsubr_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s64_x)))
-svint64_t svhsubr_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s16_x)))
-svint16_t svhsubr_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s8_z)))
-svint8_t svhsubr_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s32_z)))
-svint32_t svhsubr_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s64_z)))
-svint64_t svhsubr_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s16_z)))
-svint16_t svhsubr_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u8_m)))
-svuint8_t svhsubr_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u32_m)))
-svuint32_t svhsubr_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u64_m)))
-svuint64_t svhsubr_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u16_m)))
-svuint16_t svhsubr_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u8_x)))
-svuint8_t svhsubr_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u32_x)))
-svuint32_t svhsubr_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u64_x)))
-svuint64_t svhsubr_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u16_x)))
-svuint16_t svhsubr_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u8_z)))
-svuint8_t svhsubr_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u32_z)))
-svuint32_t svhsubr_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u64_z)))
-svuint64_t svhsubr_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u16_z)))
-svuint16_t svhsubr_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s8_m)))
-svint8_t svhsubr_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s32_m)))
-svint32_t svhsubr_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s64_m)))
-svint64_t svhsubr_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s16_m)))
-svint16_t svhsubr_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s8_x)))
-svint8_t svhsubr_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s32_x)))
-svint32_t svhsubr_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s64_x)))
-svint64_t svhsubr_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s16_x)))
-svint16_t svhsubr_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s8_z)))
-svint8_t svhsubr_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s32_z)))
-svint32_t svhsubr_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s64_z)))
-svint64_t svhsubr_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s16_z)))
-svint16_t svhsubr_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u8_m)))
-svuint8_t svhsubr_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u32_m)))
-svuint32_t svhsubr_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u64_m)))
-svuint64_t svhsubr_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u16_m)))
-svuint16_t svhsubr_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u8_x)))
-svuint8_t svhsubr_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u32_x)))
-svuint32_t svhsubr_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u64_x)))
-svuint64_t svhsubr_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u16_x)))
-svuint16_t svhsubr_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u8_z)))
-svuint8_t svhsubr_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u32_z)))
-svuint32_t svhsubr_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u64_z)))
-svuint64_t svhsubr_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u16_z)))
-svuint16_t svhsubr_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_index_u32)))
-svuint32_t svldnt1_gather_index_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_index_u64)))
-svuint64_t svldnt1_gather_index_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_index_f64)))
-svfloat64_t svldnt1_gather_index_f64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_index_f32)))
-svfloat32_t svldnt1_gather_index_f32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_index_s32)))
-svint32_t svldnt1_gather_index_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_index_s64)))
-svint64_t svldnt1_gather_index_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_offset_u32)))
-svuint32_t svldnt1_gather_offset_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_offset_u64)))
-svuint64_t svldnt1_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_offset_f64)))
-svfloat64_t svldnt1_gather_offset_f64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_offset_f32)))
-svfloat32_t svldnt1_gather_offset_f32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_offset_s32)))
-svint32_t svldnt1_gather_offset_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_offset_s64)))
-svint64_t svldnt1_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_u32)))
-svuint32_t svldnt1_gather_u32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_u64)))
-svuint64_t svldnt1_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_f64)))
-svfloat64_t svldnt1_gather_f64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_f32)))
-svfloat32_t svldnt1_gather_f32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_s32)))
-svint32_t svldnt1_gather_s32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_s64)))
-svint64_t svldnt1_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64index_u64)))
-svuint64_t svldnt1_gather_index(svbool_t, uint64_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64index_f64)))
-svfloat64_t svldnt1_gather_index(svbool_t, float64_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64index_s64)))
-svint64_t svldnt1_gather_index(svbool_t, int64_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64index_u64)))
-svuint64_t svldnt1_gather_index(svbool_t, uint64_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64index_f64)))
-svfloat64_t svldnt1_gather_index(svbool_t, float64_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64index_s64)))
-svint64_t svldnt1_gather_index(svbool_t, int64_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32offset_u32)))
-svuint32_t svldnt1_gather_offset(svbool_t, uint32_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32offset_f32)))
-svfloat32_t svldnt1_gather_offset(svbool_t, float32_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32offset_s32)))
-svint32_t svldnt1_gather_offset(svbool_t, int32_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64offset_u64)))
-svuint64_t svldnt1_gather_offset(svbool_t, uint64_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64offset_f64)))
-svfloat64_t svldnt1_gather_offset(svbool_t, float64_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64offset_s64)))
-svint64_t svldnt1_gather_offset(svbool_t, int64_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64offset_u64)))
-svuint64_t svldnt1_gather_offset(svbool_t, uint64_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64offset_f64)))
-svfloat64_t svldnt1_gather_offset(svbool_t, float64_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64offset_s64)))
-svint64_t svldnt1_gather_offset(svbool_t, int64_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_offset_u32)))
-svuint32_t svldnt1sb_gather_offset_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_offset_u64)))
-svuint64_t svldnt1sb_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_offset_s32)))
-svint32_t svldnt1sb_gather_offset_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_offset_s64)))
-svint64_t svldnt1sb_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_u32)))
-svuint32_t svldnt1sb_gather_u32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_u64)))
-svuint64_t svldnt1sb_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_s32)))
-svint32_t svldnt1sb_gather_s32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_s64)))
-svint64_t svldnt1sb_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32offset_u32)))
-svuint32_t svldnt1sb_gather_offset_u32(svbool_t, int8_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32offset_s32)))
-svint32_t svldnt1sb_gather_offset_s32(svbool_t, int8_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_s64offset_u64)))
-svuint64_t svldnt1sb_gather_offset_u64(svbool_t, int8_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_s64offset_s64)))
-svint64_t svldnt1sb_gather_offset_s64(svbool_t, int8_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64offset_u64)))
-svuint64_t svldnt1sb_gather_offset_u64(svbool_t, int8_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64offset_s64)))
-svint64_t svldnt1sb_gather_offset_s64(svbool_t, int8_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_index_u32)))
-svuint32_t svldnt1sh_gather_index_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_index_u64)))
-svuint64_t svldnt1sh_gather_index_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_index_s32)))
-svint32_t svldnt1sh_gather_index_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_index_s64)))
-svint64_t svldnt1sh_gather_index_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_offset_u32)))
-svuint32_t svldnt1sh_gather_offset_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_offset_u64)))
-svuint64_t svldnt1sh_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_offset_s32)))
-svint32_t svldnt1sh_gather_offset_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_offset_s64)))
-svint64_t svldnt1sh_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_u32)))
-svuint32_t svldnt1sh_gather_u32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_u64)))
-svuint64_t svldnt1sh_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_s32)))
-svint32_t svldnt1sh_gather_s32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_s64)))
-svint64_t svldnt1sh_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64index_u64)))
-svuint64_t svldnt1sh_gather_index_u64(svbool_t, int16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64index_s64)))
-svint64_t svldnt1sh_gather_index_s64(svbool_t, int16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64index_u64)))
-svuint64_t svldnt1sh_gather_index_u64(svbool_t, int16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64index_s64)))
-svint64_t svldnt1sh_gather_index_s64(svbool_t, int16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32offset_u32)))
-svuint32_t svldnt1sh_gather_offset_u32(svbool_t, int16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32offset_s32)))
-svint32_t svldnt1sh_gather_offset_s32(svbool_t, int16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64offset_u64)))
-svuint64_t svldnt1sh_gather_offset_u64(svbool_t, int16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64offset_s64)))
-svint64_t svldnt1sh_gather_offset_s64(svbool_t, int16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64offset_u64)))
-svuint64_t svldnt1sh_gather_offset_u64(svbool_t, int16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64offset_s64)))
-svint64_t svldnt1sh_gather_offset_s64(svbool_t, int16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_index_u64)))
-svuint64_t svldnt1sw_gather_index_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_index_s64)))
-svint64_t svldnt1sw_gather_index_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_offset_u64)))
-svuint64_t svldnt1sw_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_offset_s64)))
-svint64_t svldnt1sw_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_u64)))
-svuint64_t svldnt1sw_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_s64)))
-svint64_t svldnt1sw_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64index_u64)))
-svuint64_t svldnt1sw_gather_index_u64(svbool_t, int32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64index_s64)))
-svint64_t svldnt1sw_gather_index_s64(svbool_t, int32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64index_u64)))
-svuint64_t svldnt1sw_gather_index_u64(svbool_t, int32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64index_s64)))
-svint64_t svldnt1sw_gather_index_s64(svbool_t, int32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64offset_u64)))
-svuint64_t svldnt1sw_gather_offset_u64(svbool_t, int32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64offset_s64)))
-svint64_t svldnt1sw_gather_offset_s64(svbool_t, int32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64offset_u64)))
-svuint64_t svldnt1sw_gather_offset_u64(svbool_t, int32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64offset_s64)))
-svint64_t svldnt1sw_gather_offset_s64(svbool_t, int32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_offset_u32)))
-svuint32_t svldnt1ub_gather_offset_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_offset_u64)))
-svuint64_t svldnt1ub_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_offset_s32)))
-svint32_t svldnt1ub_gather_offset_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_offset_s64)))
-svint64_t svldnt1ub_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_u32)))
-svuint32_t svldnt1ub_gather_u32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_u64)))
-svuint64_t svldnt1ub_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_s32)))
-svint32_t svldnt1ub_gather_s32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_s64)))
-svint64_t svldnt1ub_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32offset_u32)))
-svuint32_t svldnt1ub_gather_offset_u32(svbool_t, uint8_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32offset_s32)))
-svint32_t svldnt1ub_gather_offset_s32(svbool_t, uint8_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_s64offset_u64)))
-svuint64_t svldnt1ub_gather_offset_u64(svbool_t, uint8_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_s64offset_s64)))
-svint64_t svldnt1ub_gather_offset_s64(svbool_t, uint8_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64offset_u64)))
-svuint64_t svldnt1ub_gather_offset_u64(svbool_t, uint8_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64offset_s64)))
-svint64_t svldnt1ub_gather_offset_s64(svbool_t, uint8_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_index_u32)))
-svuint32_t svldnt1uh_gather_index_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_index_u64)))
-svuint64_t svldnt1uh_gather_index_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_index_s32)))
-svint32_t svldnt1uh_gather_index_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_index_s64)))
-svint64_t svldnt1uh_gather_index_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_offset_u32)))
-svuint32_t svldnt1uh_gather_offset_u32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_offset_u64)))
-svuint64_t svldnt1uh_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_offset_s32)))
-svint32_t svldnt1uh_gather_offset_s32(svbool_t, svuint32_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_offset_s64)))
-svint64_t svldnt1uh_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_u32)))
-svuint32_t svldnt1uh_gather_u32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_u64)))
-svuint64_t svldnt1uh_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_s32)))
-svint32_t svldnt1uh_gather_s32(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_s64)))
-svint64_t svldnt1uh_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64index_u64)))
-svuint64_t svldnt1uh_gather_index_u64(svbool_t, uint16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64index_s64)))
-svint64_t svldnt1uh_gather_index_s64(svbool_t, uint16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64index_u64)))
-svuint64_t svldnt1uh_gather_index_u64(svbool_t, uint16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64index_s64)))
-svint64_t svldnt1uh_gather_index_s64(svbool_t, uint16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32offset_u32)))
-svuint32_t svldnt1uh_gather_offset_u32(svbool_t, uint16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32offset_s32)))
-svint32_t svldnt1uh_gather_offset_s32(svbool_t, uint16_t const *, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64offset_u64)))
-svuint64_t svldnt1uh_gather_offset_u64(svbool_t, uint16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64offset_s64)))
-svint64_t svldnt1uh_gather_offset_s64(svbool_t, uint16_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64offset_u64)))
-svuint64_t svldnt1uh_gather_offset_u64(svbool_t, uint16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64offset_s64)))
-svint64_t svldnt1uh_gather_offset_s64(svbool_t, uint16_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_index_u64)))
-svuint64_t svldnt1uw_gather_index_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_index_s64)))
-svint64_t svldnt1uw_gather_index_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_offset_u64)))
-svuint64_t svldnt1uw_gather_offset_u64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_offset_s64)))
-svint64_t svldnt1uw_gather_offset_s64(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_u64)))
-svuint64_t svldnt1uw_gather_u64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_s64)))
-svint64_t svldnt1uw_gather_s64(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64index_u64)))
-svuint64_t svldnt1uw_gather_index_u64(svbool_t, uint32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64index_s64)))
-svint64_t svldnt1uw_gather_index_s64(svbool_t, uint32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64index_u64)))
-svuint64_t svldnt1uw_gather_index_u64(svbool_t, uint32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64index_s64)))
-svint64_t svldnt1uw_gather_index_s64(svbool_t, uint32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64offset_u64)))
-svuint64_t svldnt1uw_gather_offset_u64(svbool_t, uint32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64offset_s64)))
-svint64_t svldnt1uw_gather_offset_s64(svbool_t, uint32_t const *, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64offset_u64)))
-svuint64_t svldnt1uw_gather_offset_u64(svbool_t, uint32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64offset_s64)))
-svint64_t svldnt1uw_gather_offset_s64(svbool_t, uint32_t const *, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f64_m)))
-svint64_t svlogb_m(svint64_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f32_m)))
-svint32_t svlogb_m(svint32_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f16_m)))
-svint16_t svlogb_m(svint16_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f64_x)))
-svint64_t svlogb_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f32_x)))
-svint32_t svlogb_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f16_x)))
-svint16_t svlogb_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f64_z)))
-svint64_t svlogb_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f32_z)))
-svint32_t svlogb_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f16_z)))
-svint16_t svlogb_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_u8)))
-svbool_t svmatch(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_u16)))
-svbool_t svmatch(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_s8)))
-svbool_t svmatch(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_s16)))
-svbool_t svmatch(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f64_m)))
-svfloat64_t svmaxnmp_m(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f32_m)))
-svfloat32_t svmaxnmp_m(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f16_m)))
-svfloat16_t svmaxnmp_m(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f64_x)))
-svfloat64_t svmaxnmp_x(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f32_x)))
-svfloat32_t svmaxnmp_x(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f16_x)))
-svfloat16_t svmaxnmp_x(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f64_m)))
-svfloat64_t svmaxp_m(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f32_m)))
-svfloat32_t svmaxp_m(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f16_m)))
-svfloat16_t svmaxp_m(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f64_x)))
-svfloat64_t svmaxp_x(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f32_x)))
-svfloat32_t svmaxp_x(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f16_x)))
-svfloat16_t svmaxp_x(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s8_m)))
-svint8_t svmaxp_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s32_m)))
-svint32_t svmaxp_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s64_m)))
-svint64_t svmaxp_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s16_m)))
-svint16_t svmaxp_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s8_x)))
-svint8_t svmaxp_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s32_x)))
-svint32_t svmaxp_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s64_x)))
-svint64_t svmaxp_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s16_x)))
-svint16_t svmaxp_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u8_m)))
-svuint8_t svmaxp_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u32_m)))
-svuint32_t svmaxp_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u64_m)))
-svuint64_t svmaxp_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u16_m)))
-svuint16_t svmaxp_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u8_x)))
-svuint8_t svmaxp_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u32_x)))
-svuint32_t svmaxp_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u64_x)))
-svuint64_t svmaxp_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u16_x)))
-svuint16_t svmaxp_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f64_m)))
-svfloat64_t svminnmp_m(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f32_m)))
-svfloat32_t svminnmp_m(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f16_m)))
-svfloat16_t svminnmp_m(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f64_x)))
-svfloat64_t svminnmp_x(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f32_x)))
-svfloat32_t svminnmp_x(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f16_x)))
-svfloat16_t svminnmp_x(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f64_m)))
-svfloat64_t svminp_m(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f32_m)))
-svfloat32_t svminp_m(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f16_m)))
-svfloat16_t svminp_m(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f64_x)))
-svfloat64_t svminp_x(svbool_t, svfloat64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f32_x)))
-svfloat32_t svminp_x(svbool_t, svfloat32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f16_x)))
-svfloat16_t svminp_x(svbool_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s8_m)))
-svint8_t svminp_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s32_m)))
-svint32_t svminp_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s64_m)))
-svint64_t svminp_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s16_m)))
-svint16_t svminp_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s8_x)))
-svint8_t svminp_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s32_x)))
-svint32_t svminp_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s64_x)))
-svint64_t svminp_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s16_x)))
-svint16_t svminp_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u8_m)))
-svuint8_t svminp_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u32_m)))
-svuint32_t svminp_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u64_m)))
-svuint64_t svminp_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u16_m)))
-svuint16_t svminp_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u8_x)))
-svuint8_t svminp_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u32_x)))
-svuint32_t svminp_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u64_x)))
-svuint64_t svminp_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u16_x)))
-svuint16_t svminp_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_u32)))
-svuint32_t svmla_lane(svuint32_t, svuint32_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_u64)))
-svuint64_t svmla_lane(svuint64_t, svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_u16)))
-svuint16_t svmla_lane(svuint16_t, svuint16_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_s32)))
-svint32_t svmla_lane(svint32_t, svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_s64)))
-svint64_t svmla_lane(svint64_t, svint64_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_s16)))
-svint16_t svmla_lane(svint16_t, svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_f32)))
-svfloat32_t svmlalb(svfloat32_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_s32)))
-svint32_t svmlalb(svint32_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_s64)))
-svint64_t svmlalb(svint64_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_s16)))
-svint16_t svmlalb(svint16_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_u32)))
-svuint32_t svmlalb(svuint32_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_u64)))
-svuint64_t svmlalb(svuint64_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_u16)))
-svuint16_t svmlalb(svuint16_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_f32)))
-svfloat32_t svmlalb(svfloat32_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_s32)))
-svint32_t svmlalb(svint32_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_s64)))
-svint64_t svmlalb(svint64_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_s16)))
-svint16_t svmlalb(svint16_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_u32)))
-svuint32_t svmlalb(svuint32_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_u64)))
-svuint64_t svmlalb(svuint64_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_u16)))
-svuint16_t svmlalb(svuint16_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_f32)))
-svfloat32_t svmlalb_lane(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_s32)))
-svint32_t svmlalb_lane(svint32_t, svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_s64)))
-svint64_t svmlalb_lane(svint64_t, svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_u32)))
-svuint32_t svmlalb_lane(svuint32_t, svuint16_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_u64)))
-svuint64_t svmlalb_lane(svuint64_t, svuint32_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_f32)))
-svfloat32_t svmlalt(svfloat32_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_s32)))
-svint32_t svmlalt(svint32_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_s64)))
-svint64_t svmlalt(svint64_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_s16)))
-svint16_t svmlalt(svint16_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_u32)))
-svuint32_t svmlalt(svuint32_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_u64)))
-svuint64_t svmlalt(svuint64_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_u16)))
-svuint16_t svmlalt(svuint16_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_f32)))
-svfloat32_t svmlalt(svfloat32_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_s32)))
-svint32_t svmlalt(svint32_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_s64)))
-svint64_t svmlalt(svint64_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_s16)))
-svint16_t svmlalt(svint16_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_u32)))
-svuint32_t svmlalt(svuint32_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_u64)))
-svuint64_t svmlalt(svuint64_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_u16)))
-svuint16_t svmlalt(svuint16_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_f32)))
-svfloat32_t svmlalt_lane(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_s32)))
-svint32_t svmlalt_lane(svint32_t, svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_s64)))
-svint64_t svmlalt_lane(svint64_t, svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_u32)))
-svuint32_t svmlalt_lane(svuint32_t, svuint16_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_u64)))
-svuint64_t svmlalt_lane(svuint64_t, svuint32_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_u32)))
-svuint32_t svmls_lane(svuint32_t, svuint32_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_u64)))
-svuint64_t svmls_lane(svuint64_t, svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_u16)))
-svuint16_t svmls_lane(svuint16_t, svuint16_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_s32)))
-svint32_t svmls_lane(svint32_t, svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_s64)))
-svint64_t svmls_lane(svint64_t, svint64_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_s16)))
-svint16_t svmls_lane(svint16_t, svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_f32)))
-svfloat32_t svmlslb(svfloat32_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_s32)))
-svint32_t svmlslb(svint32_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_s64)))
-svint64_t svmlslb(svint64_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_s16)))
-svint16_t svmlslb(svint16_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_u32)))
-svuint32_t svmlslb(svuint32_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_u64)))
-svuint64_t svmlslb(svuint64_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_u16)))
-svuint16_t svmlslb(svuint16_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_f32)))
-svfloat32_t svmlslb(svfloat32_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_s32)))
-svint32_t svmlslb(svint32_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_s64)))
-svint64_t svmlslb(svint64_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_s16)))
-svint16_t svmlslb(svint16_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_u32)))
-svuint32_t svmlslb(svuint32_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_u64)))
-svuint64_t svmlslb(svuint64_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_u16)))
-svuint16_t svmlslb(svuint16_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_f32)))
-svfloat32_t svmlslb_lane(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_s32)))
-svint32_t svmlslb_lane(svint32_t, svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_s64)))
-svint64_t svmlslb_lane(svint64_t, svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_u32)))
-svuint32_t svmlslb_lane(svuint32_t, svuint16_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_u64)))
-svuint64_t svmlslb_lane(svuint64_t, svuint32_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_f32)))
-svfloat32_t svmlslt(svfloat32_t, svfloat16_t, float16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_s32)))
-svint32_t svmlslt(svint32_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_s64)))
-svint64_t svmlslt(svint64_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_s16)))
-svint16_t svmlslt(svint16_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_u32)))
-svuint32_t svmlslt(svuint32_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_u64)))
-svuint64_t svmlslt(svuint64_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_u16)))
-svuint16_t svmlslt(svuint16_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_f32)))
-svfloat32_t svmlslt(svfloat32_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_s32)))
-svint32_t svmlslt(svint32_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_s64)))
-svint64_t svmlslt(svint64_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_s16)))
-svint16_t svmlslt(svint16_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_u32)))
-svuint32_t svmlslt(svuint32_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_u64)))
-svuint64_t svmlslt(svuint64_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_u16)))
-svuint16_t svmlslt(svuint16_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_f32)))
-svfloat32_t svmlslt_lane(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_s32)))
-svint32_t svmlslt_lane(svint32_t, svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_s64)))
-svint64_t svmlslt_lane(svint64_t, svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_u32)))
-svuint32_t svmlslt_lane(svuint32_t, svuint16_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_u64)))
-svuint64_t svmlslt_lane(svuint64_t, svuint32_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_s32)))
-svint32_t svmovlb(svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_s64)))
-svint64_t svmovlb(svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_s16)))
-svint16_t svmovlb(svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_u32)))
-svuint32_t svmovlb(svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_u64)))
-svuint64_t svmovlb(svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_u16)))
-svuint16_t svmovlb(svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_s32)))
-svint32_t svmovlt(svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_s64)))
-svint64_t svmovlt(svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_s16)))
-svint16_t svmovlt(svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_u32)))
-svuint32_t svmovlt(svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_u64)))
-svuint64_t svmovlt(svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_u16)))
-svuint16_t svmovlt(svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_u32)))
-svuint32_t svmul_lane(svuint32_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_u64)))
-svuint64_t svmul_lane(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_u16)))
-svuint16_t svmul_lane(svuint16_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_s32)))
-svint32_t svmul_lane(svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_s64)))
-svint64_t svmul_lane(svint64_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_s16)))
-svint16_t svmul_lane(svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_s32)))
-svint32_t svmullb(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_s64)))
-svint64_t svmullb(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_s16)))
-svint16_t svmullb(svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_u32)))
-svuint32_t svmullb(svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_u64)))
-svuint64_t svmullb(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_u16)))
-svuint16_t svmullb(svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_s32)))
-svint32_t svmullb(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_s64)))
-svint64_t svmullb(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_s16)))
-svint16_t svmullb(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_u32)))
-svuint32_t svmullb(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_u64)))
-svuint64_t svmullb(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_u16)))
-svuint16_t svmullb(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_s32)))
-svint32_t svmullb_lane(svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_s64)))
-svint64_t svmullb_lane(svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_u32)))
-svuint32_t svmullb_lane(svuint16_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_u64)))
-svuint64_t svmullb_lane(svuint32_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_s32)))
-svint32_t svmullt(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_s64)))
-svint64_t svmullt(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_s16)))
-svint16_t svmullt(svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_u32)))
-svuint32_t svmullt(svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_u64)))
-svuint64_t svmullt(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_u16)))
-svuint16_t svmullt(svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_s32)))
-svint32_t svmullt(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_s64)))
-svint64_t svmullt(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_s16)))
-svint16_t svmullt(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_u32)))
-svuint32_t svmullt(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_u64)))
-svuint64_t svmullt(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_u16)))
-svuint16_t svmullt(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_s32)))
-svint32_t svmullt_lane(svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_s64)))
-svint64_t svmullt_lane(svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_u32)))
-svuint32_t svmullt_lane(svuint16_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_u64)))
-svuint64_t svmullt_lane(svuint32_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u8)))
-svuint8_t svnbsl(svuint8_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u32)))
-svuint32_t svnbsl(svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u64)))
-svuint64_t svnbsl(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u16)))
-svuint16_t svnbsl(svuint16_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s8)))
-svint8_t svnbsl(svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s32)))
-svint32_t svnbsl(svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s64)))
-svint64_t svnbsl(svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s16)))
-svint16_t svnbsl(svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u8)))
-svuint8_t svnbsl(svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u32)))
-svuint32_t svnbsl(svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u64)))
-svuint64_t svnbsl(svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u16)))
-svuint16_t svnbsl(svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s8)))
-svint8_t svnbsl(svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s32)))
-svint32_t svnbsl(svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s64)))
-svint64_t svnbsl(svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s16)))
-svint16_t svnbsl(svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_u8)))
-svbool_t svnmatch(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_u16)))
-svbool_t svnmatch(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_s8)))
-svbool_t svnmatch(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_s16)))
-svbool_t svnmatch(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmul_n_u8)))
-svuint8_t svpmul(svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmul_u8)))
-svuint8_t svpmul(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_n_u64)))
-svuint64_t svpmullb(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_n_u16)))
-svuint16_t svpmullb(svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_u64)))
-svuint64_t svpmullb(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_u16)))
-svuint16_t svpmullb(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_n_u8)))
-svuint8_t svpmullb_pair(svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_n_u32)))
-svuint32_t svpmullb_pair(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_u8)))
-svuint8_t svpmullb_pair(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_u32)))
-svuint32_t svpmullb_pair(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_n_u64)))
-svuint64_t svpmullt(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_n_u16)))
-svuint16_t svpmullt(svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_u64)))
-svuint64_t svpmullt(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_u16)))
-svuint16_t svpmullt(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_n_u8)))
-svuint8_t svpmullt_pair(svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_n_u32)))
-svuint32_t svpmullt_pair(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_u8)))
-svuint8_t svpmullt_pair(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_u32)))
-svuint32_t svpmullt_pair(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s8_m)))
-svint8_t svqabs_m(svint8_t, svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s32_m)))
-svint32_t svqabs_m(svint32_t, svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s64_m)))
-svint64_t svqabs_m(svint64_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s16_m)))
-svint16_t svqabs_m(svint16_t, svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s8_x)))
-svint8_t svqabs_x(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s32_x)))
-svint32_t svqabs_x(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s64_x)))
-svint64_t svqabs_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s16_x)))
-svint16_t svqabs_x(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s8_z)))
-svint8_t svqabs_z(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s32_z)))
-svint32_t svqabs_z(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s64_z)))
-svint64_t svqabs_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s16_z)))
-svint16_t svqabs_z(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8_m)))
-svint8_t svqadd_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32_m)))
-svint32_t svqadd_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64_m)))
-svint64_t svqadd_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16_m)))
-svint16_t svqadd_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8_x)))
-svint8_t svqadd_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32_x)))
-svint32_t svqadd_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64_x)))
-svint64_t svqadd_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16_x)))
-svint16_t svqadd_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8_z)))
-svint8_t svqadd_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32_z)))
-svint32_t svqadd_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64_z)))
-svint64_t svqadd_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16_z)))
-svint16_t svqadd_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8_m)))
-svuint8_t svqadd_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32_m)))
-svuint32_t svqadd_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64_m)))
-svuint64_t svqadd_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16_m)))
-svuint16_t svqadd_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8_x)))
-svuint8_t svqadd_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32_x)))
-svuint32_t svqadd_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64_x)))
-svuint64_t svqadd_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16_x)))
-svuint16_t svqadd_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8_z)))
-svuint8_t svqadd_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32_z)))
-svuint32_t svqadd_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64_z)))
-svuint64_t svqadd_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16_z)))
-svuint16_t svqadd_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8_m)))
-svint8_t svqadd_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32_m)))
-svint32_t svqadd_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64_m)))
-svint64_t svqadd_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16_m)))
-svint16_t svqadd_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8_x)))
-svint8_t svqadd_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32_x)))
-svint32_t svqadd_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64_x)))
-svint64_t svqadd_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16_x)))
-svint16_t svqadd_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8_z)))
-svint8_t svqadd_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32_z)))
-svint32_t svqadd_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64_z)))
-svint64_t svqadd_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16_z)))
-svint16_t svqadd_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8_m)))
-svuint8_t svqadd_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32_m)))
-svuint32_t svqadd_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64_m)))
-svuint64_t svqadd_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16_m)))
-svuint16_t svqadd_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8_x)))
-svuint8_t svqadd_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32_x)))
-svuint32_t svqadd_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64_x)))
-svuint64_t svqadd_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16_x)))
-svuint16_t svqadd_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8_z)))
-svuint8_t svqadd_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32_z)))
-svuint32_t svqadd_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64_z)))
-svuint64_t svqadd_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16_z)))
-svuint16_t svqadd_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s8)))
-svint8_t svqcadd(svint8_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s32)))
-svint32_t svqcadd(svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s64)))
-svint64_t svqcadd(svint64_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s16)))
-svint16_t svqcadd(svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_n_s32)))
-svint32_t svqdmlalb(svint32_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_n_s64)))
-svint64_t svqdmlalb(svint64_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_n_s16)))
-svint16_t svqdmlalb(svint16_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_s32)))
-svint32_t svqdmlalb(svint32_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_s64)))
-svint64_t svqdmlalb(svint64_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_s16)))
-svint16_t svqdmlalb(svint16_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_lane_s32)))
-svint32_t svqdmlalb_lane(svint32_t, svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_lane_s64)))
-svint64_t svqdmlalb_lane(svint64_t, svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_n_s32)))
-svint32_t svqdmlalbt(svint32_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_n_s64)))
-svint64_t svqdmlalbt(svint64_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_n_s16)))
-svint16_t svqdmlalbt(svint16_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_s32)))
-svint32_t svqdmlalbt(svint32_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_s64)))
-svint64_t svqdmlalbt(svint64_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_s16)))
-svint16_t svqdmlalbt(svint16_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_n_s32)))
-svint32_t svqdmlalt(svint32_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_n_s64)))
-svint64_t svqdmlalt(svint64_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_n_s16)))
-svint16_t svqdmlalt(svint16_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_s32)))
-svint32_t svqdmlalt(svint32_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_s64)))
-svint64_t svqdmlalt(svint64_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_s16)))
-svint16_t svqdmlalt(svint16_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_lane_s32)))
-svint32_t svqdmlalt_lane(svint32_t, svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_lane_s64)))
-svint64_t svqdmlalt_lane(svint64_t, svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_n_s32)))
-svint32_t svqdmlslb(svint32_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_n_s64)))
-svint64_t svqdmlslb(svint64_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_n_s16)))
-svint16_t svqdmlslb(svint16_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_s32)))
-svint32_t svqdmlslb(svint32_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_s64)))
-svint64_t svqdmlslb(svint64_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_s16)))
-svint16_t svqdmlslb(svint16_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_lane_s32)))
-svint32_t svqdmlslb_lane(svint32_t, svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_lane_s64)))
-svint64_t svqdmlslb_lane(svint64_t, svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_n_s32)))
-svint32_t svqdmlslbt(svint32_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_n_s64)))
-svint64_t svqdmlslbt(svint64_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_n_s16)))
-svint16_t svqdmlslbt(svint16_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_s32)))
-svint32_t svqdmlslbt(svint32_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_s64)))
-svint64_t svqdmlslbt(svint64_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_s16)))
-svint16_t svqdmlslbt(svint16_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_n_s32)))
-svint32_t svqdmlslt(svint32_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_n_s64)))
-svint64_t svqdmlslt(svint64_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_n_s16)))
-svint16_t svqdmlslt(svint16_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_s32)))
-svint32_t svqdmlslt(svint32_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_s64)))
-svint64_t svqdmlslt(svint64_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_s16)))
-svint16_t svqdmlslt(svint16_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_lane_s32)))
-svint32_t svqdmlslt_lane(svint32_t, svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_lane_s64)))
-svint64_t svqdmlslt_lane(svint64_t, svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s8)))
-svint8_t svqdmulh(svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s32)))
-svint32_t svqdmulh(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s64)))
-svint64_t svqdmulh(svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s16)))
-svint16_t svqdmulh(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s8)))
-svint8_t svqdmulh(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s32)))
-svint32_t svqdmulh(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s64)))
-svint64_t svqdmulh(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s16)))
-svint16_t svqdmulh(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_lane_s32)))
-svint32_t svqdmulh_lane(svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_lane_s64)))
-svint64_t svqdmulh_lane(svint64_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_lane_s16)))
-svint16_t svqdmulh_lane(svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_n_s32)))
-svint32_t svqdmullb(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_n_s64)))
-svint64_t svqdmullb(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_n_s16)))
-svint16_t svqdmullb(svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_s32)))
-svint32_t svqdmullb(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_s64)))
-svint64_t svqdmullb(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_s16)))
-svint16_t svqdmullb(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_lane_s32)))
-svint32_t svqdmullb_lane(svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_lane_s64)))
-svint64_t svqdmullb_lane(svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_n_s32)))
-svint32_t svqdmullt(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_n_s64)))
-svint64_t svqdmullt(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_n_s16)))
-svint16_t svqdmullt(svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_s32)))
-svint32_t svqdmullt(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_s64)))
-svint64_t svqdmullt(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_s16)))
-svint16_t svqdmullt(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_lane_s32)))
-svint32_t svqdmullt_lane(svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_lane_s64)))
-svint64_t svqdmullt_lane(svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s8_m)))
-svint8_t svqneg_m(svint8_t, svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s32_m)))
-svint32_t svqneg_m(svint32_t, svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s64_m)))
-svint64_t svqneg_m(svint64_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s16_m)))
-svint16_t svqneg_m(svint16_t, svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s8_x)))
-svint8_t svqneg_x(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s32_x)))
-svint32_t svqneg_x(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s64_x)))
-svint64_t svqneg_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s16_x)))
-svint16_t svqneg_x(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s8_z)))
-svint8_t svqneg_z(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s32_z)))
-svint32_t svqneg_z(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s64_z)))
-svint64_t svqneg_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s16_z)))
-svint16_t svqneg_z(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s8)))
-svint8_t svqrdcmlah(svint8_t, svint8_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s32)))
-svint32_t svqrdcmlah(svint32_t, svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s64)))
-svint64_t svqrdcmlah(svint64_t, svint64_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s16)))
-svint16_t svqrdcmlah(svint16_t, svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_lane_s32)))
-svint32_t svqrdcmlah_lane(svint32_t, svint32_t, svint32_t, uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_lane_s16)))
-svint16_t svqrdcmlah_lane(svint16_t, svint16_t, svint16_t, uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s8)))
-svint8_t svqrdmlah(svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s32)))
-svint32_t svqrdmlah(svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s64)))
-svint64_t svqrdmlah(svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s16)))
-svint16_t svqrdmlah(svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s8)))
-svint8_t svqrdmlah(svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s32)))
-svint32_t svqrdmlah(svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s64)))
-svint64_t svqrdmlah(svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s16)))
-svint16_t svqrdmlah(svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_lane_s32)))
-svint32_t svqrdmlah_lane(svint32_t, svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_lane_s64)))
-svint64_t svqrdmlah_lane(svint64_t, svint64_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_lane_s16)))
-svint16_t svqrdmlah_lane(svint16_t, svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s8)))
-svint8_t svqrdmlsh(svint8_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s32)))
-svint32_t svqrdmlsh(svint32_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s64)))
-svint64_t svqrdmlsh(svint64_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s16)))
-svint16_t svqrdmlsh(svint16_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s8)))
-svint8_t svqrdmlsh(svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s32)))
-svint32_t svqrdmlsh(svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s64)))
-svint64_t svqrdmlsh(svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s16)))
-svint16_t svqrdmlsh(svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_lane_s32)))
-svint32_t svqrdmlsh_lane(svint32_t, svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_lane_s64)))
-svint64_t svqrdmlsh_lane(svint64_t, svint64_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_lane_s16)))
-svint16_t svqrdmlsh_lane(svint16_t, svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s8)))
-svint8_t svqrdmulh(svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s32)))
-svint32_t svqrdmulh(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s64)))
-svint64_t svqrdmulh(svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s16)))
-svint16_t svqrdmulh(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s8)))
-svint8_t svqrdmulh(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s32)))
-svint32_t svqrdmulh(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s64)))
-svint64_t svqrdmulh(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s16)))
-svint16_t svqrdmulh(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_lane_s32)))
-svint32_t svqrdmulh_lane(svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_lane_s64)))
-svint64_t svqrdmulh_lane(svint64_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_lane_s16)))
-svint16_t svqrdmulh_lane(svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s8_m)))
-svint8_t svqrshl_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s32_m)))
-svint32_t svqrshl_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s64_m)))
-svint64_t svqrshl_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s16_m)))
-svint16_t svqrshl_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s8_x)))
-svint8_t svqrshl_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s32_x)))
-svint32_t svqrshl_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s64_x)))
-svint64_t svqrshl_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s16_x)))
-svint16_t svqrshl_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s8_z)))
-svint8_t svqrshl_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s32_z)))
-svint32_t svqrshl_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s64_z)))
-svint64_t svqrshl_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s16_z)))
-svint16_t svqrshl_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u8_m)))
-svuint8_t svqrshl_m(svbool_t, svuint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u32_m)))
-svuint32_t svqrshl_m(svbool_t, svuint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u64_m)))
-svuint64_t svqrshl_m(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u16_m)))
-svuint16_t svqrshl_m(svbool_t, svuint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u8_x)))
-svuint8_t svqrshl_x(svbool_t, svuint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u32_x)))
-svuint32_t svqrshl_x(svbool_t, svuint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u64_x)))
-svuint64_t svqrshl_x(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u16_x)))
-svuint16_t svqrshl_x(svbool_t, svuint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u8_z)))
-svuint8_t svqrshl_z(svbool_t, svuint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u32_z)))
-svuint32_t svqrshl_z(svbool_t, svuint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u64_z)))
-svuint64_t svqrshl_z(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u16_z)))
-svuint16_t svqrshl_z(svbool_t, svuint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s8_m)))
-svint8_t svqrshl_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s32_m)))
-svint32_t svqrshl_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s64_m)))
-svint64_t svqrshl_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s16_m)))
-svint16_t svqrshl_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s8_x)))
-svint8_t svqrshl_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s32_x)))
-svint32_t svqrshl_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s64_x)))
-svint64_t svqrshl_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s16_x)))
-svint16_t svqrshl_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s8_z)))
-svint8_t svqrshl_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s32_z)))
-svint32_t svqrshl_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s64_z)))
-svint64_t svqrshl_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s16_z)))
-svint16_t svqrshl_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u8_m)))
-svuint8_t svqrshl_m(svbool_t, svuint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u32_m)))
-svuint32_t svqrshl_m(svbool_t, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u64_m)))
-svuint64_t svqrshl_m(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u16_m)))
-svuint16_t svqrshl_m(svbool_t, svuint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u8_x)))
-svuint8_t svqrshl_x(svbool_t, svuint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u32_x)))
-svuint32_t svqrshl_x(svbool_t, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u64_x)))
-svuint64_t svqrshl_x(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u16_x)))
-svuint16_t svqrshl_x(svbool_t, svuint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u8_z)))
-svuint8_t svqrshl_z(svbool_t, svuint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u32_z)))
-svuint32_t svqrshl_z(svbool_t, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u64_z)))
-svuint64_t svqrshl_z(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u16_z)))
-svuint16_t svqrshl_z(svbool_t, svuint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_s32)))
-svint16_t svqrshrnb(svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_s64)))
-svint32_t svqrshrnb(svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_s16)))
-svint8_t svqrshrnb(svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_u32)))
-svuint16_t svqrshrnb(svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_u64)))
-svuint32_t svqrshrnb(svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_u16)))
-svuint8_t svqrshrnb(svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_s32)))
-svint16_t svqrshrnt(svint16_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_s64)))
-svint32_t svqrshrnt(svint32_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_s16)))
-svint8_t svqrshrnt(svint8_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_u32)))
-svuint16_t svqrshrnt(svuint16_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_u64)))
-svuint32_t svqrshrnt(svuint32_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_u16)))
-svuint8_t svqrshrnt(svuint8_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunb_n_s32)))
-svuint16_t svqrshrunb(svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunb_n_s64)))
-svuint32_t svqrshrunb(svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunb_n_s16)))
-svuint8_t svqrshrunb(svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunt_n_s32)))
-svuint16_t svqrshrunt(svuint16_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunt_n_s64)))
-svuint32_t svqrshrunt(svuint32_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunt_n_s16)))
-svuint8_t svqrshrunt(svuint8_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s8_m)))
-svint8_t svqshl_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s32_m)))
-svint32_t svqshl_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s64_m)))
-svint64_t svqshl_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s16_m)))
-svint16_t svqshl_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s8_x)))
-svint8_t svqshl_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s32_x)))
-svint32_t svqshl_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s64_x)))
-svint64_t svqshl_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s16_x)))
-svint16_t svqshl_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s8_z)))
-svint8_t svqshl_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s32_z)))
-svint32_t svqshl_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s64_z)))
-svint64_t svqshl_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s16_z)))
-svint16_t svqshl_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u8_m)))
-svuint8_t svqshl_m(svbool_t, svuint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u32_m)))
-svuint32_t svqshl_m(svbool_t, svuint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u64_m)))
-svuint64_t svqshl_m(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u16_m)))
-svuint16_t svqshl_m(svbool_t, svuint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u8_x)))
-svuint8_t svqshl_x(svbool_t, svuint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u32_x)))
-svuint32_t svqshl_x(svbool_t, svuint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u64_x)))
-svuint64_t svqshl_x(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u16_x)))
-svuint16_t svqshl_x(svbool_t, svuint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u8_z)))
-svuint8_t svqshl_z(svbool_t, svuint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u32_z)))
-svuint32_t svqshl_z(svbool_t, svuint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u64_z)))
-svuint64_t svqshl_z(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u16_z)))
-svuint16_t svqshl_z(svbool_t, svuint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s8_m)))
-svint8_t svqshl_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s32_m)))
-svint32_t svqshl_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s64_m)))
-svint64_t svqshl_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s16_m)))
-svint16_t svqshl_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s8_x)))
-svint8_t svqshl_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s32_x)))
-svint32_t svqshl_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s64_x)))
-svint64_t svqshl_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s16_x)))
-svint16_t svqshl_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s8_z)))
-svint8_t svqshl_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s32_z)))
-svint32_t svqshl_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s64_z)))
-svint64_t svqshl_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s16_z)))
-svint16_t svqshl_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u8_m)))
-svuint8_t svqshl_m(svbool_t, svuint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u32_m)))
-svuint32_t svqshl_m(svbool_t, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u64_m)))
-svuint64_t svqshl_m(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u16_m)))
-svuint16_t svqshl_m(svbool_t, svuint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u8_x)))
-svuint8_t svqshl_x(svbool_t, svuint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u32_x)))
-svuint32_t svqshl_x(svbool_t, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u64_x)))
-svuint64_t svqshl_x(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u16_x)))
-svuint16_t svqshl_x(svbool_t, svuint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u8_z)))
-svuint8_t svqshl_z(svbool_t, svuint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u32_z)))
-svuint32_t svqshl_z(svbool_t, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u64_z)))
-svuint64_t svqshl_z(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u16_z)))
-svuint16_t svqshl_z(svbool_t, svuint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s8_m)))
-svuint8_t svqshlu_m(svbool_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s32_m)))
-svuint32_t svqshlu_m(svbool_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s64_m)))
-svuint64_t svqshlu_m(svbool_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s16_m)))
-svuint16_t svqshlu_m(svbool_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s8_x)))
-svuint8_t svqshlu_x(svbool_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s32_x)))
-svuint32_t svqshlu_x(svbool_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s64_x)))
-svuint64_t svqshlu_x(svbool_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s16_x)))
-svuint16_t svqshlu_x(svbool_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s8_z)))
-svuint8_t svqshlu_z(svbool_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s32_z)))
-svuint32_t svqshlu_z(svbool_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s64_z)))
-svuint64_t svqshlu_z(svbool_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s16_z)))
-svuint16_t svqshlu_z(svbool_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_s32)))
-svint16_t svqshrnb(svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_s64)))
-svint32_t svqshrnb(svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_s16)))
-svint8_t svqshrnb(svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_u32)))
-svuint16_t svqshrnb(svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_u64)))
-svuint32_t svqshrnb(svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_u16)))
-svuint8_t svqshrnb(svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_s32)))
-svint16_t svqshrnt(svint16_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_s64)))
-svint32_t svqshrnt(svint32_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_s16)))
-svint8_t svqshrnt(svint8_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_u32)))
-svuint16_t svqshrnt(svuint16_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_u64)))
-svuint32_t svqshrnt(svuint32_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_u16)))
-svuint8_t svqshrnt(svuint8_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunb_n_s32)))
-svuint16_t svqshrunb(svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunb_n_s64)))
-svuint32_t svqshrunb(svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunb_n_s16)))
-svuint8_t svqshrunb(svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunt_n_s32)))
-svuint16_t svqshrunt(svuint16_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunt_n_s64)))
-svuint32_t svqshrunt(svuint32_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunt_n_s16)))
-svuint8_t svqshrunt(svuint8_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8_m)))
-svint8_t svqsub_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32_m)))
-svint32_t svqsub_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64_m)))
-svint64_t svqsub_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16_m)))
-svint16_t svqsub_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8_x)))
-svint8_t svqsub_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32_x)))
-svint32_t svqsub_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64_x)))
-svint64_t svqsub_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16_x)))
-svint16_t svqsub_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8_z)))
-svint8_t svqsub_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32_z)))
-svint32_t svqsub_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64_z)))
-svint64_t svqsub_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16_z)))
-svint16_t svqsub_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8_m)))
-svuint8_t svqsub_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32_m)))
-svuint32_t svqsub_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64_m)))
-svuint64_t svqsub_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16_m)))
-svuint16_t svqsub_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8_x)))
-svuint8_t svqsub_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32_x)))
-svuint32_t svqsub_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64_x)))
-svuint64_t svqsub_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16_x)))
-svuint16_t svqsub_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8_z)))
-svuint8_t svqsub_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32_z)))
-svuint32_t svqsub_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64_z)))
-svuint64_t svqsub_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16_z)))
-svuint16_t svqsub_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8_m)))
-svint8_t svqsub_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32_m)))
-svint32_t svqsub_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64_m)))
-svint64_t svqsub_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16_m)))
-svint16_t svqsub_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8_x)))
-svint8_t svqsub_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32_x)))
-svint32_t svqsub_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64_x)))
-svint64_t svqsub_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16_x)))
-svint16_t svqsub_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8_z)))
-svint8_t svqsub_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32_z)))
-svint32_t svqsub_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64_z)))
-svint64_t svqsub_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16_z)))
-svint16_t svqsub_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8_m)))
-svuint8_t svqsub_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32_m)))
-svuint32_t svqsub_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64_m)))
-svuint64_t svqsub_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16_m)))
-svuint16_t svqsub_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8_x)))
-svuint8_t svqsub_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32_x)))
-svuint32_t svqsub_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64_x)))
-svuint64_t svqsub_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16_x)))
-svuint16_t svqsub_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8_z)))
-svuint8_t svqsub_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32_z)))
-svuint32_t svqsub_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64_z)))
-svuint64_t svqsub_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16_z)))
-svuint16_t svqsub_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s8_m)))
-svint8_t svqsubr_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s32_m)))
-svint32_t svqsubr_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s64_m)))
-svint64_t svqsubr_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s16_m)))
-svint16_t svqsubr_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s8_x)))
-svint8_t svqsubr_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s32_x)))
-svint32_t svqsubr_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s64_x)))
-svint64_t svqsubr_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s16_x)))
-svint16_t svqsubr_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s8_z)))
-svint8_t svqsubr_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s32_z)))
-svint32_t svqsubr_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s64_z)))
-svint64_t svqsubr_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s16_z)))
-svint16_t svqsubr_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u8_m)))
-svuint8_t svqsubr_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u32_m)))
-svuint32_t svqsubr_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u64_m)))
-svuint64_t svqsubr_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u16_m)))
-svuint16_t svqsubr_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u8_x)))
-svuint8_t svqsubr_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u32_x)))
-svuint32_t svqsubr_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u64_x)))
-svuint64_t svqsubr_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u16_x)))
-svuint16_t svqsubr_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u8_z)))
-svuint8_t svqsubr_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u32_z)))
-svuint32_t svqsubr_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u64_z)))
-svuint64_t svqsubr_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u16_z)))
-svuint16_t svqsubr_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s8_m)))
-svint8_t svqsubr_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s32_m)))
-svint32_t svqsubr_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s64_m)))
-svint64_t svqsubr_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s16_m)))
-svint16_t svqsubr_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s8_x)))
-svint8_t svqsubr_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s32_x)))
-svint32_t svqsubr_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s64_x)))
-svint64_t svqsubr_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s16_x)))
-svint16_t svqsubr_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s8_z)))
-svint8_t svqsubr_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s32_z)))
-svint32_t svqsubr_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s64_z)))
-svint64_t svqsubr_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s16_z)))
-svint16_t svqsubr_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u8_m)))
-svuint8_t svqsubr_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u32_m)))
-svuint32_t svqsubr_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u64_m)))
-svuint64_t svqsubr_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u16_m)))
-svuint16_t svqsubr_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u8_x)))
-svuint8_t svqsubr_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u32_x)))
-svuint32_t svqsubr_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u64_x)))
-svuint64_t svqsubr_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u16_x)))
-svuint16_t svqsubr_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u8_z)))
-svuint8_t svqsubr_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u32_z)))
-svuint32_t svqsubr_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u64_z)))
-svuint64_t svqsubr_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u16_z)))
-svuint16_t svqsubr_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_s32)))
-svint16_t svqxtnb(svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_s64)))
-svint32_t svqxtnb(svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_s16)))
-svint8_t svqxtnb(svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_u32)))
-svuint16_t svqxtnb(svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_u64)))
-svuint32_t svqxtnb(svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_u16)))
-svuint8_t svqxtnb(svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_s32)))
-svint16_t svqxtnt(svint16_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_s64)))
-svint32_t svqxtnt(svint32_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_s16)))
-svint8_t svqxtnt(svint8_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_u32)))
-svuint16_t svqxtnt(svuint16_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_u64)))
-svuint32_t svqxtnt(svuint32_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_u16)))
-svuint8_t svqxtnt(svuint8_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunb_s32)))
-svuint16_t svqxtunb(svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunb_s64)))
-svuint32_t svqxtunb(svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunb_s16)))
-svuint8_t svqxtunb(svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunt_s32)))
-svuint16_t svqxtunt(svuint16_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunt_s64)))
-svuint32_t svqxtunt(svuint32_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunt_s16)))
-svuint8_t svqxtunt(svuint8_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_u32)))
-svuint16_t svraddhnb(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_u64)))
-svuint32_t svraddhnb(svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_u16)))
-svuint8_t svraddhnb(svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_s32)))
-svint16_t svraddhnb(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_s64)))
-svint32_t svraddhnb(svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_s16)))
-svint8_t svraddhnb(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_u32)))
-svuint16_t svraddhnb(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_u64)))
-svuint32_t svraddhnb(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_u16)))
-svuint8_t svraddhnb(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_s32)))
-svint16_t svraddhnb(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_s64)))
-svint32_t svraddhnb(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_s16)))
-svint8_t svraddhnb(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_u32)))
-svuint16_t svraddhnt(svuint16_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_u64)))
-svuint32_t svraddhnt(svuint32_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_u16)))
-svuint8_t svraddhnt(svuint8_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_s32)))
-svint16_t svraddhnt(svint16_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_s64)))
-svint32_t svraddhnt(svint32_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_s16)))
-svint8_t svraddhnt(svint8_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_u32)))
-svuint16_t svraddhnt(svuint16_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_u64)))
-svuint32_t svraddhnt(svuint32_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_u16)))
-svuint8_t svraddhnt(svuint8_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_s32)))
-svint16_t svraddhnt(svint16_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_s64)))
-svint32_t svraddhnt(svint32_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_s16)))
-svint8_t svraddhnt(svint8_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_u32_m)))
-svuint32_t svrecpe_m(svuint32_t, svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_u32_x)))
-svuint32_t svrecpe_x(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_u32_z)))
-svuint32_t svrecpe_z(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s8_m)))
-svint8_t svrhadd_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s32_m)))
-svint32_t svrhadd_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s64_m)))
-svint64_t svrhadd_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s16_m)))
-svint16_t svrhadd_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s8_x)))
-svint8_t svrhadd_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s32_x)))
-svint32_t svrhadd_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s64_x)))
-svint64_t svrhadd_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s16_x)))
-svint16_t svrhadd_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s8_z)))
-svint8_t svrhadd_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s32_z)))
-svint32_t svrhadd_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s64_z)))
-svint64_t svrhadd_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s16_z)))
-svint16_t svrhadd_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u8_m)))
-svuint8_t svrhadd_m(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u32_m)))
-svuint32_t svrhadd_m(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u64_m)))
-svuint64_t svrhadd_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u16_m)))
-svuint16_t svrhadd_m(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u8_x)))
-svuint8_t svrhadd_x(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u32_x)))
-svuint32_t svrhadd_x(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u64_x)))
-svuint64_t svrhadd_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u16_x)))
-svuint16_t svrhadd_x(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u8_z)))
-svuint8_t svrhadd_z(svbool_t, svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u32_z)))
-svuint32_t svrhadd_z(svbool_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u64_z)))
-svuint64_t svrhadd_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u16_z)))
-svuint16_t svrhadd_z(svbool_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s8_m)))
-svint8_t svrhadd_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s32_m)))
-svint32_t svrhadd_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s64_m)))
-svint64_t svrhadd_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s16_m)))
-svint16_t svrhadd_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s8_x)))
-svint8_t svrhadd_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s32_x)))
-svint32_t svrhadd_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s64_x)))
-svint64_t svrhadd_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s16_x)))
-svint16_t svrhadd_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s8_z)))
-svint8_t svrhadd_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s32_z)))
-svint32_t svrhadd_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s64_z)))
-svint64_t svrhadd_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s16_z)))
-svint16_t svrhadd_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u8_m)))
-svuint8_t svrhadd_m(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u32_m)))
-svuint32_t svrhadd_m(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u64_m)))
-svuint64_t svrhadd_m(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u16_m)))
-svuint16_t svrhadd_m(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u8_x)))
-svuint8_t svrhadd_x(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u32_x)))
-svuint32_t svrhadd_x(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u64_x)))
-svuint64_t svrhadd_x(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u16_x)))
-svuint16_t svrhadd_x(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u8_z)))
-svuint8_t svrhadd_z(svbool_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u32_z)))
-svuint32_t svrhadd_z(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u64_z)))
-svuint64_t svrhadd_z(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u16_z)))
-svuint16_t svrhadd_z(svbool_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s8_m)))
-svint8_t svrshl_m(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s32_m)))
-svint32_t svrshl_m(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s64_m)))
-svint64_t svrshl_m(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s16_m)))
-svint16_t svrshl_m(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s8_x)))
-svint8_t svrshl_x(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s32_x)))
-svint32_t svrshl_x(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s64_x)))
-svint64_t svrshl_x(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s16_x)))
-svint16_t svrshl_x(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s8_z)))
-svint8_t svrshl_z(svbool_t, svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s32_z)))
-svint32_t svrshl_z(svbool_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s64_z)))
-svint64_t svrshl_z(svbool_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s16_z)))
-svint16_t svrshl_z(svbool_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u8_m)))
-svuint8_t svrshl_m(svbool_t, svuint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u32_m)))
-svuint32_t svrshl_m(svbool_t, svuint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u64_m)))
-svuint64_t svrshl_m(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u16_m)))
-svuint16_t svrshl_m(svbool_t, svuint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u8_x)))
-svuint8_t svrshl_x(svbool_t, svuint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u32_x)))
-svuint32_t svrshl_x(svbool_t, svuint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u64_x)))
-svuint64_t svrshl_x(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u16_x)))
-svuint16_t svrshl_x(svbool_t, svuint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u8_z)))
-svuint8_t svrshl_z(svbool_t, svuint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u32_z)))
-svuint32_t svrshl_z(svbool_t, svuint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u64_z)))
-svuint64_t svrshl_z(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u16_z)))
-svuint16_t svrshl_z(svbool_t, svuint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_m)))
-svint8_t svrshl_m(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_m)))
-svint32_t svrshl_m(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_m)))
-svint64_t svrshl_m(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_m)))
-svint16_t svrshl_m(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_x)))
-svint8_t svrshl_x(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_x)))
-svint32_t svrshl_x(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_x)))
-svint64_t svrshl_x(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_x)))
-svint16_t svrshl_x(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_z)))
-svint8_t svrshl_z(svbool_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_z)))
-svint32_t svrshl_z(svbool_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_z)))
-svint64_t svrshl_z(svbool_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_z)))
-svint16_t svrshl_z(svbool_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_m)))
-svuint8_t svrshl_m(svbool_t, svuint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_m)))
-svuint32_t svrshl_m(svbool_t, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_m)))
-svuint64_t svrshl_m(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_m)))
-svuint16_t svrshl_m(svbool_t, svuint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_x)))
-svuint8_t svrshl_x(svbool_t, svuint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_x)))
-svuint32_t svrshl_x(svbool_t, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_x)))
-svuint64_t svrshl_x(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_x)))
-svuint16_t svrshl_x(svbool_t, svuint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_z)))
-svuint8_t svrshl_z(svbool_t, svuint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_z)))
-svuint32_t svrshl_z(svbool_t, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_z)))
-svuint64_t svrshl_z(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_z)))
-svuint16_t svrshl_z(svbool_t, svuint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s8_m)))
-svint8_t svrshr_m(svbool_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s32_m)))
-svint32_t svrshr_m(svbool_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s64_m)))
-svint64_t svrshr_m(svbool_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s16_m)))
-svint16_t svrshr_m(svbool_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u8_m)))
-svuint8_t svrshr_m(svbool_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u32_m)))
-svuint32_t svrshr_m(svbool_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u64_m)))
-svuint64_t svrshr_m(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u16_m)))
-svuint16_t svrshr_m(svbool_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s8_x)))
-svint8_t svrshr_x(svbool_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s32_x)))
-svint32_t svrshr_x(svbool_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s64_x)))
-svint64_t svrshr_x(svbool_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s16_x)))
-svint16_t svrshr_x(svbool_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u8_x)))
-svuint8_t svrshr_x(svbool_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u32_x)))
-svuint32_t svrshr_x(svbool_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u64_x)))
-svuint64_t svrshr_x(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u16_x)))
-svuint16_t svrshr_x(svbool_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s8_z)))
-svint8_t svrshr_z(svbool_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s32_z)))
-svint32_t svrshr_z(svbool_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s64_z)))
-svint64_t svrshr_z(svbool_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s16_z)))
-svint16_t svrshr_z(svbool_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u8_z)))
-svuint8_t svrshr_z(svbool_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u32_z)))
-svuint32_t svrshr_z(svbool_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u64_z)))
-svuint64_t svrshr_z(svbool_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u16_z)))
-svuint16_t svrshr_z(svbool_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_u32)))
-svuint16_t svrshrnb(svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_u64)))
-svuint32_t svrshrnb(svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_u16)))
-svuint8_t svrshrnb(svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_s32)))
-svint16_t svrshrnb(svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_s64)))
-svint32_t svrshrnb(svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_s16)))
-svint8_t svrshrnb(svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_u32)))
-svuint16_t svrshrnt(svuint16_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_u64)))
-svuint32_t svrshrnt(svuint32_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_u16)))
-svuint8_t svrshrnt(svuint8_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_s32)))
-svint16_t svrshrnt(svint16_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_s64)))
-svint32_t svrshrnt(svint32_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_s16)))
-svint8_t svrshrnt(svint8_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_u32_m)))
-svuint32_t svrsqrte_m(svuint32_t, svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_u32_x)))
-svuint32_t svrsqrte_x(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_u32_z)))
-svuint32_t svrsqrte_z(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s8)))
-svint8_t svrsra(svint8_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s32)))
-svint32_t svrsra(svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s64)))
-svint64_t svrsra(svint64_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s16)))
-svint16_t svrsra(svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u8)))
-svuint8_t svrsra(svuint8_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u32)))
-svuint32_t svrsra(svuint32_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u64)))
-svuint64_t svrsra(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u16)))
-svuint16_t svrsra(svuint16_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_u32)))
-svuint16_t svrsubhnb(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_u64)))
-svuint32_t svrsubhnb(svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_u16)))
-svuint8_t svrsubhnb(svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_s32)))
-svint16_t svrsubhnb(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_s64)))
-svint32_t svrsubhnb(svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_s16)))
-svint8_t svrsubhnb(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_u32)))
-svuint16_t svrsubhnb(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_u64)))
-svuint32_t svrsubhnb(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_u16)))
-svuint8_t svrsubhnb(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_s32)))
-svint16_t svrsubhnb(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_s64)))
-svint32_t svrsubhnb(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_s16)))
-svint8_t svrsubhnb(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_u32)))
-svuint16_t svrsubhnt(svuint16_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_u64)))
-svuint32_t svrsubhnt(svuint32_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_u16)))
-svuint8_t svrsubhnt(svuint8_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_s32)))
-svint16_t svrsubhnt(svint16_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_s64)))
-svint32_t svrsubhnt(svint32_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_s16)))
-svint8_t svrsubhnt(svint8_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_u32)))
-svuint16_t svrsubhnt(svuint16_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_u64)))
-svuint32_t svrsubhnt(svuint32_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_u16)))
-svuint8_t svrsubhnt(svuint8_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_s32)))
-svint16_t svrsubhnt(svint16_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_s64)))
-svint32_t svrsubhnt(svint32_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_s16)))
-svint8_t svrsubhnt(svint8_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_n_u32)))
-svuint32_t svsbclb(svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_n_u64)))
-svuint64_t svsbclb(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_u32)))
-svuint32_t svsbclb(svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_u64)))
-svuint64_t svsbclb(svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_n_u32)))
-svuint32_t svsbclt(svuint32_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_n_u64)))
-svuint64_t svsbclt(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_u32)))
-svuint32_t svsbclt(svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_u64)))
-svuint64_t svsbclt(svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_s32)))
-svint32_t svshllb(svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_s64)))
-svint64_t svshllb(svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_s16)))
-svint16_t svshllb(svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_u32)))
-svuint32_t svshllb(svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_u64)))
-svuint64_t svshllb(svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_u16)))
-svuint16_t svshllb(svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_s32)))
-svint32_t svshllt(svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_s64)))
-svint64_t svshllt(svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_s16)))
-svint16_t svshllt(svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_u32)))
-svuint32_t svshllt(svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_u64)))
-svuint64_t svshllt(svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_u16)))
-svuint16_t svshllt(svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_u32)))
-svuint16_t svshrnb(svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_u64)))
-svuint32_t svshrnb(svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_u16)))
-svuint8_t svshrnb(svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_s32)))
-svint16_t svshrnb(svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_s64)))
-svint32_t svshrnb(svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_s16)))
-svint8_t svshrnb(svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_u32)))
-svuint16_t svshrnt(svuint16_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_u64)))
-svuint32_t svshrnt(svuint32_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_u16)))
-svuint8_t svshrnt(svuint8_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_s32)))
-svint16_t svshrnt(svint16_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_s64)))
-svint32_t svshrnt(svint32_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_s16)))
-svint8_t svshrnt(svint8_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u8)))
-svuint8_t svsli(svuint8_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u32)))
-svuint32_t svsli(svuint32_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u64)))
-svuint64_t svsli(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u16)))
-svuint16_t svsli(svuint16_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s8)))
-svint8_t svsli(svint8_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s32)))
-svint32_t svsli(svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s64)))
-svint64_t svsli(svint64_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s16)))
-svint16_t svsli(svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u8_m)))
-svuint8_t svsqadd_m(svbool_t, svuint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u32_m)))
-svuint32_t svsqadd_m(svbool_t, svuint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u64_m)))
-svuint64_t svsqadd_m(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u16_m)))
-svuint16_t svsqadd_m(svbool_t, svuint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u8_x)))
-svuint8_t svsqadd_x(svbool_t, svuint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u32_x)))
-svuint32_t svsqadd_x(svbool_t, svuint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u64_x)))
-svuint64_t svsqadd_x(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u16_x)))
-svuint16_t svsqadd_x(svbool_t, svuint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u8_z)))
-svuint8_t svsqadd_z(svbool_t, svuint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u32_z)))
-svuint32_t svsqadd_z(svbool_t, svuint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u64_z)))
-svuint64_t svsqadd_z(svbool_t, svuint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u16_z)))
-svuint16_t svsqadd_z(svbool_t, svuint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u8_m)))
-svuint8_t svsqadd_m(svbool_t, svuint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u32_m)))
-svuint32_t svsqadd_m(svbool_t, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u64_m)))
-svuint64_t svsqadd_m(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u16_m)))
-svuint16_t svsqadd_m(svbool_t, svuint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u8_x)))
-svuint8_t svsqadd_x(svbool_t, svuint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u32_x)))
-svuint32_t svsqadd_x(svbool_t, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u64_x)))
-svuint64_t svsqadd_x(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u16_x)))
-svuint16_t svsqadd_x(svbool_t, svuint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u8_z)))
-svuint8_t svsqadd_z(svbool_t, svuint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u32_z)))
-svuint32_t svsqadd_z(svbool_t, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u64_z)))
-svuint64_t svsqadd_z(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u16_z)))
-svuint16_t svsqadd_z(svbool_t, svuint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s8)))
-svint8_t svsra(svint8_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s32)))
-svint32_t svsra(svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s64)))
-svint64_t svsra(svint64_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s16)))
-svint16_t svsra(svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u8)))
-svuint8_t svsra(svuint8_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u32)))
-svuint32_t svsra(svuint32_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u64)))
-svuint64_t svsra(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u16)))
-svuint16_t svsra(svuint16_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u8)))
-svuint8_t svsri(svuint8_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u32)))
-svuint32_t svsri(svuint32_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u64)))
-svuint64_t svsri(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u16)))
-svuint16_t svsri(svuint16_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s8)))
-svint8_t svsri(svint8_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s32)))
-svint32_t svsri(svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s64)))
-svint64_t svsri(svint64_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s16)))
-svint16_t svsri(svint16_t, svint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_index_u32)))
-void svstnt1_scatter_index(svbool_t, svuint32_t, int64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_index_u64)))
-void svstnt1_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_index_f64)))
-void svstnt1_scatter_index(svbool_t, svuint64_t, int64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_index_f32)))
-void svstnt1_scatter_index(svbool_t, svuint32_t, int64_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_index_s32)))
-void svstnt1_scatter_index(svbool_t, svuint32_t, int64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_index_s64)))
-void svstnt1_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_offset_u32)))
-void svstnt1_scatter_offset(svbool_t, svuint32_t, int64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_offset_u64)))
-void svstnt1_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_offset_f64)))
-void svstnt1_scatter_offset(svbool_t, svuint64_t, int64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_offset_f32)))
-void svstnt1_scatter_offset(svbool_t, svuint32_t, int64_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_offset_s32)))
-void svstnt1_scatter_offset(svbool_t, svuint32_t, int64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_offset_s64)))
-void svstnt1_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_u32)))
-void svstnt1_scatter(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_u64)))
-void svstnt1_scatter(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_f64)))
-void svstnt1_scatter(svbool_t, svuint64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_f32)))
-void svstnt1_scatter(svbool_t, svuint32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_s32)))
-void svstnt1_scatter(svbool_t, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_s64)))
-void svstnt1_scatter(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64index_u64)))
-void svstnt1_scatter_index(svbool_t, uint64_t *, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64index_f64)))
-void svstnt1_scatter_index(svbool_t, float64_t *, svint64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64index_s64)))
-void svstnt1_scatter_index(svbool_t, int64_t *, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64index_u64)))
-void svstnt1_scatter_index(svbool_t, uint64_t *, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64index_f64)))
-void svstnt1_scatter_index(svbool_t, float64_t *, svuint64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64index_s64)))
-void svstnt1_scatter_index(svbool_t, int64_t *, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32offset_u32)))
-void svstnt1_scatter_offset(svbool_t, uint32_t *, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32offset_f32)))
-void svstnt1_scatter_offset(svbool_t, float32_t *, svuint32_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32offset_s32)))
-void svstnt1_scatter_offset(svbool_t, int32_t *, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64offset_u64)))
-void svstnt1_scatter_offset(svbool_t, uint64_t *, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64offset_f64)))
-void svstnt1_scatter_offset(svbool_t, float64_t *, svint64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64offset_s64)))
-void svstnt1_scatter_offset(svbool_t, int64_t *, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64offset_u64)))
-void svstnt1_scatter_offset(svbool_t, uint64_t *, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64offset_f64)))
-void svstnt1_scatter_offset(svbool_t, float64_t *, svuint64_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64offset_s64)))
-void svstnt1_scatter_offset(svbool_t, int64_t *, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_offset_u32)))
-void svstnt1b_scatter_offset(svbool_t, svuint32_t, int64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_offset_u64)))
-void svstnt1b_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_offset_s32)))
-void svstnt1b_scatter_offset(svbool_t, svuint32_t, int64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_offset_s64)))
-void svstnt1b_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_u32)))
-void svstnt1b_scatter(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_u64)))
-void svstnt1b_scatter(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_s32)))
-void svstnt1b_scatter(svbool_t, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_s64)))
-void svstnt1b_scatter(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32offset_s32)))
-void svstnt1b_scatter_offset(svbool_t, int8_t *, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32offset_u32)))
-void svstnt1b_scatter_offset(svbool_t, uint8_t *, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_s64offset_s64)))
-void svstnt1b_scatter_offset(svbool_t, int8_t *, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_s64offset_u64)))
-void svstnt1b_scatter_offset(svbool_t, uint8_t *, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64offset_s64)))
-void svstnt1b_scatter_offset(svbool_t, int8_t *, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64offset_u64)))
-void svstnt1b_scatter_offset(svbool_t, uint8_t *, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_index_u32)))
-void svstnt1h_scatter_index(svbool_t, svuint32_t, int64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_index_u64)))
-void svstnt1h_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_index_s32)))
-void svstnt1h_scatter_index(svbool_t, svuint32_t, int64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_index_s64)))
-void svstnt1h_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_offset_u32)))
-void svstnt1h_scatter_offset(svbool_t, svuint32_t, int64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_offset_u64)))
-void svstnt1h_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_offset_s32)))
-void svstnt1h_scatter_offset(svbool_t, svuint32_t, int64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_offset_s64)))
-void svstnt1h_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_u32)))
-void svstnt1h_scatter(svbool_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_u64)))
-void svstnt1h_scatter(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_s32)))
-void svstnt1h_scatter(svbool_t, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_s64)))
-void svstnt1h_scatter(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64index_s64)))
-void svstnt1h_scatter_index(svbool_t, int16_t *, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64index_u64)))
-void svstnt1h_scatter_index(svbool_t, uint16_t *, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64index_s64)))
-void svstnt1h_scatter_index(svbool_t, int16_t *, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64index_u64)))
-void svstnt1h_scatter_index(svbool_t, uint16_t *, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32offset_s32)))
-void svstnt1h_scatter_offset(svbool_t, int16_t *, svuint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32offset_u32)))
-void svstnt1h_scatter_offset(svbool_t, uint16_t *, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64offset_s64)))
-void svstnt1h_scatter_offset(svbool_t, int16_t *, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64offset_u64)))
-void svstnt1h_scatter_offset(svbool_t, uint16_t *, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64offset_s64)))
-void svstnt1h_scatter_offset(svbool_t, int16_t *, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64offset_u64)))
-void svstnt1h_scatter_offset(svbool_t, uint16_t *, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_index_u64)))
-void svstnt1w_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_index_s64)))
-void svstnt1w_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_offset_u64)))
-void svstnt1w_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_offset_s64)))
-void svstnt1w_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_u64)))
-void svstnt1w_scatter(svbool_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_s64)))
-void svstnt1w_scatter(svbool_t, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64index_s64)))
-void svstnt1w_scatter_index(svbool_t, int32_t *, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64index_u64)))
-void svstnt1w_scatter_index(svbool_t, uint32_t *, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64index_s64)))
-void svstnt1w_scatter_index(svbool_t, int32_t *, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64index_u64)))
-void svstnt1w_scatter_index(svbool_t, uint32_t *, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64offset_s64)))
-void svstnt1w_scatter_offset(svbool_t, int32_t *, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64offset_u64)))
-void svstnt1w_scatter_offset(svbool_t, uint32_t *, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64offset_s64)))
-void svstnt1w_scatter_offset(svbool_t, int32_t *, svuint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64offset_u64)))
-void svstnt1w_scatter_offset(svbool_t, uint32_t *, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_u32)))
-svuint16_t svsubhnb(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_u64)))
-svuint32_t svsubhnb(svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_u16)))
-svuint8_t svsubhnb(svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_s32)))
-svint16_t svsubhnb(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_s64)))
-svint32_t svsubhnb(svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_s16)))
-svint8_t svsubhnb(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_u32)))
-svuint16_t svsubhnb(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_u64)))
-svuint32_t svsubhnb(svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_u16)))
-svuint8_t svsubhnb(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_s32)))
-svint16_t svsubhnb(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_s64)))
-svint32_t svsubhnb(svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_s16)))
-svint8_t svsubhnb(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_u32)))
-svuint16_t svsubhnt(svuint16_t, svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_u64)))
-svuint32_t svsubhnt(svuint32_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_u16)))
-svuint8_t svsubhnt(svuint8_t, svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_s32)))
-svint16_t svsubhnt(svint16_t, svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_s64)))
-svint32_t svsubhnt(svint32_t, svint64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_s16)))
-svint8_t svsubhnt(svint8_t, svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_u32)))
-svuint16_t svsubhnt(svuint16_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_u64)))
-svuint32_t svsubhnt(svuint32_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_u16)))
-svuint8_t svsubhnt(svuint8_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_s32)))
-svint16_t svsubhnt(svint16_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_s64)))
-svint32_t svsubhnt(svint32_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_s16)))
-svint8_t svsubhnt(svint8_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_s32)))
-svint32_t svsublb(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_s64)))
-svint64_t svsublb(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_s16)))
-svint16_t svsublb(svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_u32)))
-svuint32_t svsublb(svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_u64)))
-svuint64_t svsublb(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_u16)))
-svuint16_t svsublb(svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_s32)))
-svint32_t svsublb(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_s64)))
-svint64_t svsublb(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_s16)))
-svint16_t svsublb(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_u32)))
-svuint32_t svsublb(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_u64)))
-svuint64_t svsublb(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_u16)))
-svuint16_t svsublb(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_n_s32)))
-svint32_t svsublbt(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_n_s64)))
-svint64_t svsublbt(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_n_s16)))
-svint16_t svsublbt(svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_s32)))
-svint32_t svsublbt(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_s64)))
-svint64_t svsublbt(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_s16)))
-svint16_t svsublbt(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_s32)))
-svint32_t svsublt(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_s64)))
-svint64_t svsublt(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_s16)))
-svint16_t svsublt(svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_u32)))
-svuint32_t svsublt(svuint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_u64)))
-svuint64_t svsublt(svuint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_u16)))
-svuint16_t svsublt(svuint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_s32)))
-svint32_t svsublt(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_s64)))
-svint64_t svsublt(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_s16)))
-svint16_t svsublt(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_u32)))
-svuint32_t svsublt(svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_u64)))
-svuint64_t svsublt(svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_u16)))
-svuint16_t svsublt(svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_n_s32)))
-svint32_t svsubltb(svint16_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_n_s64)))
-svint64_t svsubltb(svint32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_n_s16)))
-svint16_t svsubltb(svint8_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_s32)))
-svint32_t svsubltb(svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_s64)))
-svint64_t svsubltb(svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_s16)))
-svint16_t svsubltb(svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_s32)))
-svint32_t svsubwb(svint32_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_s64)))
-svint64_t svsubwb(svint64_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_s16)))
-svint16_t svsubwb(svint16_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_u32)))
-svuint32_t svsubwb(svuint32_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_u64)))
-svuint64_t svsubwb(svuint64_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_u16)))
-svuint16_t svsubwb(svuint16_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_s32)))
-svint32_t svsubwb(svint32_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_s64)))
-svint64_t svsubwb(svint64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_s16)))
-svint16_t svsubwb(svint16_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_u32)))
-svuint32_t svsubwb(svuint32_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_u64)))
-svuint64_t svsubwb(svuint64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_u16)))
-svuint16_t svsubwb(svuint16_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_s32)))
-svint32_t svsubwt(svint32_t, int16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_s64)))
-svint64_t svsubwt(svint64_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_s16)))
-svint16_t svsubwt(svint16_t, int8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_u32)))
-svuint32_t svsubwt(svuint32_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_u64)))
-svuint64_t svsubwt(svuint64_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_u16)))
-svuint16_t svsubwt(svuint16_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_s32)))
-svint32_t svsubwt(svint32_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_s64)))
-svint64_t svsubwt(svint64_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_s16)))
-svint16_t svsubwt(svint16_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_u32)))
-svuint32_t svsubwt(svuint32_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_u64)))
-svuint64_t svsubwt(svuint64_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_u16)))
-svuint16_t svsubwt(svuint16_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u8)))
-svuint8_t svtbl2(svuint8x2_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u32)))
-svuint32_t svtbl2(svuint32x2_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u64)))
-svuint64_t svtbl2(svuint64x2_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u16)))
-svuint16_t svtbl2(svuint16x2_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s8)))
-svint8_t svtbl2(svint8x2_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_f64)))
-svfloat64_t svtbl2(svfloat64x2_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_f32)))
-svfloat32_t svtbl2(svfloat32x2_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_f16)))
-svfloat16_t svtbl2(svfloat16x2_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s32)))
-svint32_t svtbl2(svint32x2_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s64)))
-svint64_t svtbl2(svint64x2_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s16)))
-svint16_t svtbl2(svint16x2_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u8)))
-svuint8_t svtbx(svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u32)))
-svuint32_t svtbx(svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u64)))
-svuint64_t svtbx(svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u16)))
-svuint16_t svtbx(svuint16_t, svuint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s8)))
-svint8_t svtbx(svint8_t, svint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_f64)))
-svfloat64_t svtbx(svfloat64_t, svfloat64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_f32)))
-svfloat32_t svtbx(svfloat32_t, svfloat32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_f16)))
-svfloat16_t svtbx(svfloat16_t, svfloat16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s32)))
-svint32_t svtbx(svint32_t, svint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s64)))
-svint64_t svtbx(svint64_t, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s16)))
-svint16_t svtbx(svint16_t, svint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s8_m)))
-svint8_t svuqadd_m(svbool_t, svint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s32_m)))
-svint32_t svuqadd_m(svbool_t, svint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s64_m)))
-svint64_t svuqadd_m(svbool_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s16_m)))
-svint16_t svuqadd_m(svbool_t, svint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s8_x)))
-svint8_t svuqadd_x(svbool_t, svint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s32_x)))
-svint32_t svuqadd_x(svbool_t, svint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s64_x)))
-svint64_t svuqadd_x(svbool_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s16_x)))
-svint16_t svuqadd_x(svbool_t, svint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s8_z)))
-svint8_t svuqadd_z(svbool_t, svint8_t, uint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s32_z)))
-svint32_t svuqadd_z(svbool_t, svint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s64_z)))
-svint64_t svuqadd_z(svbool_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s16_z)))
-svint16_t svuqadd_z(svbool_t, svint16_t, uint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s8_m)))
-svint8_t svuqadd_m(svbool_t, svint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s32_m)))
-svint32_t svuqadd_m(svbool_t, svint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s64_m)))
-svint64_t svuqadd_m(svbool_t, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s16_m)))
-svint16_t svuqadd_m(svbool_t, svint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s8_x)))
-svint8_t svuqadd_x(svbool_t, svint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s32_x)))
-svint32_t svuqadd_x(svbool_t, svint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s64_x)))
-svint64_t svuqadd_x(svbool_t, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s16_x)))
-svint16_t svuqadd_x(svbool_t, svint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s8_z)))
-svint8_t svuqadd_z(svbool_t, svint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s32_z)))
-svint32_t svuqadd_z(svbool_t, svint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s64_z)))
-svint64_t svuqadd_z(svbool_t, svint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s16_z)))
-svint16_t svuqadd_z(svbool_t, svint16_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_s32)))
-svbool_t svwhilege_b8(int32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_s32)))
-svbool_t svwhilege_b32(int32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_s32)))
-svbool_t svwhilege_b64(int32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_s32)))
-svbool_t svwhilege_b16(int32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_s64)))
-svbool_t svwhilege_b8(int64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_s64)))
-svbool_t svwhilege_b32(int64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_s64)))
-svbool_t svwhilege_b64(int64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_s64)))
-svbool_t svwhilege_b16(int64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_u32)))
-svbool_t svwhilege_b8(uint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_u32)))
-svbool_t svwhilege_b32(uint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_u32)))
-svbool_t svwhilege_b64(uint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_u32)))
-svbool_t svwhilege_b16(uint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_u64)))
-svbool_t svwhilege_b8(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_u64)))
-svbool_t svwhilege_b32(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_u64)))
-svbool_t svwhilege_b64(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_u64)))
-svbool_t svwhilege_b16(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_s32)))
-svbool_t svwhilegt_b8(int32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_s32)))
-svbool_t svwhilegt_b32(int32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_s32)))
-svbool_t svwhilegt_b64(int32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_s32)))
-svbool_t svwhilegt_b16(int32_t, int32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_s64)))
-svbool_t svwhilegt_b8(int64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_s64)))
-svbool_t svwhilegt_b32(int64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_s64)))
-svbool_t svwhilegt_b64(int64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_s64)))
-svbool_t svwhilegt_b16(int64_t, int64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_u32)))
-svbool_t svwhilegt_b8(uint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_u32)))
-svbool_t svwhilegt_b32(uint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_u32)))
-svbool_t svwhilegt_b64(uint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_u32)))
-svbool_t svwhilegt_b16(uint32_t, uint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_u64)))
-svbool_t svwhilegt_b8(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_u64)))
-svbool_t svwhilegt_b32(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_u64)))
-svbool_t svwhilegt_b64(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_u64)))
-svbool_t svwhilegt_b16(uint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u8)))
-svbool_t svwhilerw(uint8_t const *, uint8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s8)))
-svbool_t svwhilerw(int8_t const *, int8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u64)))
-svbool_t svwhilerw(uint64_t const *, uint64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_f64)))
-svbool_t svwhilerw(float64_t const *, float64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s64)))
-svbool_t svwhilerw(int64_t const *, int64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u16)))
-svbool_t svwhilerw(uint16_t const *, uint16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_f16)))
-svbool_t svwhilerw(float16_t const *, float16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s16)))
-svbool_t svwhilerw(int16_t const *, int16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u32)))
-svbool_t svwhilerw(uint32_t const *, uint32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_f32)))
-svbool_t svwhilerw(float32_t const *, float32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s32)))
-svbool_t svwhilerw(int32_t const *, int32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u8)))
-svbool_t svwhilewr(uint8_t const *, uint8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s8)))
-svbool_t svwhilewr(int8_t const *, int8_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u64)))
-svbool_t svwhilewr(uint64_t const *, uint64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_f64)))
-svbool_t svwhilewr(float64_t const *, float64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s64)))
-svbool_t svwhilewr(int64_t const *, int64_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u16)))
-svbool_t svwhilewr(uint16_t const *, uint16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_f16)))
-svbool_t svwhilewr(float16_t const *, float16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s16)))
-svbool_t svwhilewr(int16_t const *, int16_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u32)))
-svbool_t svwhilewr(uint32_t const *, uint32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_f32)))
-svbool_t svwhilewr(float32_t const *, float32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s32)))
-svbool_t svwhilewr(int32_t const *, int32_t const *);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u8)))
-svuint8_t svxar(svuint8_t, svuint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u32)))
-svuint32_t svxar(svuint32_t, svuint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u64)))
-svuint64_t svxar(svuint64_t, svuint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u16)))
-svuint16_t svxar(svuint16_t, svuint16_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s8)))
-svint8_t svxar(svint8_t, svint8_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s32)))
-svint32_t svxar(svint32_t, svint32_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s64)))
-svint64_t svxar(svint64_t, svint64_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s16)))
-svint16_t svxar(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s8)))
+svint8_t svreinterpret_s8_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u8)))
+svint8_t svreinterpret_s8_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s16)))
+svint8_t svreinterpret_s8_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u16)))
+svint8_t svreinterpret_s8_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s32)))
+svint8_t svreinterpret_s8_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u32)))
+svint8_t svreinterpret_s8_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s64)))
+svint8_t svreinterpret_s8_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u64)))
+svint8_t svreinterpret_s8_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f16)))
+svint8_t svreinterpret_s8_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_bf16)))
+svint8_t svreinterpret_s8_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f32)))
+svint8_t svreinterpret_s8_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f64)))
+svint8_t svreinterpret_s8_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s8)))
+svuint8_t svreinterpret_u8_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u8)))
+svuint8_t svreinterpret_u8_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s16)))
+svuint8_t svreinterpret_u8_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u16)))
+svuint8_t svreinterpret_u8_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s32)))
+svuint8_t svreinterpret_u8_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u32)))
+svuint8_t svreinterpret_u8_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s64)))
+svuint8_t svreinterpret_u8_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u64)))
+svuint8_t svreinterpret_u8_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f16)))
+svuint8_t svreinterpret_u8_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_bf16)))
+svuint8_t svreinterpret_u8_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f32)))
+svuint8_t svreinterpret_u8_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f64)))
+svuint8_t svreinterpret_u8_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s8)))
+svint16_t svreinterpret_s16_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u8)))
+svint16_t svreinterpret_s16_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s16)))
+svint16_t svreinterpret_s16_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u16)))
+svint16_t svreinterpret_s16_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s32)))
+svint16_t svreinterpret_s16_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u32)))
+svint16_t svreinterpret_s16_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s64)))
+svint16_t svreinterpret_s16_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u64)))
+svint16_t svreinterpret_s16_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f16)))
+svint16_t svreinterpret_s16_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_bf16)))
+svint16_t svreinterpret_s16_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f32)))
+svint16_t svreinterpret_s16_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f64)))
+svint16_t svreinterpret_s16_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s8)))
+svuint16_t svreinterpret_u16_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u8)))
+svuint16_t svreinterpret_u16_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s16)))
+svuint16_t svreinterpret_u16_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u16)))
+svuint16_t svreinterpret_u16_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s32)))
+svuint16_t svreinterpret_u16_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u32)))
+svuint16_t svreinterpret_u16_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s64)))
+svuint16_t svreinterpret_u16_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u64)))
+svuint16_t svreinterpret_u16_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f16)))
+svuint16_t svreinterpret_u16_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_bf16)))
+svuint16_t svreinterpret_u16_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f32)))
+svuint16_t svreinterpret_u16_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f64)))
+svuint16_t svreinterpret_u16_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s8)))
+svint32_t svreinterpret_s32_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u8)))
+svint32_t svreinterpret_s32_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s16)))
+svint32_t svreinterpret_s32_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u16)))
+svint32_t svreinterpret_s32_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s32)))
+svint32_t svreinterpret_s32_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u32)))
+svint32_t svreinterpret_s32_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s64)))
+svint32_t svreinterpret_s32_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u64)))
+svint32_t svreinterpret_s32_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f16)))
+svint32_t svreinterpret_s32_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_bf16)))
+svint32_t svreinterpret_s32_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f32)))
+svint32_t svreinterpret_s32_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f64)))
+svint32_t svreinterpret_s32_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s8)))
+svuint32_t svreinterpret_u32_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u8)))
+svuint32_t svreinterpret_u32_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s16)))
+svuint32_t svreinterpret_u32_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u16)))
+svuint32_t svreinterpret_u32_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s32)))
+svuint32_t svreinterpret_u32_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u32)))
+svuint32_t svreinterpret_u32_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s64)))
+svuint32_t svreinterpret_u32_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u64)))
+svuint32_t svreinterpret_u32_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f16)))
+svuint32_t svreinterpret_u32_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_bf16)))
+svuint32_t svreinterpret_u32_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f32)))
+svuint32_t svreinterpret_u32_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f64)))
+svuint32_t svreinterpret_u32_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s8)))
+svint64_t svreinterpret_s64_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u8)))
+svint64_t svreinterpret_s64_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s16)))
+svint64_t svreinterpret_s64_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u16)))
+svint64_t svreinterpret_s64_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s32)))
+svint64_t svreinterpret_s64_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u32)))
+svint64_t svreinterpret_s64_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s64)))
+svint64_t svreinterpret_s64_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u64)))
+svint64_t svreinterpret_s64_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f16)))
+svint64_t svreinterpret_s64_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_bf16)))
+svint64_t svreinterpret_s64_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f32)))
+svint64_t svreinterpret_s64_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f64)))
+svint64_t svreinterpret_s64_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s8)))
+svuint64_t svreinterpret_u64_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u8)))
+svuint64_t svreinterpret_u64_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s16)))
+svuint64_t svreinterpret_u64_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u16)))
+svuint64_t svreinterpret_u64_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s32)))
+svuint64_t svreinterpret_u64_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u32)))
+svuint64_t svreinterpret_u64_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s64)))
+svuint64_t svreinterpret_u64_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u64)))
+svuint64_t svreinterpret_u64_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f16)))
+svuint64_t svreinterpret_u64_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_bf16)))
+svuint64_t svreinterpret_u64_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f32)))
+svuint64_t svreinterpret_u64_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f64)))
+svuint64_t svreinterpret_u64_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s8)))
+svfloat16_t svreinterpret_f16_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u8)))
+svfloat16_t svreinterpret_f16_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s16)))
+svfloat16_t svreinterpret_f16_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u16)))
+svfloat16_t svreinterpret_f16_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s32)))
+svfloat16_t svreinterpret_f16_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u32)))
+svfloat16_t svreinterpret_f16_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s64)))
+svfloat16_t svreinterpret_f16_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u64)))
+svfloat16_t svreinterpret_f16_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f16)))
+svfloat16_t svreinterpret_f16_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_bf16)))
+svfloat16_t svreinterpret_f16_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f32)))
+svfloat16_t svreinterpret_f16_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f64)))
+svfloat16_t svreinterpret_f16_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s8)))
+svbfloat16_t svreinterpret_bf16_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u8)))
+svbfloat16_t svreinterpret_bf16_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s16)))
+svbfloat16_t svreinterpret_bf16_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u16)))
+svbfloat16_t svreinterpret_bf16_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s32)))
+svbfloat16_t svreinterpret_bf16_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u32)))
+svbfloat16_t svreinterpret_bf16_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s64)))
+svbfloat16_t svreinterpret_bf16_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u64)))
+svbfloat16_t svreinterpret_bf16_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f16)))
+svbfloat16_t svreinterpret_bf16_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_bf16)))
+svbfloat16_t svreinterpret_bf16_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f32)))
+svbfloat16_t svreinterpret_bf16_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f64)))
+svbfloat16_t svreinterpret_bf16_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s8)))
+svfloat32_t svreinterpret_f32_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u8)))
+svfloat32_t svreinterpret_f32_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s16)))
+svfloat32_t svreinterpret_f32_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u16)))
+svfloat32_t svreinterpret_f32_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s32)))
+svfloat32_t svreinterpret_f32_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u32)))
+svfloat32_t svreinterpret_f32_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s64)))
+svfloat32_t svreinterpret_f32_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u64)))
+svfloat32_t svreinterpret_f32_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f16)))
+svfloat32_t svreinterpret_f32_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_bf16)))
+svfloat32_t svreinterpret_f32_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f32)))
+svfloat32_t svreinterpret_f32_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f64)))
+svfloat32_t svreinterpret_f32_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s8)))
+svfloat64_t svreinterpret_f64_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u8)))
+svfloat64_t svreinterpret_f64_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s16)))
+svfloat64_t svreinterpret_f64_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u16)))
+svfloat64_t svreinterpret_f64_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s32)))
+svfloat64_t svreinterpret_f64_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u32)))
+svfloat64_t svreinterpret_f64_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s64)))
+svfloat64_t svreinterpret_f64_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u64)))
+svfloat64_t svreinterpret_f64_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f16)))
+svfloat64_t svreinterpret_f64_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_bf16)))
+svfloat64_t svreinterpret_f64_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f32)))
+svfloat64_t svreinterpret_f64_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f64)))
+svfloat64_t svreinterpret_f64_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s8)))
+svint8_t svreinterpret_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u8)))
+svint8_t svreinterpret_s8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s16)))
+svint8_t svreinterpret_s8(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u16)))
+svint8_t svreinterpret_s8(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s32)))
+svint8_t svreinterpret_s8(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u32)))
+svint8_t svreinterpret_s8(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s64)))
+svint8_t svreinterpret_s8(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u64)))
+svint8_t svreinterpret_s8(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f16)))
+svint8_t svreinterpret_s8(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_bf16)))
+svint8_t svreinterpret_s8(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f32)))
+svint8_t svreinterpret_s8(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f64)))
+svint8_t svreinterpret_s8(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s8)))
+svuint8_t svreinterpret_u8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u8)))
+svuint8_t svreinterpret_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s16)))
+svuint8_t svreinterpret_u8(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u16)))
+svuint8_t svreinterpret_u8(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s32)))
+svuint8_t svreinterpret_u8(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u32)))
+svuint8_t svreinterpret_u8(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s64)))
+svuint8_t svreinterpret_u8(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u64)))
+svuint8_t svreinterpret_u8(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f16)))
+svuint8_t svreinterpret_u8(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_bf16)))
+svuint8_t svreinterpret_u8(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f32)))
+svuint8_t svreinterpret_u8(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f64)))
+svuint8_t svreinterpret_u8(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s8)))
+svint16_t svreinterpret_s16(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u8)))
+svint16_t svreinterpret_s16(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s16)))
+svint16_t svreinterpret_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u16)))
+svint16_t svreinterpret_s16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s32)))
+svint16_t svreinterpret_s16(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u32)))
+svint16_t svreinterpret_s16(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s64)))
+svint16_t svreinterpret_s16(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u64)))
+svint16_t svreinterpret_s16(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f16)))
+svint16_t svreinterpret_s16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_bf16)))
+svint16_t svreinterpret_s16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f32)))
+svint16_t svreinterpret_s16(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f64)))
+svint16_t svreinterpret_s16(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s8)))
+svuint16_t svreinterpret_u16(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u8)))
+svuint16_t svreinterpret_u16(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s16)))
+svuint16_t svreinterpret_u16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u16)))
+svuint16_t svreinterpret_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s32)))
+svuint16_t svreinterpret_u16(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u32)))
+svuint16_t svreinterpret_u16(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s64)))
+svuint16_t svreinterpret_u16(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u64)))
+svuint16_t svreinterpret_u16(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f16)))
+svuint16_t svreinterpret_u16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_bf16)))
+svuint16_t svreinterpret_u16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f32)))
+svuint16_t svreinterpret_u16(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f64)))
+svuint16_t svreinterpret_u16(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s8)))
+svint32_t svreinterpret_s32(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u8)))
+svint32_t svreinterpret_s32(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s16)))
+svint32_t svreinterpret_s32(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u16)))
+svint32_t svreinterpret_s32(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s32)))
+svint32_t svreinterpret_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u32)))
+svint32_t svreinterpret_s32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s64)))
+svint32_t svreinterpret_s32(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u64)))
+svint32_t svreinterpret_s32(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f16)))
+svint32_t svreinterpret_s32(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_bf16)))
+svint32_t svreinterpret_s32(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f32)))
+svint32_t svreinterpret_s32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f64)))
+svint32_t svreinterpret_s32(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s8)))
+svuint32_t svreinterpret_u32(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u8)))
+svuint32_t svreinterpret_u32(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s16)))
+svuint32_t svreinterpret_u32(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u16)))
+svuint32_t svreinterpret_u32(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s32)))
+svuint32_t svreinterpret_u32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u32)))
+svuint32_t svreinterpret_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s64)))
+svuint32_t svreinterpret_u32(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u64)))
+svuint32_t svreinterpret_u32(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f16)))
+svuint32_t svreinterpret_u32(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_bf16)))
+svuint32_t svreinterpret_u32(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f32)))
+svuint32_t svreinterpret_u32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f64)))
+svuint32_t svreinterpret_u32(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s8)))
+svint64_t svreinterpret_s64(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u8)))
+svint64_t svreinterpret_s64(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s16)))
+svint64_t svreinterpret_s64(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u16)))
+svint64_t svreinterpret_s64(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s32)))
+svint64_t svreinterpret_s64(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u32)))
+svint64_t svreinterpret_s64(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s64)))
+svint64_t svreinterpret_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u64)))
+svint64_t svreinterpret_s64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f16)))
+svint64_t svreinterpret_s64(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_bf16)))
+svint64_t svreinterpret_s64(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f32)))
+svint64_t svreinterpret_s64(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f64)))
+svint64_t svreinterpret_s64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s8)))
+svuint64_t svreinterpret_u64(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u8)))
+svuint64_t svreinterpret_u64(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s16)))
+svuint64_t svreinterpret_u64(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u16)))
+svuint64_t svreinterpret_u64(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s32)))
+svuint64_t svreinterpret_u64(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u32)))
+svuint64_t svreinterpret_u64(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s64)))
+svuint64_t svreinterpret_u64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u64)))
+svuint64_t svreinterpret_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f16)))
+svuint64_t svreinterpret_u64(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_bf16)))
+svuint64_t svreinterpret_u64(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f32)))
+svuint64_t svreinterpret_u64(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f64)))
+svuint64_t svreinterpret_u64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s8)))
+svfloat16_t svreinterpret_f16(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u8)))
+svfloat16_t svreinterpret_f16(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s16)))
+svfloat16_t svreinterpret_f16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u16)))
+svfloat16_t svreinterpret_f16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s32)))
+svfloat16_t svreinterpret_f16(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u32)))
+svfloat16_t svreinterpret_f16(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s64)))
+svfloat16_t svreinterpret_f16(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u64)))
+svfloat16_t svreinterpret_f16(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f16)))
+svfloat16_t svreinterpret_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_bf16)))
+svfloat16_t svreinterpret_f16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f32)))
+svfloat16_t svreinterpret_f16(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f64)))
+svfloat16_t svreinterpret_f16(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s8)))
+svbfloat16_t svreinterpret_bf16(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u8)))
+svbfloat16_t svreinterpret_bf16(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s16)))
+svbfloat16_t svreinterpret_bf16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u16)))
+svbfloat16_t svreinterpret_bf16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s32)))
+svbfloat16_t svreinterpret_bf16(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u32)))
+svbfloat16_t svreinterpret_bf16(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s64)))
+svbfloat16_t svreinterpret_bf16(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u64)))
+svbfloat16_t svreinterpret_bf16(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f16)))
+svbfloat16_t svreinterpret_bf16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_bf16)))
+svbfloat16_t svreinterpret_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f32)))
+svbfloat16_t svreinterpret_bf16(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f64)))
+svbfloat16_t svreinterpret_bf16(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s8)))
+svfloat32_t svreinterpret_f32(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u8)))
+svfloat32_t svreinterpret_f32(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s16)))
+svfloat32_t svreinterpret_f32(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u16)))
+svfloat32_t svreinterpret_f32(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s32)))
+svfloat32_t svreinterpret_f32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u32)))
+svfloat32_t svreinterpret_f32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s64)))
+svfloat32_t svreinterpret_f32(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u64)))
+svfloat32_t svreinterpret_f32(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f16)))
+svfloat32_t svreinterpret_f32(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_bf16)))
+svfloat32_t svreinterpret_f32(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f32)))
+svfloat32_t svreinterpret_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f64)))
+svfloat32_t svreinterpret_f32(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s8)))
+svfloat64_t svreinterpret_f64(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u8)))
+svfloat64_t svreinterpret_f64(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s16)))
+svfloat64_t svreinterpret_f64(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u16)))
+svfloat64_t svreinterpret_f64(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s32)))
+svfloat64_t svreinterpret_f64(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u32)))
+svfloat64_t svreinterpret_f64(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s64)))
+svfloat64_t svreinterpret_f64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u64)))
+svfloat64_t svreinterpret_f64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f16)))
+svfloat64_t svreinterpret_f64(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_bf16)))
+svfloat64_t svreinterpret_f64(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f32)))
+svfloat64_t svreinterpret_f64(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f64)))
+svfloat64_t svreinterpret_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s8_x2)))
+svint8x2_t svreinterpret_s8_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u8_x2)))
+svint8x2_t svreinterpret_s8_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s16_x2)))
+svint8x2_t svreinterpret_s8_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u16_x2)))
+svint8x2_t svreinterpret_s8_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s32_x2)))
+svint8x2_t svreinterpret_s8_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u32_x2)))
+svint8x2_t svreinterpret_s8_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s64_x2)))
+svint8x2_t svreinterpret_s8_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u64_x2)))
+svint8x2_t svreinterpret_s8_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f16_x2)))
+svint8x2_t svreinterpret_s8_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_bf16_x2)))
+svint8x2_t svreinterpret_s8_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f32_x2)))
+svint8x2_t svreinterpret_s8_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f64_x2)))
+svint8x2_t svreinterpret_s8_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s8_x2)))
+svuint8x2_t svreinterpret_u8_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u8_x2)))
+svuint8x2_t svreinterpret_u8_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s16_x2)))
+svuint8x2_t svreinterpret_u8_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u16_x2)))
+svuint8x2_t svreinterpret_u8_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s32_x2)))
+svuint8x2_t svreinterpret_u8_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u32_x2)))
+svuint8x2_t svreinterpret_u8_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s64_x2)))
+svuint8x2_t svreinterpret_u8_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u64_x2)))
+svuint8x2_t svreinterpret_u8_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f16_x2)))
+svuint8x2_t svreinterpret_u8_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_bf16_x2)))
+svuint8x2_t svreinterpret_u8_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f32_x2)))
+svuint8x2_t svreinterpret_u8_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f64_x2)))
+svuint8x2_t svreinterpret_u8_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s8_x2)))
+svint16x2_t svreinterpret_s16_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u8_x2)))
+svint16x2_t svreinterpret_s16_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s16_x2)))
+svint16x2_t svreinterpret_s16_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u16_x2)))
+svint16x2_t svreinterpret_s16_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s32_x2)))
+svint16x2_t svreinterpret_s16_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u32_x2)))
+svint16x2_t svreinterpret_s16_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s64_x2)))
+svint16x2_t svreinterpret_s16_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u64_x2)))
+svint16x2_t svreinterpret_s16_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f16_x2)))
+svint16x2_t svreinterpret_s16_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_bf16_x2)))
+svint16x2_t svreinterpret_s16_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f32_x2)))
+svint16x2_t svreinterpret_s16_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f64_x2)))
+svint16x2_t svreinterpret_s16_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s8_x2)))
+svuint16x2_t svreinterpret_u16_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u8_x2)))
+svuint16x2_t svreinterpret_u16_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s16_x2)))
+svuint16x2_t svreinterpret_u16_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u16_x2)))
+svuint16x2_t svreinterpret_u16_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s32_x2)))
+svuint16x2_t svreinterpret_u16_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u32_x2)))
+svuint16x2_t svreinterpret_u16_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s64_x2)))
+svuint16x2_t svreinterpret_u16_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u64_x2)))
+svuint16x2_t svreinterpret_u16_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f16_x2)))
+svuint16x2_t svreinterpret_u16_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_bf16_x2)))
+svuint16x2_t svreinterpret_u16_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f32_x2)))
+svuint16x2_t svreinterpret_u16_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f64_x2)))
+svuint16x2_t svreinterpret_u16_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s8_x2)))
+svint32x2_t svreinterpret_s32_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u8_x2)))
+svint32x2_t svreinterpret_s32_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s16_x2)))
+svint32x2_t svreinterpret_s32_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u16_x2)))
+svint32x2_t svreinterpret_s32_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s32_x2)))
+svint32x2_t svreinterpret_s32_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u32_x2)))
+svint32x2_t svreinterpret_s32_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s64_x2)))
+svint32x2_t svreinterpret_s32_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u64_x2)))
+svint32x2_t svreinterpret_s32_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f16_x2)))
+svint32x2_t svreinterpret_s32_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_bf16_x2)))
+svint32x2_t svreinterpret_s32_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f32_x2)))
+svint32x2_t svreinterpret_s32_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f64_x2)))
+svint32x2_t svreinterpret_s32_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s8_x2)))
+svuint32x2_t svreinterpret_u32_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u8_x2)))
+svuint32x2_t svreinterpret_u32_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s16_x2)))
+svuint32x2_t svreinterpret_u32_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u16_x2)))
+svuint32x2_t svreinterpret_u32_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s32_x2)))
+svuint32x2_t svreinterpret_u32_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u32_x2)))
+svuint32x2_t svreinterpret_u32_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s64_x2)))
+svuint32x2_t svreinterpret_u32_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u64_x2)))
+svuint32x2_t svreinterpret_u32_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f16_x2)))
+svuint32x2_t svreinterpret_u32_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_bf16_x2)))
+svuint32x2_t svreinterpret_u32_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f32_x2)))
+svuint32x2_t svreinterpret_u32_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f64_x2)))
+svuint32x2_t svreinterpret_u32_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s8_x2)))
+svint64x2_t svreinterpret_s64_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u8_x2)))
+svint64x2_t svreinterpret_s64_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s16_x2)))
+svint64x2_t svreinterpret_s64_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u16_x2)))
+svint64x2_t svreinterpret_s64_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s32_x2)))
+svint64x2_t svreinterpret_s64_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u32_x2)))
+svint64x2_t svreinterpret_s64_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s64_x2)))
+svint64x2_t svreinterpret_s64_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u64_x2)))
+svint64x2_t svreinterpret_s64_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f16_x2)))
+svint64x2_t svreinterpret_s64_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_bf16_x2)))
+svint64x2_t svreinterpret_s64_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f32_x2)))
+svint64x2_t svreinterpret_s64_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f64_x2)))
+svint64x2_t svreinterpret_s64_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s8_x2)))
+svuint64x2_t svreinterpret_u64_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u8_x2)))
+svuint64x2_t svreinterpret_u64_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s16_x2)))
+svuint64x2_t svreinterpret_u64_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u16_x2)))
+svuint64x2_t svreinterpret_u64_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s32_x2)))
+svuint64x2_t svreinterpret_u64_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u32_x2)))
+svuint64x2_t svreinterpret_u64_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s64_x2)))
+svuint64x2_t svreinterpret_u64_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u64_x2)))
+svuint64x2_t svreinterpret_u64_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f16_x2)))
+svuint64x2_t svreinterpret_u64_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_bf16_x2)))
+svuint64x2_t svreinterpret_u64_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f32_x2)))
+svuint64x2_t svreinterpret_u64_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f64_x2)))
+svuint64x2_t svreinterpret_u64_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s8_x2)))
+svfloat16x2_t svreinterpret_f16_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u8_x2)))
+svfloat16x2_t svreinterpret_f16_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s16_x2)))
+svfloat16x2_t svreinterpret_f16_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u16_x2)))
+svfloat16x2_t svreinterpret_f16_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s32_x2)))
+svfloat16x2_t svreinterpret_f16_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u32_x2)))
+svfloat16x2_t svreinterpret_f16_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s64_x2)))
+svfloat16x2_t svreinterpret_f16_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u64_x2)))
+svfloat16x2_t svreinterpret_f16_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f16_x2)))
+svfloat16x2_t svreinterpret_f16_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_bf16_x2)))
+svfloat16x2_t svreinterpret_f16_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f32_x2)))
+svfloat16x2_t svreinterpret_f16_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f64_x2)))
+svfloat16x2_t svreinterpret_f16_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s8_x2)))
+svbfloat16x2_t svreinterpret_bf16_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u8_x2)))
+svbfloat16x2_t svreinterpret_bf16_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s16_x2)))
+svbfloat16x2_t svreinterpret_bf16_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u16_x2)))
+svbfloat16x2_t svreinterpret_bf16_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s32_x2)))
+svbfloat16x2_t svreinterpret_bf16_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u32_x2)))
+svbfloat16x2_t svreinterpret_bf16_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s64_x2)))
+svbfloat16x2_t svreinterpret_bf16_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u64_x2)))
+svbfloat16x2_t svreinterpret_bf16_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f16_x2)))
+svbfloat16x2_t svreinterpret_bf16_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_bf16_x2)))
+svbfloat16x2_t svreinterpret_bf16_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f32_x2)))
+svbfloat16x2_t svreinterpret_bf16_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f64_x2)))
+svbfloat16x2_t svreinterpret_bf16_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s8_x2)))
+svfloat32x2_t svreinterpret_f32_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u8_x2)))
+svfloat32x2_t svreinterpret_f32_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s16_x2)))
+svfloat32x2_t svreinterpret_f32_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u16_x2)))
+svfloat32x2_t svreinterpret_f32_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s32_x2)))
+svfloat32x2_t svreinterpret_f32_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u32_x2)))
+svfloat32x2_t svreinterpret_f32_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s64_x2)))
+svfloat32x2_t svreinterpret_f32_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u64_x2)))
+svfloat32x2_t svreinterpret_f32_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f16_x2)))
+svfloat32x2_t svreinterpret_f32_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_bf16_x2)))
+svfloat32x2_t svreinterpret_f32_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f32_x2)))
+svfloat32x2_t svreinterpret_f32_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f64_x2)))
+svfloat32x2_t svreinterpret_f32_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s8_x2)))
+svfloat64x2_t svreinterpret_f64_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u8_x2)))
+svfloat64x2_t svreinterpret_f64_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s16_x2)))
+svfloat64x2_t svreinterpret_f64_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u16_x2)))
+svfloat64x2_t svreinterpret_f64_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s32_x2)))
+svfloat64x2_t svreinterpret_f64_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u32_x2)))
+svfloat64x2_t svreinterpret_f64_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s64_x2)))
+svfloat64x2_t svreinterpret_f64_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u64_x2)))
+svfloat64x2_t svreinterpret_f64_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f16_x2)))
+svfloat64x2_t svreinterpret_f64_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_bf16_x2)))
+svfloat64x2_t svreinterpret_f64_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f32_x2)))
+svfloat64x2_t svreinterpret_f64_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f64_x2)))
+svfloat64x2_t svreinterpret_f64_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s8_x2)))
+svint8x2_t svreinterpret_s8(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u8_x2)))
+svint8x2_t svreinterpret_s8(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s16_x2)))
+svint8x2_t svreinterpret_s8(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u16_x2)))
+svint8x2_t svreinterpret_s8(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s32_x2)))
+svint8x2_t svreinterpret_s8(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u32_x2)))
+svint8x2_t svreinterpret_s8(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s64_x2)))
+svint8x2_t svreinterpret_s8(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u64_x2)))
+svint8x2_t svreinterpret_s8(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f16_x2)))
+svint8x2_t svreinterpret_s8(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_bf16_x2)))
+svint8x2_t svreinterpret_s8(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f32_x2)))
+svint8x2_t svreinterpret_s8(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f64_x2)))
+svint8x2_t svreinterpret_s8(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s8_x2)))
+svuint8x2_t svreinterpret_u8(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u8_x2)))
+svuint8x2_t svreinterpret_u8(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s16_x2)))
+svuint8x2_t svreinterpret_u8(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u16_x2)))
+svuint8x2_t svreinterpret_u8(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s32_x2)))
+svuint8x2_t svreinterpret_u8(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u32_x2)))
+svuint8x2_t svreinterpret_u8(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s64_x2)))
+svuint8x2_t svreinterpret_u8(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u64_x2)))
+svuint8x2_t svreinterpret_u8(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f16_x2)))
+svuint8x2_t svreinterpret_u8(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_bf16_x2)))
+svuint8x2_t svreinterpret_u8(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f32_x2)))
+svuint8x2_t svreinterpret_u8(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f64_x2)))
+svuint8x2_t svreinterpret_u8(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s8_x2)))
+svint16x2_t svreinterpret_s16(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u8_x2)))
+svint16x2_t svreinterpret_s16(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s16_x2)))
+svint16x2_t svreinterpret_s16(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u16_x2)))
+svint16x2_t svreinterpret_s16(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s32_x2)))
+svint16x2_t svreinterpret_s16(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u32_x2)))
+svint16x2_t svreinterpret_s16(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s64_x2)))
+svint16x2_t svreinterpret_s16(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u64_x2)))
+svint16x2_t svreinterpret_s16(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f16_x2)))
+svint16x2_t svreinterpret_s16(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_bf16_x2)))
+svint16x2_t svreinterpret_s16(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f32_x2)))
+svint16x2_t svreinterpret_s16(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f64_x2)))
+svint16x2_t svreinterpret_s16(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s8_x2)))
+svuint16x2_t svreinterpret_u16(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u8_x2)))
+svuint16x2_t svreinterpret_u16(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s16_x2)))
+svuint16x2_t svreinterpret_u16(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u16_x2)))
+svuint16x2_t svreinterpret_u16(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s32_x2)))
+svuint16x2_t svreinterpret_u16(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u32_x2)))
+svuint16x2_t svreinterpret_u16(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s64_x2)))
+svuint16x2_t svreinterpret_u16(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u64_x2)))
+svuint16x2_t svreinterpret_u16(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f16_x2)))
+svuint16x2_t svreinterpret_u16(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_bf16_x2)))
+svuint16x2_t svreinterpret_u16(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f32_x2)))
+svuint16x2_t svreinterpret_u16(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f64_x2)))
+svuint16x2_t svreinterpret_u16(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s8_x2)))
+svint32x2_t svreinterpret_s32(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u8_x2)))
+svint32x2_t svreinterpret_s32(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s16_x2)))
+svint32x2_t svreinterpret_s32(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u16_x2)))
+svint32x2_t svreinterpret_s32(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s32_x2)))
+svint32x2_t svreinterpret_s32(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u32_x2)))
+svint32x2_t svreinterpret_s32(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s64_x2)))
+svint32x2_t svreinterpret_s32(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u64_x2)))
+svint32x2_t svreinterpret_s32(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f16_x2)))
+svint32x2_t svreinterpret_s32(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_bf16_x2)))
+svint32x2_t svreinterpret_s32(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f32_x2)))
+svint32x2_t svreinterpret_s32(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f64_x2)))
+svint32x2_t svreinterpret_s32(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s8_x2)))
+svuint32x2_t svreinterpret_u32(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u8_x2)))
+svuint32x2_t svreinterpret_u32(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s16_x2)))
+svuint32x2_t svreinterpret_u32(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u16_x2)))
+svuint32x2_t svreinterpret_u32(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s32_x2)))
+svuint32x2_t svreinterpret_u32(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u32_x2)))
+svuint32x2_t svreinterpret_u32(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s64_x2)))
+svuint32x2_t svreinterpret_u32(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u64_x2)))
+svuint32x2_t svreinterpret_u32(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f16_x2)))
+svuint32x2_t svreinterpret_u32(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_bf16_x2)))
+svuint32x2_t svreinterpret_u32(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f32_x2)))
+svuint32x2_t svreinterpret_u32(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f64_x2)))
+svuint32x2_t svreinterpret_u32(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s8_x2)))
+svint64x2_t svreinterpret_s64(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u8_x2)))
+svint64x2_t svreinterpret_s64(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s16_x2)))
+svint64x2_t svreinterpret_s64(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u16_x2)))
+svint64x2_t svreinterpret_s64(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s32_x2)))
+svint64x2_t svreinterpret_s64(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u32_x2)))
+svint64x2_t svreinterpret_s64(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s64_x2)))
+svint64x2_t svreinterpret_s64(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u64_x2)))
+svint64x2_t svreinterpret_s64(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f16_x2)))
+svint64x2_t svreinterpret_s64(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_bf16_x2)))
+svint64x2_t svreinterpret_s64(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f32_x2)))
+svint64x2_t svreinterpret_s64(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f64_x2)))
+svint64x2_t svreinterpret_s64(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s8_x2)))
+svuint64x2_t svreinterpret_u64(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u8_x2)))
+svuint64x2_t svreinterpret_u64(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s16_x2)))
+svuint64x2_t svreinterpret_u64(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u16_x2)))
+svuint64x2_t svreinterpret_u64(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s32_x2)))
+svuint64x2_t svreinterpret_u64(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u32_x2)))
+svuint64x2_t svreinterpret_u64(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s64_x2)))
+svuint64x2_t svreinterpret_u64(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u64_x2)))
+svuint64x2_t svreinterpret_u64(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f16_x2)))
+svuint64x2_t svreinterpret_u64(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_bf16_x2)))
+svuint64x2_t svreinterpret_u64(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f32_x2)))
+svuint64x2_t svreinterpret_u64(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f64_x2)))
+svuint64x2_t svreinterpret_u64(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s8_x2)))
+svfloat16x2_t svreinterpret_f16(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u8_x2)))
+svfloat16x2_t svreinterpret_f16(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s16_x2)))
+svfloat16x2_t svreinterpret_f16(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u16_x2)))
+svfloat16x2_t svreinterpret_f16(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s32_x2)))
+svfloat16x2_t svreinterpret_f16(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u32_x2)))
+svfloat16x2_t svreinterpret_f16(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s64_x2)))
+svfloat16x2_t svreinterpret_f16(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u64_x2)))
+svfloat16x2_t svreinterpret_f16(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f16_x2)))
+svfloat16x2_t svreinterpret_f16(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_bf16_x2)))
+svfloat16x2_t svreinterpret_f16(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f32_x2)))
+svfloat16x2_t svreinterpret_f16(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f64_x2)))
+svfloat16x2_t svreinterpret_f16(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s8_x2)))
+svbfloat16x2_t svreinterpret_bf16(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u8_x2)))
+svbfloat16x2_t svreinterpret_bf16(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s16_x2)))
+svbfloat16x2_t svreinterpret_bf16(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u16_x2)))
+svbfloat16x2_t svreinterpret_bf16(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s32_x2)))
+svbfloat16x2_t svreinterpret_bf16(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u32_x2)))
+svbfloat16x2_t svreinterpret_bf16(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s64_x2)))
+svbfloat16x2_t svreinterpret_bf16(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u64_x2)))
+svbfloat16x2_t svreinterpret_bf16(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f16_x2)))
+svbfloat16x2_t svreinterpret_bf16(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_bf16_x2)))
+svbfloat16x2_t svreinterpret_bf16(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f32_x2)))
+svbfloat16x2_t svreinterpret_bf16(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f64_x2)))
+svbfloat16x2_t svreinterpret_bf16(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s8_x2)))
+svfloat32x2_t svreinterpret_f32(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u8_x2)))
+svfloat32x2_t svreinterpret_f32(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s16_x2)))
+svfloat32x2_t svreinterpret_f32(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u16_x2)))
+svfloat32x2_t svreinterpret_f32(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s32_x2)))
+svfloat32x2_t svreinterpret_f32(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u32_x2)))
+svfloat32x2_t svreinterpret_f32(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s64_x2)))
+svfloat32x2_t svreinterpret_f32(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u64_x2)))
+svfloat32x2_t svreinterpret_f32(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f16_x2)))
+svfloat32x2_t svreinterpret_f32(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_bf16_x2)))
+svfloat32x2_t svreinterpret_f32(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f32_x2)))
+svfloat32x2_t svreinterpret_f32(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f64_x2)))
+svfloat32x2_t svreinterpret_f32(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s8_x2)))
+svfloat64x2_t svreinterpret_f64(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u8_x2)))
+svfloat64x2_t svreinterpret_f64(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s16_x2)))
+svfloat64x2_t svreinterpret_f64(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u16_x2)))
+svfloat64x2_t svreinterpret_f64(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s32_x2)))
+svfloat64x2_t svreinterpret_f64(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u32_x2)))
+svfloat64x2_t svreinterpret_f64(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s64_x2)))
+svfloat64x2_t svreinterpret_f64(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u64_x2)))
+svfloat64x2_t svreinterpret_f64(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f16_x2)))
+svfloat64x2_t svreinterpret_f64(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_bf16_x2)))
+svfloat64x2_t svreinterpret_f64(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f32_x2)))
+svfloat64x2_t svreinterpret_f64(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f64_x2)))
+svfloat64x2_t svreinterpret_f64(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s8_x3)))
+svint8x3_t svreinterpret_s8_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u8_x3)))
+svint8x3_t svreinterpret_s8_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s16_x3)))
+svint8x3_t svreinterpret_s8_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u16_x3)))
+svint8x3_t svreinterpret_s8_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s32_x3)))
+svint8x3_t svreinterpret_s8_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u32_x3)))
+svint8x3_t svreinterpret_s8_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s64_x3)))
+svint8x3_t svreinterpret_s8_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u64_x3)))
+svint8x3_t svreinterpret_s8_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f16_x3)))
+svint8x3_t svreinterpret_s8_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_bf16_x3)))
+svint8x3_t svreinterpret_s8_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f32_x3)))
+svint8x3_t svreinterpret_s8_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f64_x3)))
+svint8x3_t svreinterpret_s8_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s8_x3)))
+svuint8x3_t svreinterpret_u8_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u8_x3)))
+svuint8x3_t svreinterpret_u8_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s16_x3)))
+svuint8x3_t svreinterpret_u8_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u16_x3)))
+svuint8x3_t svreinterpret_u8_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s32_x3)))
+svuint8x3_t svreinterpret_u8_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u32_x3)))
+svuint8x3_t svreinterpret_u8_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s64_x3)))
+svuint8x3_t svreinterpret_u8_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u64_x3)))
+svuint8x3_t svreinterpret_u8_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f16_x3)))
+svuint8x3_t svreinterpret_u8_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_bf16_x3)))
+svuint8x3_t svreinterpret_u8_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f32_x3)))
+svuint8x3_t svreinterpret_u8_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f64_x3)))
+svuint8x3_t svreinterpret_u8_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s8_x3)))
+svint16x3_t svreinterpret_s16_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u8_x3)))
+svint16x3_t svreinterpret_s16_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s16_x3)))
+svint16x3_t svreinterpret_s16_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u16_x3)))
+svint16x3_t svreinterpret_s16_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s32_x3)))
+svint16x3_t svreinterpret_s16_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u32_x3)))
+svint16x3_t svreinterpret_s16_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s64_x3)))
+svint16x3_t svreinterpret_s16_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u64_x3)))
+svint16x3_t svreinterpret_s16_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f16_x3)))
+svint16x3_t svreinterpret_s16_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_bf16_x3)))
+svint16x3_t svreinterpret_s16_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f32_x3)))
+svint16x3_t svreinterpret_s16_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f64_x3)))
+svint16x3_t svreinterpret_s16_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s8_x3)))
+svuint16x3_t svreinterpret_u16_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u8_x3)))
+svuint16x3_t svreinterpret_u16_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s16_x3)))
+svuint16x3_t svreinterpret_u16_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u16_x3)))
+svuint16x3_t svreinterpret_u16_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s32_x3)))
+svuint16x3_t svreinterpret_u16_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u32_x3)))
+svuint16x3_t svreinterpret_u16_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s64_x3)))
+svuint16x3_t svreinterpret_u16_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u64_x3)))
+svuint16x3_t svreinterpret_u16_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f16_x3)))
+svuint16x3_t svreinterpret_u16_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_bf16_x3)))
+svuint16x3_t svreinterpret_u16_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f32_x3)))
+svuint16x3_t svreinterpret_u16_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f64_x3)))
+svuint16x3_t svreinterpret_u16_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s8_x3)))
+svint32x3_t svreinterpret_s32_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u8_x3)))
+svint32x3_t svreinterpret_s32_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s16_x3)))
+svint32x3_t svreinterpret_s32_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u16_x3)))
+svint32x3_t svreinterpret_s32_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s32_x3)))
+svint32x3_t svreinterpret_s32_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u32_x3)))
+svint32x3_t svreinterpret_s32_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s64_x3)))
+svint32x3_t svreinterpret_s32_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u64_x3)))
+svint32x3_t svreinterpret_s32_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f16_x3)))
+svint32x3_t svreinterpret_s32_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_bf16_x3)))
+svint32x3_t svreinterpret_s32_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f32_x3)))
+svint32x3_t svreinterpret_s32_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f64_x3)))
+svint32x3_t svreinterpret_s32_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s8_x3)))
+svuint32x3_t svreinterpret_u32_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u8_x3)))
+svuint32x3_t svreinterpret_u32_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s16_x3)))
+svuint32x3_t svreinterpret_u32_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u16_x3)))
+svuint32x3_t svreinterpret_u32_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s32_x3)))
+svuint32x3_t svreinterpret_u32_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u32_x3)))
+svuint32x3_t svreinterpret_u32_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s64_x3)))
+svuint32x3_t svreinterpret_u32_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u64_x3)))
+svuint32x3_t svreinterpret_u32_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f16_x3)))
+svuint32x3_t svreinterpret_u32_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_bf16_x3)))
+svuint32x3_t svreinterpret_u32_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f32_x3)))
+svuint32x3_t svreinterpret_u32_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f64_x3)))
+svuint32x3_t svreinterpret_u32_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s8_x3)))
+svint64x3_t svreinterpret_s64_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u8_x3)))
+svint64x3_t svreinterpret_s64_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s16_x3)))
+svint64x3_t svreinterpret_s64_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u16_x3)))
+svint64x3_t svreinterpret_s64_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s32_x3)))
+svint64x3_t svreinterpret_s64_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u32_x3)))
+svint64x3_t svreinterpret_s64_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s64_x3)))
+svint64x3_t svreinterpret_s64_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u64_x3)))
+svint64x3_t svreinterpret_s64_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f16_x3)))
+svint64x3_t svreinterpret_s64_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_bf16_x3)))
+svint64x3_t svreinterpret_s64_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f32_x3)))
+svint64x3_t svreinterpret_s64_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f64_x3)))
+svint64x3_t svreinterpret_s64_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s8_x3)))
+svuint64x3_t svreinterpret_u64_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u8_x3)))
+svuint64x3_t svreinterpret_u64_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s16_x3)))
+svuint64x3_t svreinterpret_u64_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u16_x3)))
+svuint64x3_t svreinterpret_u64_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s32_x3)))
+svuint64x3_t svreinterpret_u64_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u32_x3)))
+svuint64x3_t svreinterpret_u64_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s64_x3)))
+svuint64x3_t svreinterpret_u64_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u64_x3)))
+svuint64x3_t svreinterpret_u64_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f16_x3)))
+svuint64x3_t svreinterpret_u64_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_bf16_x3)))
+svuint64x3_t svreinterpret_u64_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f32_x3)))
+svuint64x3_t svreinterpret_u64_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f64_x3)))
+svuint64x3_t svreinterpret_u64_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s8_x3)))
+svfloat16x3_t svreinterpret_f16_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u8_x3)))
+svfloat16x3_t svreinterpret_f16_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s16_x3)))
+svfloat16x3_t svreinterpret_f16_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u16_x3)))
+svfloat16x3_t svreinterpret_f16_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s32_x3)))
+svfloat16x3_t svreinterpret_f16_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u32_x3)))
+svfloat16x3_t svreinterpret_f16_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s64_x3)))
+svfloat16x3_t svreinterpret_f16_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u64_x3)))
+svfloat16x3_t svreinterpret_f16_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f16_x3)))
+svfloat16x3_t svreinterpret_f16_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_bf16_x3)))
+svfloat16x3_t svreinterpret_f16_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f32_x3)))
+svfloat16x3_t svreinterpret_f16_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f64_x3)))
+svfloat16x3_t svreinterpret_f16_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s8_x3)))
+svbfloat16x3_t svreinterpret_bf16_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u8_x3)))
+svbfloat16x3_t svreinterpret_bf16_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s16_x3)))
+svbfloat16x3_t svreinterpret_bf16_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u16_x3)))
+svbfloat16x3_t svreinterpret_bf16_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s32_x3)))
+svbfloat16x3_t svreinterpret_bf16_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u32_x3)))
+svbfloat16x3_t svreinterpret_bf16_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s64_x3)))
+svbfloat16x3_t svreinterpret_bf16_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u64_x3)))
+svbfloat16x3_t svreinterpret_bf16_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f16_x3)))
+svbfloat16x3_t svreinterpret_bf16_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_bf16_x3)))
+svbfloat16x3_t svreinterpret_bf16_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f32_x3)))
+svbfloat16x3_t svreinterpret_bf16_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f64_x3)))
+svbfloat16x3_t svreinterpret_bf16_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s8_x3)))
+svfloat32x3_t svreinterpret_f32_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u8_x3)))
+svfloat32x3_t svreinterpret_f32_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s16_x3)))
+svfloat32x3_t svreinterpret_f32_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u16_x3)))
+svfloat32x3_t svreinterpret_f32_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s32_x3)))
+svfloat32x3_t svreinterpret_f32_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u32_x3)))
+svfloat32x3_t svreinterpret_f32_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s64_x3)))
+svfloat32x3_t svreinterpret_f32_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u64_x3)))
+svfloat32x3_t svreinterpret_f32_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f16_x3)))
+svfloat32x3_t svreinterpret_f32_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_bf16_x3)))
+svfloat32x3_t svreinterpret_f32_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f32_x3)))
+svfloat32x3_t svreinterpret_f32_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f64_x3)))
+svfloat32x3_t svreinterpret_f32_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s8_x3)))
+svfloat64x3_t svreinterpret_f64_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u8_x3)))
+svfloat64x3_t svreinterpret_f64_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s16_x3)))
+svfloat64x3_t svreinterpret_f64_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u16_x3)))
+svfloat64x3_t svreinterpret_f64_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s32_x3)))
+svfloat64x3_t svreinterpret_f64_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u32_x3)))
+svfloat64x3_t svreinterpret_f64_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s64_x3)))
+svfloat64x3_t svreinterpret_f64_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u64_x3)))
+svfloat64x3_t svreinterpret_f64_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f16_x3)))
+svfloat64x3_t svreinterpret_f64_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_bf16_x3)))
+svfloat64x3_t svreinterpret_f64_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f32_x3)))
+svfloat64x3_t svreinterpret_f64_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f64_x3)))
+svfloat64x3_t svreinterpret_f64_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s8_x3)))
+svint8x3_t svreinterpret_s8(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u8_x3)))
+svint8x3_t svreinterpret_s8(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s16_x3)))
+svint8x3_t svreinterpret_s8(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u16_x3)))
+svint8x3_t svreinterpret_s8(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s32_x3)))
+svint8x3_t svreinterpret_s8(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u32_x3)))
+svint8x3_t svreinterpret_s8(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s64_x3)))
+svint8x3_t svreinterpret_s8(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u64_x3)))
+svint8x3_t svreinterpret_s8(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f16_x3)))
+svint8x3_t svreinterpret_s8(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_bf16_x3)))
+svint8x3_t svreinterpret_s8(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f32_x3)))
+svint8x3_t svreinterpret_s8(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f64_x3)))
+svint8x3_t svreinterpret_s8(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s8_x3)))
+svuint8x3_t svreinterpret_u8(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u8_x3)))
+svuint8x3_t svreinterpret_u8(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s16_x3)))
+svuint8x3_t svreinterpret_u8(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u16_x3)))
+svuint8x3_t svreinterpret_u8(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s32_x3)))
+svuint8x3_t svreinterpret_u8(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u32_x3)))
+svuint8x3_t svreinterpret_u8(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s64_x3)))
+svuint8x3_t svreinterpret_u8(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u64_x3)))
+svuint8x3_t svreinterpret_u8(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f16_x3)))
+svuint8x3_t svreinterpret_u8(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_bf16_x3)))
+svuint8x3_t svreinterpret_u8(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f32_x3)))
+svuint8x3_t svreinterpret_u8(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f64_x3)))
+svuint8x3_t svreinterpret_u8(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s8_x3)))
+svint16x3_t svreinterpret_s16(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u8_x3)))
+svint16x3_t svreinterpret_s16(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s16_x3)))
+svint16x3_t svreinterpret_s16(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u16_x3)))
+svint16x3_t svreinterpret_s16(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s32_x3)))
+svint16x3_t svreinterpret_s16(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u32_x3)))
+svint16x3_t svreinterpret_s16(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s64_x3)))
+svint16x3_t svreinterpret_s16(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u64_x3)))
+svint16x3_t svreinterpret_s16(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f16_x3)))
+svint16x3_t svreinterpret_s16(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_bf16_x3)))
+svint16x3_t svreinterpret_s16(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f32_x3)))
+svint16x3_t svreinterpret_s16(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f64_x3)))
+svint16x3_t svreinterpret_s16(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s8_x3)))
+svuint16x3_t svreinterpret_u16(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u8_x3)))
+svuint16x3_t svreinterpret_u16(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s16_x3)))
+svuint16x3_t svreinterpret_u16(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u16_x3)))
+svuint16x3_t svreinterpret_u16(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s32_x3)))
+svuint16x3_t svreinterpret_u16(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u32_x3)))
+svuint16x3_t svreinterpret_u16(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s64_x3)))
+svuint16x3_t svreinterpret_u16(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u64_x3)))
+svuint16x3_t svreinterpret_u16(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f16_x3)))
+svuint16x3_t svreinterpret_u16(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_bf16_x3)))
+svuint16x3_t svreinterpret_u16(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f32_x3)))
+svuint16x3_t svreinterpret_u16(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f64_x3)))
+svuint16x3_t svreinterpret_u16(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s8_x3)))
+svint32x3_t svreinterpret_s32(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u8_x3)))
+svint32x3_t svreinterpret_s32(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s16_x3)))
+svint32x3_t svreinterpret_s32(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u16_x3)))
+svint32x3_t svreinterpret_s32(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s32_x3)))
+svint32x3_t svreinterpret_s32(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u32_x3)))
+svint32x3_t svreinterpret_s32(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s64_x3)))
+svint32x3_t svreinterpret_s32(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u64_x3)))
+svint32x3_t svreinterpret_s32(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f16_x3)))
+svint32x3_t svreinterpret_s32(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_bf16_x3)))
+svint32x3_t svreinterpret_s32(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f32_x3)))
+svint32x3_t svreinterpret_s32(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f64_x3)))
+svint32x3_t svreinterpret_s32(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s8_x3)))
+svuint32x3_t svreinterpret_u32(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u8_x3)))
+svuint32x3_t svreinterpret_u32(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s16_x3)))
+svuint32x3_t svreinterpret_u32(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u16_x3)))
+svuint32x3_t svreinterpret_u32(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s32_x3)))
+svuint32x3_t svreinterpret_u32(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u32_x3)))
+svuint32x3_t svreinterpret_u32(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s64_x3)))
+svuint32x3_t svreinterpret_u32(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u64_x3)))
+svuint32x3_t svreinterpret_u32(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f16_x3)))
+svuint32x3_t svreinterpret_u32(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_bf16_x3)))
+svuint32x3_t svreinterpret_u32(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f32_x3)))
+svuint32x3_t svreinterpret_u32(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f64_x3)))
+svuint32x3_t svreinterpret_u32(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s8_x3)))
+svint64x3_t svreinterpret_s64(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u8_x3)))
+svint64x3_t svreinterpret_s64(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s16_x3)))
+svint64x3_t svreinterpret_s64(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u16_x3)))
+svint64x3_t svreinterpret_s64(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s32_x3)))
+svint64x3_t svreinterpret_s64(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u32_x3)))
+svint64x3_t svreinterpret_s64(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s64_x3)))
+svint64x3_t svreinterpret_s64(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u64_x3)))
+svint64x3_t svreinterpret_s64(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f16_x3)))
+svint64x3_t svreinterpret_s64(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_bf16_x3)))
+svint64x3_t svreinterpret_s64(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f32_x3)))
+svint64x3_t svreinterpret_s64(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f64_x3)))
+svint64x3_t svreinterpret_s64(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s8_x3)))
+svuint64x3_t svreinterpret_u64(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u8_x3)))
+svuint64x3_t svreinterpret_u64(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s16_x3)))
+svuint64x3_t svreinterpret_u64(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u16_x3)))
+svuint64x3_t svreinterpret_u64(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s32_x3)))
+svuint64x3_t svreinterpret_u64(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u32_x3)))
+svuint64x3_t svreinterpret_u64(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s64_x3)))
+svuint64x3_t svreinterpret_u64(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u64_x3)))
+svuint64x3_t svreinterpret_u64(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f16_x3)))
+svuint64x3_t svreinterpret_u64(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_bf16_x3)))
+svuint64x3_t svreinterpret_u64(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f32_x3)))
+svuint64x3_t svreinterpret_u64(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f64_x3)))
+svuint64x3_t svreinterpret_u64(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s8_x3)))
+svfloat16x3_t svreinterpret_f16(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u8_x3)))
+svfloat16x3_t svreinterpret_f16(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s16_x3)))
+svfloat16x3_t svreinterpret_f16(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u16_x3)))
+svfloat16x3_t svreinterpret_f16(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s32_x3)))
+svfloat16x3_t svreinterpret_f16(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u32_x3)))
+svfloat16x3_t svreinterpret_f16(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s64_x3)))
+svfloat16x3_t svreinterpret_f16(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u64_x3)))
+svfloat16x3_t svreinterpret_f16(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f16_x3)))
+svfloat16x3_t svreinterpret_f16(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_bf16_x3)))
+svfloat16x3_t svreinterpret_f16(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f32_x3)))
+svfloat16x3_t svreinterpret_f16(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f64_x3)))
+svfloat16x3_t svreinterpret_f16(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s8_x3)))
+svbfloat16x3_t svreinterpret_bf16(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u8_x3)))
+svbfloat16x3_t svreinterpret_bf16(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s16_x3)))
+svbfloat16x3_t svreinterpret_bf16(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u16_x3)))
+svbfloat16x3_t svreinterpret_bf16(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s32_x3)))
+svbfloat16x3_t svreinterpret_bf16(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u32_x3)))
+svbfloat16x3_t svreinterpret_bf16(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s64_x3)))
+svbfloat16x3_t svreinterpret_bf16(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u64_x3)))
+svbfloat16x3_t svreinterpret_bf16(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f16_x3)))
+svbfloat16x3_t svreinterpret_bf16(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_bf16_x3)))
+svbfloat16x3_t svreinterpret_bf16(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f32_x3)))
+svbfloat16x3_t svreinterpret_bf16(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f64_x3)))
+svbfloat16x3_t svreinterpret_bf16(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s8_x3)))
+svfloat32x3_t svreinterpret_f32(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u8_x3)))
+svfloat32x3_t svreinterpret_f32(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s16_x3)))
+svfloat32x3_t svreinterpret_f32(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u16_x3)))
+svfloat32x3_t svreinterpret_f32(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s32_x3)))
+svfloat32x3_t svreinterpret_f32(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u32_x3)))
+svfloat32x3_t svreinterpret_f32(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s64_x3)))
+svfloat32x3_t svreinterpret_f32(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u64_x3)))
+svfloat32x3_t svreinterpret_f32(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f16_x3)))
+svfloat32x3_t svreinterpret_f32(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_bf16_x3)))
+svfloat32x3_t svreinterpret_f32(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f32_x3)))
+svfloat32x3_t svreinterpret_f32(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f64_x3)))
+svfloat32x3_t svreinterpret_f32(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s8_x3)))
+svfloat64x3_t svreinterpret_f64(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u8_x3)))
+svfloat64x3_t svreinterpret_f64(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s16_x3)))
+svfloat64x3_t svreinterpret_f64(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u16_x3)))
+svfloat64x3_t svreinterpret_f64(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s32_x3)))
+svfloat64x3_t svreinterpret_f64(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u32_x3)))
+svfloat64x3_t svreinterpret_f64(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s64_x3)))
+svfloat64x3_t svreinterpret_f64(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u64_x3)))
+svfloat64x3_t svreinterpret_f64(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f16_x3)))
+svfloat64x3_t svreinterpret_f64(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_bf16_x3)))
+svfloat64x3_t svreinterpret_f64(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f32_x3)))
+svfloat64x3_t svreinterpret_f64(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f64_x3)))
+svfloat64x3_t svreinterpret_f64(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s8_x4)))
+svint8x4_t svreinterpret_s8_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u8_x4)))
+svint8x4_t svreinterpret_s8_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s16_x4)))
+svint8x4_t svreinterpret_s8_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u16_x4)))
+svint8x4_t svreinterpret_s8_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s32_x4)))
+svint8x4_t svreinterpret_s8_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u32_x4)))
+svint8x4_t svreinterpret_s8_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s64_x4)))
+svint8x4_t svreinterpret_s8_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u64_x4)))
+svint8x4_t svreinterpret_s8_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f16_x4)))
+svint8x4_t svreinterpret_s8_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_bf16_x4)))
+svint8x4_t svreinterpret_s8_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f32_x4)))
+svint8x4_t svreinterpret_s8_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f64_x4)))
+svint8x4_t svreinterpret_s8_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s8_x4)))
+svuint8x4_t svreinterpret_u8_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u8_x4)))
+svuint8x4_t svreinterpret_u8_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s16_x4)))
+svuint8x4_t svreinterpret_u8_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u16_x4)))
+svuint8x4_t svreinterpret_u8_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s32_x4)))
+svuint8x4_t svreinterpret_u8_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u32_x4)))
+svuint8x4_t svreinterpret_u8_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s64_x4)))
+svuint8x4_t svreinterpret_u8_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u64_x4)))
+svuint8x4_t svreinterpret_u8_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f16_x4)))
+svuint8x4_t svreinterpret_u8_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_bf16_x4)))
+svuint8x4_t svreinterpret_u8_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f32_x4)))
+svuint8x4_t svreinterpret_u8_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f64_x4)))
+svuint8x4_t svreinterpret_u8_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s8_x4)))
+svint16x4_t svreinterpret_s16_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u8_x4)))
+svint16x4_t svreinterpret_s16_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s16_x4)))
+svint16x4_t svreinterpret_s16_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u16_x4)))
+svint16x4_t svreinterpret_s16_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s32_x4)))
+svint16x4_t svreinterpret_s16_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u32_x4)))
+svint16x4_t svreinterpret_s16_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s64_x4)))
+svint16x4_t svreinterpret_s16_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u64_x4)))
+svint16x4_t svreinterpret_s16_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f16_x4)))
+svint16x4_t svreinterpret_s16_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_bf16_x4)))
+svint16x4_t svreinterpret_s16_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f32_x4)))
+svint16x4_t svreinterpret_s16_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f64_x4)))
+svint16x4_t svreinterpret_s16_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s8_x4)))
+svuint16x4_t svreinterpret_u16_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u8_x4)))
+svuint16x4_t svreinterpret_u16_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s16_x4)))
+svuint16x4_t svreinterpret_u16_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u16_x4)))
+svuint16x4_t svreinterpret_u16_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s32_x4)))
+svuint16x4_t svreinterpret_u16_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u32_x4)))
+svuint16x4_t svreinterpret_u16_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s64_x4)))
+svuint16x4_t svreinterpret_u16_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u64_x4)))
+svuint16x4_t svreinterpret_u16_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f16_x4)))
+svuint16x4_t svreinterpret_u16_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_bf16_x4)))
+svuint16x4_t svreinterpret_u16_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f32_x4)))
+svuint16x4_t svreinterpret_u16_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f64_x4)))
+svuint16x4_t svreinterpret_u16_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s8_x4)))
+svint32x4_t svreinterpret_s32_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u8_x4)))
+svint32x4_t svreinterpret_s32_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s16_x4)))
+svint32x4_t svreinterpret_s32_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u16_x4)))
+svint32x4_t svreinterpret_s32_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s32_x4)))
+svint32x4_t svreinterpret_s32_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u32_x4)))
+svint32x4_t svreinterpret_s32_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s64_x4)))
+svint32x4_t svreinterpret_s32_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u64_x4)))
+svint32x4_t svreinterpret_s32_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f16_x4)))
+svint32x4_t svreinterpret_s32_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_bf16_x4)))
+svint32x4_t svreinterpret_s32_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f32_x4)))
+svint32x4_t svreinterpret_s32_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f64_x4)))
+svint32x4_t svreinterpret_s32_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s8_x4)))
+svuint32x4_t svreinterpret_u32_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u8_x4)))
+svuint32x4_t svreinterpret_u32_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s16_x4)))
+svuint32x4_t svreinterpret_u32_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u16_x4)))
+svuint32x4_t svreinterpret_u32_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s32_x4)))
+svuint32x4_t svreinterpret_u32_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u32_x4)))
+svuint32x4_t svreinterpret_u32_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s64_x4)))
+svuint32x4_t svreinterpret_u32_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u64_x4)))
+svuint32x4_t svreinterpret_u32_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f16_x4)))
+svuint32x4_t svreinterpret_u32_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_bf16_x4)))
+svuint32x4_t svreinterpret_u32_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f32_x4)))
+svuint32x4_t svreinterpret_u32_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f64_x4)))
+svuint32x4_t svreinterpret_u32_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s8_x4)))
+svint64x4_t svreinterpret_s64_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u8_x4)))
+svint64x4_t svreinterpret_s64_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s16_x4)))
+svint64x4_t svreinterpret_s64_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u16_x4)))
+svint64x4_t svreinterpret_s64_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s32_x4)))
+svint64x4_t svreinterpret_s64_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u32_x4)))
+svint64x4_t svreinterpret_s64_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s64_x4)))
+svint64x4_t svreinterpret_s64_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u64_x4)))
+svint64x4_t svreinterpret_s64_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f16_x4)))
+svint64x4_t svreinterpret_s64_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_bf16_x4)))
+svint64x4_t svreinterpret_s64_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f32_x4)))
+svint64x4_t svreinterpret_s64_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f64_x4)))
+svint64x4_t svreinterpret_s64_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s8_x4)))
+svuint64x4_t svreinterpret_u64_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u8_x4)))
+svuint64x4_t svreinterpret_u64_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s16_x4)))
+svuint64x4_t svreinterpret_u64_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u16_x4)))
+svuint64x4_t svreinterpret_u64_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s32_x4)))
+svuint64x4_t svreinterpret_u64_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u32_x4)))
+svuint64x4_t svreinterpret_u64_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s64_x4)))
+svuint64x4_t svreinterpret_u64_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u64_x4)))
+svuint64x4_t svreinterpret_u64_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f16_x4)))
+svuint64x4_t svreinterpret_u64_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_bf16_x4)))
+svuint64x4_t svreinterpret_u64_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f32_x4)))
+svuint64x4_t svreinterpret_u64_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f64_x4)))
+svuint64x4_t svreinterpret_u64_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s8_x4)))
+svfloat16x4_t svreinterpret_f16_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u8_x4)))
+svfloat16x4_t svreinterpret_f16_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s16_x4)))
+svfloat16x4_t svreinterpret_f16_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u16_x4)))
+svfloat16x4_t svreinterpret_f16_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s32_x4)))
+svfloat16x4_t svreinterpret_f16_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u32_x4)))
+svfloat16x4_t svreinterpret_f16_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s64_x4)))
+svfloat16x4_t svreinterpret_f16_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u64_x4)))
+svfloat16x4_t svreinterpret_f16_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f16_x4)))
+svfloat16x4_t svreinterpret_f16_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_bf16_x4)))
+svfloat16x4_t svreinterpret_f16_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f32_x4)))
+svfloat16x4_t svreinterpret_f16_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f64_x4)))
+svfloat16x4_t svreinterpret_f16_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s8_x4)))
+svbfloat16x4_t svreinterpret_bf16_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u8_x4)))
+svbfloat16x4_t svreinterpret_bf16_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s16_x4)))
+svbfloat16x4_t svreinterpret_bf16_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u16_x4)))
+svbfloat16x4_t svreinterpret_bf16_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s32_x4)))
+svbfloat16x4_t svreinterpret_bf16_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u32_x4)))
+svbfloat16x4_t svreinterpret_bf16_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s64_x4)))
+svbfloat16x4_t svreinterpret_bf16_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u64_x4)))
+svbfloat16x4_t svreinterpret_bf16_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f16_x4)))
+svbfloat16x4_t svreinterpret_bf16_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_bf16_x4)))
+svbfloat16x4_t svreinterpret_bf16_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f32_x4)))
+svbfloat16x4_t svreinterpret_bf16_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f64_x4)))
+svbfloat16x4_t svreinterpret_bf16_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s8_x4)))
+svfloat32x4_t svreinterpret_f32_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u8_x4)))
+svfloat32x4_t svreinterpret_f32_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s16_x4)))
+svfloat32x4_t svreinterpret_f32_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u16_x4)))
+svfloat32x4_t svreinterpret_f32_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s32_x4)))
+svfloat32x4_t svreinterpret_f32_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u32_x4)))
+svfloat32x4_t svreinterpret_f32_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s64_x4)))
+svfloat32x4_t svreinterpret_f32_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u64_x4)))
+svfloat32x4_t svreinterpret_f32_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f16_x4)))
+svfloat32x4_t svreinterpret_f32_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_bf16_x4)))
+svfloat32x4_t svreinterpret_f32_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f32_x4)))
+svfloat32x4_t svreinterpret_f32_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f64_x4)))
+svfloat32x4_t svreinterpret_f32_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s8_x4)))
+svfloat64x4_t svreinterpret_f64_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u8_x4)))
+svfloat64x4_t svreinterpret_f64_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s16_x4)))
+svfloat64x4_t svreinterpret_f64_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u16_x4)))
+svfloat64x4_t svreinterpret_f64_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s32_x4)))
+svfloat64x4_t svreinterpret_f64_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u32_x4)))
+svfloat64x4_t svreinterpret_f64_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s64_x4)))
+svfloat64x4_t svreinterpret_f64_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u64_x4)))
+svfloat64x4_t svreinterpret_f64_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f16_x4)))
+svfloat64x4_t svreinterpret_f64_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_bf16_x4)))
+svfloat64x4_t svreinterpret_f64_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f32_x4)))
+svfloat64x4_t svreinterpret_f64_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f64_x4)))
+svfloat64x4_t svreinterpret_f64_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s8_x4)))
+svint8x4_t svreinterpret_s8(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u8_x4)))
+svint8x4_t svreinterpret_s8(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s16_x4)))
+svint8x4_t svreinterpret_s8(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u16_x4)))
+svint8x4_t svreinterpret_s8(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s32_x4)))
+svint8x4_t svreinterpret_s8(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u32_x4)))
+svint8x4_t svreinterpret_s8(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s64_x4)))
+svint8x4_t svreinterpret_s8(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u64_x4)))
+svint8x4_t svreinterpret_s8(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f16_x4)))
+svint8x4_t svreinterpret_s8(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_bf16_x4)))
+svint8x4_t svreinterpret_s8(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f32_x4)))
+svint8x4_t svreinterpret_s8(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f64_x4)))
+svint8x4_t svreinterpret_s8(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s8_x4)))
+svuint8x4_t svreinterpret_u8(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u8_x4)))
+svuint8x4_t svreinterpret_u8(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s16_x4)))
+svuint8x4_t svreinterpret_u8(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u16_x4)))
+svuint8x4_t svreinterpret_u8(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s32_x4)))
+svuint8x4_t svreinterpret_u8(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u32_x4)))
+svuint8x4_t svreinterpret_u8(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s64_x4)))
+svuint8x4_t svreinterpret_u8(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u64_x4)))
+svuint8x4_t svreinterpret_u8(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f16_x4)))
+svuint8x4_t svreinterpret_u8(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_bf16_x4)))
+svuint8x4_t svreinterpret_u8(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f32_x4)))
+svuint8x4_t svreinterpret_u8(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f64_x4)))
+svuint8x4_t svreinterpret_u8(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s8_x4)))
+svint16x4_t svreinterpret_s16(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u8_x4)))
+svint16x4_t svreinterpret_s16(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s16_x4)))
+svint16x4_t svreinterpret_s16(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u16_x4)))
+svint16x4_t svreinterpret_s16(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s32_x4)))
+svint16x4_t svreinterpret_s16(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u32_x4)))
+svint16x4_t svreinterpret_s16(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s64_x4)))
+svint16x4_t svreinterpret_s16(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u64_x4)))
+svint16x4_t svreinterpret_s16(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f16_x4)))
+svint16x4_t svreinterpret_s16(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_bf16_x4)))
+svint16x4_t svreinterpret_s16(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f32_x4)))
+svint16x4_t svreinterpret_s16(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f64_x4)))
+svint16x4_t svreinterpret_s16(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s8_x4)))
+svuint16x4_t svreinterpret_u16(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u8_x4)))
+svuint16x4_t svreinterpret_u16(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s16_x4)))
+svuint16x4_t svreinterpret_u16(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u16_x4)))
+svuint16x4_t svreinterpret_u16(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s32_x4)))
+svuint16x4_t svreinterpret_u16(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u32_x4)))
+svuint16x4_t svreinterpret_u16(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s64_x4)))
+svuint16x4_t svreinterpret_u16(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u64_x4)))
+svuint16x4_t svreinterpret_u16(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f16_x4)))
+svuint16x4_t svreinterpret_u16(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_bf16_x4)))
+svuint16x4_t svreinterpret_u16(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f32_x4)))
+svuint16x4_t svreinterpret_u16(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f64_x4)))
+svuint16x4_t svreinterpret_u16(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s8_x4)))
+svint32x4_t svreinterpret_s32(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u8_x4)))
+svint32x4_t svreinterpret_s32(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s16_x4)))
+svint32x4_t svreinterpret_s32(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u16_x4)))
+svint32x4_t svreinterpret_s32(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s32_x4)))
+svint32x4_t svreinterpret_s32(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u32_x4)))
+svint32x4_t svreinterpret_s32(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s64_x4)))
+svint32x4_t svreinterpret_s32(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u64_x4)))
+svint32x4_t svreinterpret_s32(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f16_x4)))
+svint32x4_t svreinterpret_s32(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_bf16_x4)))
+svint32x4_t svreinterpret_s32(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f32_x4)))
+svint32x4_t svreinterpret_s32(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f64_x4)))
+svint32x4_t svreinterpret_s32(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s8_x4)))
+svuint32x4_t svreinterpret_u32(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u8_x4)))
+svuint32x4_t svreinterpret_u32(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s16_x4)))
+svuint32x4_t svreinterpret_u32(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u16_x4)))
+svuint32x4_t svreinterpret_u32(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s32_x4)))
+svuint32x4_t svreinterpret_u32(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u32_x4)))
+svuint32x4_t svreinterpret_u32(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s64_x4)))
+svuint32x4_t svreinterpret_u32(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u64_x4)))
+svuint32x4_t svreinterpret_u32(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f16_x4)))
+svuint32x4_t svreinterpret_u32(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_bf16_x4)))
+svuint32x4_t svreinterpret_u32(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f32_x4)))
+svuint32x4_t svreinterpret_u32(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f64_x4)))
+svuint32x4_t svreinterpret_u32(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s8_x4)))
+svint64x4_t svreinterpret_s64(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u8_x4)))
+svint64x4_t svreinterpret_s64(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s16_x4)))
+svint64x4_t svreinterpret_s64(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u16_x4)))
+svint64x4_t svreinterpret_s64(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s32_x4)))
+svint64x4_t svreinterpret_s64(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u32_x4)))
+svint64x4_t svreinterpret_s64(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s64_x4)))
+svint64x4_t svreinterpret_s64(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u64_x4)))
+svint64x4_t svreinterpret_s64(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f16_x4)))
+svint64x4_t svreinterpret_s64(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_bf16_x4)))
+svint64x4_t svreinterpret_s64(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f32_x4)))
+svint64x4_t svreinterpret_s64(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f64_x4)))
+svint64x4_t svreinterpret_s64(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s8_x4)))
+svuint64x4_t svreinterpret_u64(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u8_x4)))
+svuint64x4_t svreinterpret_u64(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s16_x4)))
+svuint64x4_t svreinterpret_u64(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u16_x4)))
+svuint64x4_t svreinterpret_u64(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s32_x4)))
+svuint64x4_t svreinterpret_u64(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u32_x4)))
+svuint64x4_t svreinterpret_u64(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s64_x4)))
+svuint64x4_t svreinterpret_u64(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u64_x4)))
+svuint64x4_t svreinterpret_u64(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f16_x4)))
+svuint64x4_t svreinterpret_u64(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_bf16_x4)))
+svuint64x4_t svreinterpret_u64(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f32_x4)))
+svuint64x4_t svreinterpret_u64(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f64_x4)))
+svuint64x4_t svreinterpret_u64(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s8_x4)))
+svfloat16x4_t svreinterpret_f16(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u8_x4)))
+svfloat16x4_t svreinterpret_f16(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s16_x4)))
+svfloat16x4_t svreinterpret_f16(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u16_x4)))
+svfloat16x4_t svreinterpret_f16(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s32_x4)))
+svfloat16x4_t svreinterpret_f16(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u32_x4)))
+svfloat16x4_t svreinterpret_f16(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s64_x4)))
+svfloat16x4_t svreinterpret_f16(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u64_x4)))
+svfloat16x4_t svreinterpret_f16(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f16_x4)))
+svfloat16x4_t svreinterpret_f16(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_bf16_x4)))
+svfloat16x4_t svreinterpret_f16(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f32_x4)))
+svfloat16x4_t svreinterpret_f16(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f64_x4)))
+svfloat16x4_t svreinterpret_f16(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s8_x4)))
+svbfloat16x4_t svreinterpret_bf16(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u8_x4)))
+svbfloat16x4_t svreinterpret_bf16(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s16_x4)))
+svbfloat16x4_t svreinterpret_bf16(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u16_x4)))
+svbfloat16x4_t svreinterpret_bf16(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s32_x4)))
+svbfloat16x4_t svreinterpret_bf16(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u32_x4)))
+svbfloat16x4_t svreinterpret_bf16(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s64_x4)))
+svbfloat16x4_t svreinterpret_bf16(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u64_x4)))
+svbfloat16x4_t svreinterpret_bf16(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f16_x4)))
+svbfloat16x4_t svreinterpret_bf16(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_bf16_x4)))
+svbfloat16x4_t svreinterpret_bf16(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f32_x4)))
+svbfloat16x4_t svreinterpret_bf16(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f64_x4)))
+svbfloat16x4_t svreinterpret_bf16(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s8_x4)))
+svfloat32x4_t svreinterpret_f32(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u8_x4)))
+svfloat32x4_t svreinterpret_f32(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s16_x4)))
+svfloat32x4_t svreinterpret_f32(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u16_x4)))
+svfloat32x4_t svreinterpret_f32(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s32_x4)))
+svfloat32x4_t svreinterpret_f32(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u32_x4)))
+svfloat32x4_t svreinterpret_f32(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s64_x4)))
+svfloat32x4_t svreinterpret_f32(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u64_x4)))
+svfloat32x4_t svreinterpret_f32(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f16_x4)))
+svfloat32x4_t svreinterpret_f32(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_bf16_x4)))
+svfloat32x4_t svreinterpret_f32(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f32_x4)))
+svfloat32x4_t svreinterpret_f32(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f64_x4)))
+svfloat32x4_t svreinterpret_f32(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s8_x4)))
+svfloat64x4_t svreinterpret_f64(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u8_x4)))
+svfloat64x4_t svreinterpret_f64(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s16_x4)))
+svfloat64x4_t svreinterpret_f64(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u16_x4)))
+svfloat64x4_t svreinterpret_f64(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s32_x4)))
+svfloat64x4_t svreinterpret_f64(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u32_x4)))
+svfloat64x4_t svreinterpret_f64(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s64_x4)))
+svfloat64x4_t svreinterpret_f64(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u64_x4)))
+svfloat64x4_t svreinterpret_f64(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f16_x4)))
+svfloat64x4_t svreinterpret_f64(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_bf16_x4)))
+svfloat64x4_t svreinterpret_f64(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f32_x4)))
+svfloat64x4_t svreinterpret_f64(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f64_x4)))
+svfloat64x4_t svreinterpret_f64(svfloat64x4_t op);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_x2)))
+svfloat32x2_t svcvt_f32_f16_x2(svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtl_f32_f16_x2)))
+svfloat32x2_t svcvtl_f32_f16_x2(svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_x2)))
+svfloat32x2_t svcvt_f32(svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtl_f32_f16_x2)))
+svfloat32x2_t svcvtl_f32(svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u8_x2)))
+svuint8x2_t svadd_single_u8_x2(svuint8x2_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u32_x2)))
+svuint32x2_t svadd_single_u32_x2(svuint32x2_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u64_x2)))
+svuint64x2_t svadd_single_u64_x2(svuint64x2_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u16_x2)))
+svuint16x2_t svadd_single_u16_x2(svuint16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s8_x2)))
+svint8x2_t svadd_single_s8_x2(svint8x2_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s32_x2)))
+svint32x2_t svadd_single_s32_x2(svint32x2_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s64_x2)))
+svint64x2_t svadd_single_s64_x2(svint64x2_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s16_x2)))
+svint16x2_t svadd_single_s16_x2(svint16x2_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u8_x4)))
+svuint8x4_t svadd_single_u8_x4(svuint8x4_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u32_x4)))
+svuint32x4_t svadd_single_u32_x4(svuint32x4_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u64_x4)))
+svuint64x4_t svadd_single_u64_x4(svuint64x4_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u16_x4)))
+svuint16x4_t svadd_single_u16_x4(svuint16x4_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s8_x4)))
+svint8x4_t svadd_single_s8_x4(svint8x4_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s32_x4)))
+svint32x4_t svadd_single_s32_x4(svint32x4_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s64_x4)))
+svint64x4_t svadd_single_s64_x4(svint64x4_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s16_x4)))
+svint16x4_t svadd_single_s16_x4(svint16x4_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f64_x2)))
+svfloat64x2_t svclamp_single_f64_x2(svfloat64x2_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f32_x2)))
+svfloat32x2_t svclamp_single_f32_x2(svfloat32x2_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f16_x2)))
+svfloat16x2_t svclamp_single_f16_x2(svfloat16x2_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s8_x2)))
+svint8x2_t svclamp_single_s8_x2(svint8x2_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s32_x2)))
+svint32x2_t svclamp_single_s32_x2(svint32x2_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s64_x2)))
+svint64x2_t svclamp_single_s64_x2(svint64x2_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s16_x2)))
+svint16x2_t svclamp_single_s16_x2(svint16x2_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u8_x2)))
+svuint8x2_t svclamp_single_u8_x2(svuint8x2_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u32_x2)))
+svuint32x2_t svclamp_single_u32_x2(svuint32x2_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u64_x2)))
+svuint64x2_t svclamp_single_u64_x2(svuint64x2_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u16_x2)))
+svuint16x2_t svclamp_single_u16_x2(svuint16x2_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f64_x4)))
+svfloat64x4_t svclamp_single_f64_x4(svfloat64x4_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f32_x4)))
+svfloat32x4_t svclamp_single_f32_x4(svfloat32x4_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f16_x4)))
+svfloat16x4_t svclamp_single_f16_x4(svfloat16x4_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s8_x4)))
+svint8x4_t svclamp_single_s8_x4(svint8x4_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s32_x4)))
+svint32x4_t svclamp_single_s32_x4(svint32x4_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s64_x4)))
+svint64x4_t svclamp_single_s64_x4(svint64x4_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s16_x4)))
+svint16x4_t svclamp_single_s16_x4(svint16x4_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u8_x4)))
+svuint8x4_t svclamp_single_u8_x4(svuint8x4_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u32_x4)))
+svuint32x4_t svclamp_single_u32_x4(svuint32x4_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u64_x4)))
+svuint64x4_t svclamp_single_u64_x4(svuint64x4_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u16_x4)))
+svuint16x4_t svclamp_single_u16_x4(svuint16x4_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_x2)))
+svbfloat16_t svcvt_bf16_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_x2)))
+svfloat16_t svcvt_f16_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_x2)))
+svint32x2_t svcvt_s32_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_x2)))
+svuint32x2_t svcvt_u32_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_x4)))
+svint32x4_t svcvt_s32_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_x4)))
+svuint32x4_t svcvt_u32_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_x2)))
+svfloat32x2_t svcvt_f32_s32_x2(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_x4)))
+svfloat32x4_t svcvt_f32_s32_x4(svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_x2)))
+svfloat32x2_t svcvt_f32_u32_x2(svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_x4)))
+svfloat32x4_t svcvt_f32_u32_x4(svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtn_bf16_f32_x2)))
+svbfloat16_t svcvtn_bf16_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtn_f16_f32_x2)))
+svfloat16_t svcvtn_f16_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f64_x2)))
+svfloat64x2_t svmax_single_f64_x2(svfloat64x2_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f32_x2)))
+svfloat32x2_t svmax_single_f32_x2(svfloat32x2_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f16_x2)))
+svfloat16x2_t svmax_single_f16_x2(svfloat16x2_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s8_x2)))
+svint8x2_t svmax_single_s8_x2(svint8x2_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s32_x2)))
+svint32x2_t svmax_single_s32_x2(svint32x2_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s64_x2)))
+svint64x2_t svmax_single_s64_x2(svint64x2_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s16_x2)))
+svint16x2_t svmax_single_s16_x2(svint16x2_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u8_x2)))
+svuint8x2_t svmax_single_u8_x2(svuint8x2_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u32_x2)))
+svuint32x2_t svmax_single_u32_x2(svuint32x2_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u64_x2)))
+svuint64x2_t svmax_single_u64_x2(svuint64x2_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u16_x2)))
+svuint16x2_t svmax_single_u16_x2(svuint16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f64_x4)))
+svfloat64x4_t svmax_single_f64_x4(svfloat64x4_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f32_x4)))
+svfloat32x4_t svmax_single_f32_x4(svfloat32x4_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f16_x4)))
+svfloat16x4_t svmax_single_f16_x4(svfloat16x4_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s8_x4)))
+svint8x4_t svmax_single_s8_x4(svint8x4_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s32_x4)))
+svint32x4_t svmax_single_s32_x4(svint32x4_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s64_x4)))
+svint64x4_t svmax_single_s64_x4(svint64x4_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s16_x4)))
+svint16x4_t svmax_single_s16_x4(svint16x4_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u8_x4)))
+svuint8x4_t svmax_single_u8_x4(svuint8x4_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u32_x4)))
+svuint32x4_t svmax_single_u32_x4(svuint32x4_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u64_x4)))
+svuint64x4_t svmax_single_u64_x4(svuint64x4_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u16_x4)))
+svuint16x4_t svmax_single_u16_x4(svuint16x4_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_x2)))
+svfloat64x2_t svmax_f64_x2(svfloat64x2_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_x2)))
+svfloat32x2_t svmax_f32_x2(svfloat32x2_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_x2)))
+svfloat16x2_t svmax_f16_x2(svfloat16x2_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_x2)))
+svint8x2_t svmax_s8_x2(svint8x2_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_x2)))
+svint32x2_t svmax_s32_x2(svint32x2_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_x2)))
+svint64x2_t svmax_s64_x2(svint64x2_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_x2)))
+svint16x2_t svmax_s16_x2(svint16x2_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_x2)))
+svuint8x2_t svmax_u8_x2(svuint8x2_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_x2)))
+svuint32x2_t svmax_u32_x2(svuint32x2_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_x2)))
+svuint64x2_t svmax_u64_x2(svuint64x2_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_x2)))
+svuint16x2_t svmax_u16_x2(svuint16x2_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_x4)))
+svfloat64x4_t svmax_f64_x4(svfloat64x4_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_x4)))
+svfloat32x4_t svmax_f32_x4(svfloat32x4_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_x4)))
+svfloat16x4_t svmax_f16_x4(svfloat16x4_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_x4)))
+svint8x4_t svmax_s8_x4(svint8x4_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_x4)))
+svint32x4_t svmax_s32_x4(svint32x4_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_x4)))
+svint64x4_t svmax_s64_x4(svint64x4_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_x4)))
+svint16x4_t svmax_s16_x4(svint16x4_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_x4)))
+svuint8x4_t svmax_u8_x4(svuint8x4_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_x4)))
+svuint32x4_t svmax_u32_x4(svuint32x4_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_x4)))
+svuint64x4_t svmax_u64_x4(svuint64x4_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_x4)))
+svuint16x4_t svmax_u16_x4(svuint16x4_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f64_x2)))
+svfloat64x2_t svmaxnm_single_f64_x2(svfloat64x2_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f32_x2)))
+svfloat32x2_t svmaxnm_single_f32_x2(svfloat32x2_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f16_x2)))
+svfloat16x2_t svmaxnm_single_f16_x2(svfloat16x2_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f64_x4)))
+svfloat64x4_t svmaxnm_single_f64_x4(svfloat64x4_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f32_x4)))
+svfloat32x4_t svmaxnm_single_f32_x4(svfloat32x4_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f16_x4)))
+svfloat16x4_t svmaxnm_single_f16_x4(svfloat16x4_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_x2)))
+svfloat64x2_t svmaxnm_f64_x2(svfloat64x2_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_x2)))
+svfloat32x2_t svmaxnm_f32_x2(svfloat32x2_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x2)))
+svfloat16x2_t svmaxnm_f16_x2(svfloat16x2_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_x4)))
+svfloat64x4_t svmaxnm_f64_x4(svfloat64x4_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_x4)))
+svfloat32x4_t svmaxnm_f32_x4(svfloat32x4_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x4)))
+svfloat16x4_t svmaxnm_f16_x4(svfloat16x4_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f64_x2)))
+svfloat64x2_t svmin_single_f64_x2(svfloat64x2_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f32_x2)))
+svfloat32x2_t svmin_single_f32_x2(svfloat32x2_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f16_x2)))
+svfloat16x2_t svmin_single_f16_x2(svfloat16x2_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s8_x2)))
+svint8x2_t svmin_single_s8_x2(svint8x2_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s32_x2)))
+svint32x2_t svmin_single_s32_x2(svint32x2_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s64_x2)))
+svint64x2_t svmin_single_s64_x2(svint64x2_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s16_x2)))
+svint16x2_t svmin_single_s16_x2(svint16x2_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u8_x2)))
+svuint8x2_t svmin_single_u8_x2(svuint8x2_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u32_x2)))
+svuint32x2_t svmin_single_u32_x2(svuint32x2_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u64_x2)))
+svuint64x2_t svmin_single_u64_x2(svuint64x2_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u16_x2)))
+svuint16x2_t svmin_single_u16_x2(svuint16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f64_x4)))
+svfloat64x4_t svmin_single_f64_x4(svfloat64x4_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f32_x4)))
+svfloat32x4_t svmin_single_f32_x4(svfloat32x4_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f16_x4)))
+svfloat16x4_t svmin_single_f16_x4(svfloat16x4_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s8_x4)))
+svint8x4_t svmin_single_s8_x4(svint8x4_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s32_x4)))
+svint32x4_t svmin_single_s32_x4(svint32x4_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s64_x4)))
+svint64x4_t svmin_single_s64_x4(svint64x4_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s16_x4)))
+svint16x4_t svmin_single_s16_x4(svint16x4_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u8_x4)))
+svuint8x4_t svmin_single_u8_x4(svuint8x4_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u32_x4)))
+svuint32x4_t svmin_single_u32_x4(svuint32x4_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u64_x4)))
+svuint64x4_t svmin_single_u64_x4(svuint64x4_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u16_x4)))
+svuint16x4_t svmin_single_u16_x4(svuint16x4_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_x2)))
+svfloat64x2_t svmin_f64_x2(svfloat64x2_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_x2)))
+svfloat32x2_t svmin_f32_x2(svfloat32x2_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_x2)))
+svfloat16x2_t svmin_f16_x2(svfloat16x2_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_x2)))
+svint8x2_t svmin_s8_x2(svint8x2_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_x2)))
+svint32x2_t svmin_s32_x2(svint32x2_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_x2)))
+svint64x2_t svmin_s64_x2(svint64x2_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_x2)))
+svint16x2_t svmin_s16_x2(svint16x2_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_x2)))
+svuint8x2_t svmin_u8_x2(svuint8x2_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_x2)))
+svuint32x2_t svmin_u32_x2(svuint32x2_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_x2)))
+svuint64x2_t svmin_u64_x2(svuint64x2_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_x2)))
+svuint16x2_t svmin_u16_x2(svuint16x2_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_x4)))
+svfloat64x4_t svmin_f64_x4(svfloat64x4_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_x4)))
+svfloat32x4_t svmin_f32_x4(svfloat32x4_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_x4)))
+svfloat16x4_t svmin_f16_x4(svfloat16x4_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_x4)))
+svint8x4_t svmin_s8_x4(svint8x4_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_x4)))
+svint32x4_t svmin_s32_x4(svint32x4_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_x4)))
+svint64x4_t svmin_s64_x4(svint64x4_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_x4)))
+svint16x4_t svmin_s16_x4(svint16x4_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_x4)))
+svuint8x4_t svmin_u8_x4(svuint8x4_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_x4)))
+svuint32x4_t svmin_u32_x4(svuint32x4_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_x4)))
+svuint64x4_t svmin_u64_x4(svuint64x4_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_x4)))
+svuint16x4_t svmin_u16_x4(svuint16x4_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f64_x2)))
+svfloat64x2_t svminnm_single_f64_x2(svfloat64x2_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f32_x2)))
+svfloat32x2_t svminnm_single_f32_x2(svfloat32x2_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f16_x2)))
+svfloat16x2_t svminnm_single_f16_x2(svfloat16x2_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f64_x4)))
+svfloat64x4_t svminnm_single_f64_x4(svfloat64x4_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f32_x4)))
+svfloat32x4_t svminnm_single_f32_x4(svfloat32x4_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f16_x4)))
+svfloat16x4_t svminnm_single_f16_x4(svfloat16x4_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_x2)))
+svfloat64x2_t svminnm_f64_x2(svfloat64x2_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_x2)))
+svfloat32x2_t svminnm_f32_x2(svfloat32x2_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_x2)))
+svfloat16x2_t svminnm_f16_x2(svfloat16x2_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_x4)))
+svfloat64x4_t svminnm_f64_x4(svfloat64x4_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_x4)))
+svfloat32x4_t svminnm_f32_x4(svfloat32x4_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_x4)))
+svfloat16x4_t svminnm_f16_x4(svfloat16x4_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_s16_s32_x2)))
+svint16_t svqcvt_s16_s32_x2(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_s16_s64_x4)))
+svint16_t svqcvt_s16_s64_x4(svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_s8_s32_x4)))
+svint8_t svqcvt_s8_s32_x4(svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_s32_x2)))
+svuint16_t svqcvt_u16_s32_x2(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_u32_x2)))
+svuint16_t svqcvt_u16_u32_x2(svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_s64_x4)))
+svuint16_t svqcvt_u16_s64_x4(svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_u64_x4)))
+svuint16_t svqcvt_u16_u64_x4(svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u8_s32_x4)))
+svuint8_t svqcvt_u8_s32_x4(svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u8_u32_x4)))
+svuint8_t svqcvt_u8_u32_x4(svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_s16_s64_x4)))
+svint16_t svqcvtn_s16_s64_x4(svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_s8_s32_x4)))
+svint8_t svqcvtn_s8_s32_x4(svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_s64_x4)))
+svuint16_t svqcvtn_u16_s64_x4(svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_u64_x4)))
+svuint16_t svqcvtn_u16_u64_x4(svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u8_s32_x4)))
+svuint8_t svqcvtn_u8_s32_x4(svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u8_u32_x4)))
+svuint8_t svqcvtn_u8_u32_x4(svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s8_x2)))
+svint8x2_t svqdmulh_single_s8_x2(svint8x2_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s32_x2)))
+svint32x2_t svqdmulh_single_s32_x2(svint32x2_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s64_x2)))
+svint64x2_t svqdmulh_single_s64_x2(svint64x2_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s16_x2)))
+svint16x2_t svqdmulh_single_s16_x2(svint16x2_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s8_x4)))
+svint8x4_t svqdmulh_single_s8_x4(svint8x4_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s32_x4)))
+svint32x4_t svqdmulh_single_s32_x4(svint32x4_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s64_x4)))
+svint64x4_t svqdmulh_single_s64_x4(svint64x4_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s16_x4)))
+svint16x4_t svqdmulh_single_s16_x4(svint16x4_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s8_x2)))
+svint8x2_t svqdmulh_s8_x2(svint8x2_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s32_x2)))
+svint32x2_t svqdmulh_s32_x2(svint32x2_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s64_x2)))
+svint64x2_t svqdmulh_s64_x2(svint64x2_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s16_x2)))
+svint16x2_t svqdmulh_s16_x2(svint16x2_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s8_x4)))
+svint8x4_t svqdmulh_s8_x4(svint8x4_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s32_x4)))
+svint32x4_t svqdmulh_s32_x4(svint32x4_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s64_x4)))
+svint64x4_t svqdmulh_s64_x4(svint64x4_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s16_x4)))
+svint16x4_t svqdmulh_s16_x4(svint16x4_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_s16_s32_x2)))
+svint16_t svqrshr_n_s16_s32_x2(svint32x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_u16_u32_x2)))
+svuint16_t svqrshr_n_u16_u32_x2(svuint32x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_s8_s32_x4)))
+svint8_t svqrshr_n_s8_s32_x4(svint32x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_s16_s64_x4)))
+svint16_t svqrshr_n_s16_s64_x4(svint64x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_u8_u32_x4)))
+svuint8_t svqrshr_n_u8_u32_x4(svuint32x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_u16_u64_x4)))
+svuint16_t svqrshr_n_u16_u64_x4(svuint64x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_s8_s32_x4)))
+svint8_t svqrshrn_n_s8_s32_x4(svint32x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_s16_s64_x4)))
+svint16_t svqrshrn_n_s16_s64_x4(svint64x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_u8_u32_x4)))
+svuint8_t svqrshrn_n_u8_u32_x4(svuint32x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_u16_u64_x4)))
+svuint16_t svqrshrn_n_u16_u64_x4(svuint64x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshru_n_u16_s32_x2)))
+svuint16_t svqrshru_n_u16_s32_x2(svint32x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshru_n_u8_s32_x4)))
+svuint8_t svqrshru_n_u8_s32_x4(svint32x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshru_n_u16_s64_x4)))
+svuint16_t svqrshru_n_u16_s64_x4(svint64x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrun_n_u8_s32_x4)))
+svuint8_t svqrshrun_n_u8_s32_x4(svint32x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrun_n_u16_s64_x4)))
+svuint16_t svqrshrun_n_u16_s64_x4(svint64x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_x2)))
+svfloat32x2_t svrinta_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_x4)))
+svfloat32x4_t svrinta_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_x2)))
+svfloat32x2_t svrintm_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_x4)))
+svfloat32x4_t svrintm_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_x2)))
+svfloat32x2_t svrintn_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_x4)))
+svfloat32x4_t svrintn_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_x2)))
+svfloat32x2_t svrintp_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_x4)))
+svfloat32x4_t svrintp_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s8_x2)))
+svint8x2_t svrshl_single_s8_x2(svint8x2_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s32_x2)))
+svint32x2_t svrshl_single_s32_x2(svint32x2_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s64_x2)))
+svint64x2_t svrshl_single_s64_x2(svint64x2_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s16_x2)))
+svint16x2_t svrshl_single_s16_x2(svint16x2_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u8_x2)))
+svuint8x2_t svrshl_single_u8_x2(svuint8x2_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u32_x2)))
+svuint32x2_t svrshl_single_u32_x2(svuint32x2_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u64_x2)))
+svuint64x2_t svrshl_single_u64_x2(svuint64x2_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u16_x2)))
+svuint16x2_t svrshl_single_u16_x2(svuint16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s8_x4)))
+svint8x4_t svrshl_single_s8_x4(svint8x4_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s32_x4)))
+svint32x4_t svrshl_single_s32_x4(svint32x4_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s64_x4)))
+svint64x4_t svrshl_single_s64_x4(svint64x4_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s16_x4)))
+svint16x4_t svrshl_single_s16_x4(svint16x4_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u8_x4)))
+svuint8x4_t svrshl_single_u8_x4(svuint8x4_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u32_x4)))
+svuint32x4_t svrshl_single_u32_x4(svuint32x4_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u64_x4)))
+svuint64x4_t svrshl_single_u64_x4(svuint64x4_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u16_x4)))
+svuint16x4_t svrshl_single_u16_x4(svuint16x4_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_x2)))
+svint8x2_t svrshl_s8_x2(svint8x2_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_x2)))
+svint32x2_t svrshl_s32_x2(svint32x2_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_x2)))
+svint64x2_t svrshl_s64_x2(svint64x2_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_x2)))
+svint16x2_t svrshl_s16_x2(svint16x2_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_x2)))
+svuint8x2_t svrshl_u8_x2(svuint8x2_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_x2)))
+svuint32x2_t svrshl_u32_x2(svuint32x2_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_x2)))
+svuint64x2_t svrshl_u64_x2(svuint64x2_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_x2)))
+svuint16x2_t svrshl_u16_x2(svuint16x2_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_x4)))
+svint8x4_t svrshl_s8_x4(svint8x4_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_x4)))
+svint32x4_t svrshl_s32_x4(svint32x4_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_x4)))
+svint64x4_t svrshl_s64_x4(svint64x4_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_x4)))
+svint16x4_t svrshl_s16_x4(svint16x4_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_x4)))
+svuint8x4_t svrshl_u8_x4(svuint8x4_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_x4)))
+svuint32x4_t svrshl_u32_x4(svuint32x4_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_x4)))
+svuint64x4_t svrshl_u64_x4(svuint64x4_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_x4)))
+svuint16x4_t svrshl_u16_x4(svuint16x4_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8_x2)))
+svuint8x2_t svsel_u8_x2(svcount_t, svuint8x2_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u32_x2)))
+svuint32x2_t svsel_u32_x2(svcount_t, svuint32x2_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u64_x2)))
+svuint64x2_t svsel_u64_x2(svcount_t, svuint64x2_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u16_x2)))
+svuint16x2_t svsel_u16_x2(svcount_t, svuint16x2_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_bf16_x2)))
+svbfloat16x2_t svsel_bf16_x2(svcount_t, svbfloat16x2_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s8_x2)))
+svint8x2_t svsel_s8_x2(svcount_t, svint8x2_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f64_x2)))
+svfloat64x2_t svsel_f64_x2(svcount_t, svfloat64x2_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f32_x2)))
+svfloat32x2_t svsel_f32_x2(svcount_t, svfloat32x2_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16_x2)))
+svfloat16x2_t svsel_f16_x2(svcount_t, svfloat16x2_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s32_x2)))
+svint32x2_t svsel_s32_x2(svcount_t, svint32x2_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s64_x2)))
+svint64x2_t svsel_s64_x2(svcount_t, svint64x2_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s16_x2)))
+svint16x2_t svsel_s16_x2(svcount_t, svint16x2_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8_x4)))
+svuint8x4_t svsel_u8_x4(svcount_t, svuint8x4_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u32_x4)))
+svuint32x4_t svsel_u32_x4(svcount_t, svuint32x4_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u64_x4)))
+svuint64x4_t svsel_u64_x4(svcount_t, svuint64x4_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u16_x4)))
+svuint16x4_t svsel_u16_x4(svcount_t, svuint16x4_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_bf16_x4)))
+svbfloat16x4_t svsel_bf16_x4(svcount_t, svbfloat16x4_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s8_x4)))
+svint8x4_t svsel_s8_x4(svcount_t, svint8x4_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f64_x4)))
+svfloat64x4_t svsel_f64_x4(svcount_t, svfloat64x4_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f32_x4)))
+svfloat32x4_t svsel_f32_x4(svcount_t, svfloat32x4_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16_x4)))
+svfloat16x4_t svsel_f16_x4(svcount_t, svfloat16x4_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s32_x4)))
+svint32x4_t svsel_s32_x4(svcount_t, svint32x4_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s64_x4)))
+svint64x4_t svsel_s64_x4(svcount_t, svint64x4_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s16_x4)))
+svint16x4_t svsel_s16_x4(svcount_t, svint16x4_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s32_s16_x2)))
+svint32x2_t svunpk_s32_s16_x2(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s64_s32_x2)))
+svint64x2_t svunpk_s64_s32_x2(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s16_s8_x2)))
+svint16x2_t svunpk_s16_s8_x2(svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u32_u16_x2)))
+svuint32x2_t svunpk_u32_u16_x2(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u64_u32_x2)))
+svuint64x2_t svunpk_u64_u32_x2(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u16_u8_x2)))
+svuint16x2_t svunpk_u16_u8_x2(svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s32_s16_x4)))
+svint32x4_t svunpk_s32_s16_x4(svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s64_s32_x4)))
+svint64x4_t svunpk_s64_s32_x4(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s16_s8_x4)))
+svint16x4_t svunpk_s16_s8_x4(svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u32_u16_x4)))
+svuint32x4_t svunpk_u32_u16_x4(svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u64_u32_x4)))
+svuint64x4_t svunpk_u64_u32_x4(svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u16_u8_x4)))
+svuint16x4_t svunpk_u16_u8_x4(svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u8_x2)))
+svuint8x2_t svuzp_u8_x2(svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u32_x2)))
+svuint32x2_t svuzp_u32_x2(svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u64_x2)))
+svuint64x2_t svuzp_u64_x2(svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u16_x2)))
+svuint16x2_t svuzp_u16_x2(svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_bf16_x2)))
+svbfloat16x2_t svuzp_bf16_x2(svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s8_x2)))
+svint8x2_t svuzp_s8_x2(svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f64_x2)))
+svfloat64x2_t svuzp_f64_x2(svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f32_x2)))
+svfloat32x2_t svuzp_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f16_x2)))
+svfloat16x2_t svuzp_f16_x2(svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s32_x2)))
+svint32x2_t svuzp_s32_x2(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s64_x2)))
+svint64x2_t svuzp_s64_x2(svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s16_x2)))
+svint16x2_t svuzp_s16_x2(svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u8_x4)))
+svuint8x4_t svuzp_u8_x4(svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u32_x4)))
+svuint32x4_t svuzp_u32_x4(svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u64_x4)))
+svuint64x4_t svuzp_u64_x4(svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u16_x4)))
+svuint16x4_t svuzp_u16_x4(svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_bf16_x4)))
+svbfloat16x4_t svuzp_bf16_x4(svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s8_x4)))
+svint8x4_t svuzp_s8_x4(svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f64_x4)))
+svfloat64x4_t svuzp_f64_x4(svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f32_x4)))
+svfloat32x4_t svuzp_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f16_x4)))
+svfloat16x4_t svuzp_f16_x4(svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s32_x4)))
+svint32x4_t svuzp_s32_x4(svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s64_x4)))
+svint64x4_t svuzp_s64_x4(svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s16_x4)))
+svint16x4_t svuzp_s16_x4(svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u8_x2)))
+svuint8x2_t svuzpq_u8_x2(svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u32_x2)))
+svuint32x2_t svuzpq_u32_x2(svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u64_x2)))
+svuint64x2_t svuzpq_u64_x2(svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u16_x2)))
+svuint16x2_t svuzpq_u16_x2(svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_bf16_x2)))
+svbfloat16x2_t svuzpq_bf16_x2(svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s8_x2)))
+svint8x2_t svuzpq_s8_x2(svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f64_x2)))
+svfloat64x2_t svuzpq_f64_x2(svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f32_x2)))
+svfloat32x2_t svuzpq_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f16_x2)))
+svfloat16x2_t svuzpq_f16_x2(svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s32_x2)))
+svint32x2_t svuzpq_s32_x2(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s64_x2)))
+svint64x2_t svuzpq_s64_x2(svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s16_x2)))
+svint16x2_t svuzpq_s16_x2(svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u8_x4)))
+svuint8x4_t svuzpq_u8_x4(svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u32_x4)))
+svuint32x4_t svuzpq_u32_x4(svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u64_x4)))
+svuint64x4_t svuzpq_u64_x4(svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u16_x4)))
+svuint16x4_t svuzpq_u16_x4(svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_bf16_x4)))
+svbfloat16x4_t svuzpq_bf16_x4(svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s8_x4)))
+svint8x4_t svuzpq_s8_x4(svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f64_x4)))
+svfloat64x4_t svuzpq_f64_x4(svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f32_x4)))
+svfloat32x4_t svuzpq_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f16_x4)))
+svfloat16x4_t svuzpq_f16_x4(svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s32_x4)))
+svint32x4_t svuzpq_s32_x4(svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s64_x4)))
+svint64x4_t svuzpq_s64_x4(svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s16_x4)))
+svint16x4_t svuzpq_s16_x4(svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u8_x2)))
+svuint8x2_t svzip_u8_x2(svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u32_x2)))
+svuint32x2_t svzip_u32_x2(svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u64_x2)))
+svuint64x2_t svzip_u64_x2(svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u16_x2)))
+svuint16x2_t svzip_u16_x2(svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_bf16_x2)))
+svbfloat16x2_t svzip_bf16_x2(svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s8_x2)))
+svint8x2_t svzip_s8_x2(svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f64_x2)))
+svfloat64x2_t svzip_f64_x2(svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f32_x2)))
+svfloat32x2_t svzip_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f16_x2)))
+svfloat16x2_t svzip_f16_x2(svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s32_x2)))
+svint32x2_t svzip_s32_x2(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s64_x2)))
+svint64x2_t svzip_s64_x2(svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s16_x2)))
+svint16x2_t svzip_s16_x2(svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u8_x4)))
+svuint8x4_t svzip_u8_x4(svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u32_x4)))
+svuint32x4_t svzip_u32_x4(svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u64_x4)))
+svuint64x4_t svzip_u64_x4(svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u16_x4)))
+svuint16x4_t svzip_u16_x4(svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_bf16_x4)))
+svbfloat16x4_t svzip_bf16_x4(svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s8_x4)))
+svint8x4_t svzip_s8_x4(svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f64_x4)))
+svfloat64x4_t svzip_f64_x4(svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f32_x4)))
+svfloat32x4_t svzip_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f16_x4)))
+svfloat16x4_t svzip_f16_x4(svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s32_x4)))
+svint32x4_t svzip_s32_x4(svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s64_x4)))
+svint64x4_t svzip_s64_x4(svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s16_x4)))
+svint16x4_t svzip_s16_x4(svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u8_x2)))
+svuint8x2_t svzipq_u8_x2(svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u32_x2)))
+svuint32x2_t svzipq_u32_x2(svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u64_x2)))
+svuint64x2_t svzipq_u64_x2(svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u16_x2)))
+svuint16x2_t svzipq_u16_x2(svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_bf16_x2)))
+svbfloat16x2_t svzipq_bf16_x2(svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s8_x2)))
+svint8x2_t svzipq_s8_x2(svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f64_x2)))
+svfloat64x2_t svzipq_f64_x2(svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f32_x2)))
+svfloat32x2_t svzipq_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f16_x2)))
+svfloat16x2_t svzipq_f16_x2(svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s32_x2)))
+svint32x2_t svzipq_s32_x2(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s64_x2)))
+svint64x2_t svzipq_s64_x2(svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s16_x2)))
+svint16x2_t svzipq_s16_x2(svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u8_x4)))
+svuint8x4_t svzipq_u8_x4(svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u32_x4)))
+svuint32x4_t svzipq_u32_x4(svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u64_x4)))
+svuint64x4_t svzipq_u64_x4(svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u16_x4)))
+svuint16x4_t svzipq_u16_x4(svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_bf16_x4)))
+svbfloat16x4_t svzipq_bf16_x4(svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s8_x4)))
+svint8x4_t svzipq_s8_x4(svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f64_x4)))
+svfloat64x4_t svzipq_f64_x4(svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f32_x4)))
+svfloat32x4_t svzipq_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f16_x4)))
+svfloat16x4_t svzipq_f16_x4(svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s32_x4)))
+svint32x4_t svzipq_s32_x4(svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s64_x4)))
+svint64x4_t svzipq_s64_x4(svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s16_x4)))
+svint16x4_t svzipq_s16_x4(svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u8_x2)))
+svuint8x2_t svadd(svuint8x2_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u32_x2)))
+svuint32x2_t svadd(svuint32x2_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u64_x2)))
+svuint64x2_t svadd(svuint64x2_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u16_x2)))
+svuint16x2_t svadd(svuint16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s8_x2)))
+svint8x2_t svadd(svint8x2_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s32_x2)))
+svint32x2_t svadd(svint32x2_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s64_x2)))
+svint64x2_t svadd(svint64x2_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s16_x2)))
+svint16x2_t svadd(svint16x2_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u8_x4)))
+svuint8x4_t svadd(svuint8x4_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u32_x4)))
+svuint32x4_t svadd(svuint32x4_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u64_x4)))
+svuint64x4_t svadd(svuint64x4_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u16_x4)))
+svuint16x4_t svadd(svuint16x4_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s8_x4)))
+svint8x4_t svadd(svint8x4_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s32_x4)))
+svint32x4_t svadd(svint32x4_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s64_x4)))
+svint64x4_t svadd(svint64x4_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s16_x4)))
+svint16x4_t svadd(svint16x4_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f64_x2)))
+svfloat64x2_t svclamp(svfloat64x2_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f32_x2)))
+svfloat32x2_t svclamp(svfloat32x2_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f16_x2)))
+svfloat16x2_t svclamp(svfloat16x2_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s8_x2)))
+svint8x2_t svclamp(svint8x2_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s32_x2)))
+svint32x2_t svclamp(svint32x2_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s64_x2)))
+svint64x2_t svclamp(svint64x2_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s16_x2)))
+svint16x2_t svclamp(svint16x2_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u8_x2)))
+svuint8x2_t svclamp(svuint8x2_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u32_x2)))
+svuint32x2_t svclamp(svuint32x2_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u64_x2)))
+svuint64x2_t svclamp(svuint64x2_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u16_x2)))
+svuint16x2_t svclamp(svuint16x2_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f64_x4)))
+svfloat64x4_t svclamp(svfloat64x4_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f32_x4)))
+svfloat32x4_t svclamp(svfloat32x4_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f16_x4)))
+svfloat16x4_t svclamp(svfloat16x4_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s8_x4)))
+svint8x4_t svclamp(svint8x4_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s32_x4)))
+svint32x4_t svclamp(svint32x4_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s64_x4)))
+svint64x4_t svclamp(svint64x4_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s16_x4)))
+svint16x4_t svclamp(svint16x4_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u8_x4)))
+svuint8x4_t svclamp(svuint8x4_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u32_x4)))
+svuint32x4_t svclamp(svuint32x4_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u64_x4)))
+svuint64x4_t svclamp(svuint64x4_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u16_x4)))
+svuint16x4_t svclamp(svuint16x4_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_x2)))
+svbfloat16_t svcvt_bf16(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_x2)))
+svfloat16_t svcvt_f16(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_x2)))
+svint32x2_t svcvt_s32(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_x2)))
+svuint32x2_t svcvt_u32(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_x4)))
+svint32x4_t svcvt_s32(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_x4)))
+svuint32x4_t svcvt_u32(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_x2)))
+svfloat32x2_t svcvt_f32(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_x4)))
+svfloat32x4_t svcvt_f32(svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_x2)))
+svfloat32x2_t svcvt_f32(svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_x4)))
+svfloat32x4_t svcvt_f32(svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtn_bf16_f32_x2)))
+svbfloat16_t svcvtn_bf16(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtn_f16_f32_x2)))
+svfloat16_t svcvtn_f16(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f64_x2)))
+svfloat64x2_t svmax(svfloat64x2_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f32_x2)))
+svfloat32x2_t svmax(svfloat32x2_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f16_x2)))
+svfloat16x2_t svmax(svfloat16x2_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s8_x2)))
+svint8x2_t svmax(svint8x2_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s32_x2)))
+svint32x2_t svmax(svint32x2_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s64_x2)))
+svint64x2_t svmax(svint64x2_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s16_x2)))
+svint16x2_t svmax(svint16x2_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u8_x2)))
+svuint8x2_t svmax(svuint8x2_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u32_x2)))
+svuint32x2_t svmax(svuint32x2_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u64_x2)))
+svuint64x2_t svmax(svuint64x2_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u16_x2)))
+svuint16x2_t svmax(svuint16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f64_x4)))
+svfloat64x4_t svmax(svfloat64x4_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f32_x4)))
+svfloat32x4_t svmax(svfloat32x4_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f16_x4)))
+svfloat16x4_t svmax(svfloat16x4_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s8_x4)))
+svint8x4_t svmax(svint8x4_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s32_x4)))
+svint32x4_t svmax(svint32x4_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s64_x4)))
+svint64x4_t svmax(svint64x4_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s16_x4)))
+svint16x4_t svmax(svint16x4_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u8_x4)))
+svuint8x4_t svmax(svuint8x4_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u32_x4)))
+svuint32x4_t svmax(svuint32x4_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u64_x4)))
+svuint64x4_t svmax(svuint64x4_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u16_x4)))
+svuint16x4_t svmax(svuint16x4_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_x2)))
+svfloat64x2_t svmax(svfloat64x2_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_x2)))
+svfloat32x2_t svmax(svfloat32x2_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_x2)))
+svfloat16x2_t svmax(svfloat16x2_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_x2)))
+svint8x2_t svmax(svint8x2_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_x2)))
+svint32x2_t svmax(svint32x2_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_x2)))
+svint64x2_t svmax(svint64x2_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_x2)))
+svint16x2_t svmax(svint16x2_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_x2)))
+svuint8x2_t svmax(svuint8x2_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_x2)))
+svuint32x2_t svmax(svuint32x2_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_x2)))
+svuint64x2_t svmax(svuint64x2_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_x2)))
+svuint16x2_t svmax(svuint16x2_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_x4)))
+svfloat64x4_t svmax(svfloat64x4_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_x4)))
+svfloat32x4_t svmax(svfloat32x4_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_x4)))
+svfloat16x4_t svmax(svfloat16x4_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_x4)))
+svint8x4_t svmax(svint8x4_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_x4)))
+svint32x4_t svmax(svint32x4_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_x4)))
+svint64x4_t svmax(svint64x4_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_x4)))
+svint16x4_t svmax(svint16x4_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_x4)))
+svuint8x4_t svmax(svuint8x4_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_x4)))
+svuint32x4_t svmax(svuint32x4_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_x4)))
+svuint64x4_t svmax(svuint64x4_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_x4)))
+svuint16x4_t svmax(svuint16x4_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f64_x2)))
+svfloat64x2_t svmaxnm(svfloat64x2_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f32_x2)))
+svfloat32x2_t svmaxnm(svfloat32x2_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f16_x2)))
+svfloat16x2_t svmaxnm(svfloat16x2_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f64_x4)))
+svfloat64x4_t svmaxnm(svfloat64x4_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f32_x4)))
+svfloat32x4_t svmaxnm(svfloat32x4_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f16_x4)))
+svfloat16x4_t svmaxnm(svfloat16x4_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_x2)))
+svfloat64x2_t svmaxnm(svfloat64x2_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_x2)))
+svfloat32x2_t svmaxnm(svfloat32x2_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x2)))
+svfloat16x2_t svmaxnm(svfloat16x2_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_x4)))
+svfloat64x4_t svmaxnm(svfloat64x4_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_x4)))
+svfloat32x4_t svmaxnm(svfloat32x4_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x4)))
+svfloat16x4_t svmaxnm(svfloat16x4_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f64_x2)))
+svfloat64x2_t svmin(svfloat64x2_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f32_x2)))
+svfloat32x2_t svmin(svfloat32x2_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f16_x2)))
+svfloat16x2_t svmin(svfloat16x2_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s8_x2)))
+svint8x2_t svmin(svint8x2_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s32_x2)))
+svint32x2_t svmin(svint32x2_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s64_x2)))
+svint64x2_t svmin(svint64x2_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s16_x2)))
+svint16x2_t svmin(svint16x2_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u8_x2)))
+svuint8x2_t svmin(svuint8x2_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u32_x2)))
+svuint32x2_t svmin(svuint32x2_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u64_x2)))
+svuint64x2_t svmin(svuint64x2_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u16_x2)))
+svuint16x2_t svmin(svuint16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f64_x4)))
+svfloat64x4_t svmin(svfloat64x4_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f32_x4)))
+svfloat32x4_t svmin(svfloat32x4_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f16_x4)))
+svfloat16x4_t svmin(svfloat16x4_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s8_x4)))
+svint8x4_t svmin(svint8x4_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s32_x4)))
+svint32x4_t svmin(svint32x4_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s64_x4)))
+svint64x4_t svmin(svint64x4_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s16_x4)))
+svint16x4_t svmin(svint16x4_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u8_x4)))
+svuint8x4_t svmin(svuint8x4_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u32_x4)))
+svuint32x4_t svmin(svuint32x4_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u64_x4)))
+svuint64x4_t svmin(svuint64x4_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u16_x4)))
+svuint16x4_t svmin(svuint16x4_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_x2)))
+svfloat64x2_t svmin(svfloat64x2_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_x2)))
+svfloat32x2_t svmin(svfloat32x2_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_x2)))
+svfloat16x2_t svmin(svfloat16x2_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_x2)))
+svint8x2_t svmin(svint8x2_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_x2)))
+svint32x2_t svmin(svint32x2_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_x2)))
+svint64x2_t svmin(svint64x2_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_x2)))
+svint16x2_t svmin(svint16x2_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_x2)))
+svuint8x2_t svmin(svuint8x2_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_x2)))
+svuint32x2_t svmin(svuint32x2_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_x2)))
+svuint64x2_t svmin(svuint64x2_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_x2)))
+svuint16x2_t svmin(svuint16x2_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_x4)))
+svfloat64x4_t svmin(svfloat64x4_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_x4)))
+svfloat32x4_t svmin(svfloat32x4_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_x4)))
+svfloat16x4_t svmin(svfloat16x4_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_x4)))
+svint8x4_t svmin(svint8x4_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_x4)))
+svint32x4_t svmin(svint32x4_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_x4)))
+svint64x4_t svmin(svint64x4_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_x4)))
+svint16x4_t svmin(svint16x4_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_x4)))
+svuint8x4_t svmin(svuint8x4_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_x4)))
+svuint32x4_t svmin(svuint32x4_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_x4)))
+svuint64x4_t svmin(svuint64x4_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_x4)))
+svuint16x4_t svmin(svuint16x4_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f64_x2)))
+svfloat64x2_t svminnm(svfloat64x2_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f32_x2)))
+svfloat32x2_t svminnm(svfloat32x2_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f16_x2)))
+svfloat16x2_t svminnm(svfloat16x2_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f64_x4)))
+svfloat64x4_t svminnm(svfloat64x4_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f32_x4)))
+svfloat32x4_t svminnm(svfloat32x4_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f16_x4)))
+svfloat16x4_t svminnm(svfloat16x4_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_x2)))
+svfloat64x2_t svminnm(svfloat64x2_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_x2)))
+svfloat32x2_t svminnm(svfloat32x2_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_x2)))
+svfloat16x2_t svminnm(svfloat16x2_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_x4)))
+svfloat64x4_t svminnm(svfloat64x4_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_x4)))
+svfloat32x4_t svminnm(svfloat32x4_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_x4)))
+svfloat16x4_t svminnm(svfloat16x4_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_s16_s32_x2)))
+svint16_t svqcvt_s16(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_s16_s64_x4)))
+svint16_t svqcvt_s16(svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_s8_s32_x4)))
+svint8_t svqcvt_s8(svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_s32_x2)))
+svuint16_t svqcvt_u16(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_u32_x2)))
+svuint16_t svqcvt_u16(svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_s64_x4)))
+svuint16_t svqcvt_u16(svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_u64_x4)))
+svuint16_t svqcvt_u16(svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u8_s32_x4)))
+svuint8_t svqcvt_u8(svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u8_u32_x4)))
+svuint8_t svqcvt_u8(svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_s16_s64_x4)))
+svint16_t svqcvtn_s16(svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_s8_s32_x4)))
+svint8_t svqcvtn_s8(svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_s64_x4)))
+svuint16_t svqcvtn_u16(svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_u64_x4)))
+svuint16_t svqcvtn_u16(svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u8_s32_x4)))
+svuint8_t svqcvtn_u8(svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u8_u32_x4)))
+svuint8_t svqcvtn_u8(svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s8_x2)))
+svint8x2_t svqdmulh(svint8x2_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s32_x2)))
+svint32x2_t svqdmulh(svint32x2_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s64_x2)))
+svint64x2_t svqdmulh(svint64x2_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s16_x2)))
+svint16x2_t svqdmulh(svint16x2_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s8_x4)))
+svint8x4_t svqdmulh(svint8x4_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s32_x4)))
+svint32x4_t svqdmulh(svint32x4_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s64_x4)))
+svint64x4_t svqdmulh(svint64x4_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s16_x4)))
+svint16x4_t svqdmulh(svint16x4_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s8_x2)))
+svint8x2_t svqdmulh(svint8x2_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s32_x2)))
+svint32x2_t svqdmulh(svint32x2_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s64_x2)))
+svint64x2_t svqdmulh(svint64x2_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s16_x2)))
+svint16x2_t svqdmulh(svint16x2_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s8_x4)))
+svint8x4_t svqdmulh(svint8x4_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s32_x4)))
+svint32x4_t svqdmulh(svint32x4_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s64_x4)))
+svint64x4_t svqdmulh(svint64x4_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s16_x4)))
+svint16x4_t svqdmulh(svint16x4_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_s16_s32_x2)))
+svint16_t svqrshr_s16(svint32x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_u16_u32_x2)))
+svuint16_t svqrshr_u16(svuint32x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_s8_s32_x4)))
+svint8_t svqrshr_s8(svint32x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_s16_s64_x4)))
+svint16_t svqrshr_s16(svint64x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_u8_u32_x4)))
+svuint8_t svqrshr_u8(svuint32x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_u16_u64_x4)))
+svuint16_t svqrshr_u16(svuint64x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_s8_s32_x4)))
+svint8_t svqrshrn_s8(svint32x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_s16_s64_x4)))
+svint16_t svqrshrn_s16(svint64x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_u8_u32_x4)))
+svuint8_t svqrshrn_u8(svuint32x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_u16_u64_x4)))
+svuint16_t svqrshrn_u16(svuint64x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshru_n_u16_s32_x2)))
+svuint16_t svqrshru_u16(svint32x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshru_n_u8_s32_x4)))
+svuint8_t svqrshru_u8(svint32x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshru_n_u16_s64_x4)))
+svuint16_t svqrshru_u16(svint64x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrun_n_u8_s32_x4)))
+svuint8_t svqrshrun_u8(svint32x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrun_n_u16_s64_x4)))
+svuint16_t svqrshrun_u16(svint64x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_x2)))
+svfloat32x2_t svrinta(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_x4)))
+svfloat32x4_t svrinta(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_x2)))
+svfloat32x2_t svrintm(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_x4)))
+svfloat32x4_t svrintm(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_x2)))
+svfloat32x2_t svrintn(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_x4)))
+svfloat32x4_t svrintn(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_x2)))
+svfloat32x2_t svrintp(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_x4)))
+svfloat32x4_t svrintp(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s8_x2)))
+svint8x2_t svrshl(svint8x2_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s32_x2)))
+svint32x2_t svrshl(svint32x2_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s64_x2)))
+svint64x2_t svrshl(svint64x2_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s16_x2)))
+svint16x2_t svrshl(svint16x2_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u8_x2)))
+svuint8x2_t svrshl(svuint8x2_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u32_x2)))
+svuint32x2_t svrshl(svuint32x2_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u64_x2)))
+svuint64x2_t svrshl(svuint64x2_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u16_x2)))
+svuint16x2_t svrshl(svuint16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s8_x4)))
+svint8x4_t svrshl(svint8x4_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s32_x4)))
+svint32x4_t svrshl(svint32x4_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s64_x4)))
+svint64x4_t svrshl(svint64x4_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s16_x4)))
+svint16x4_t svrshl(svint16x4_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u8_x4)))
+svuint8x4_t svrshl(svuint8x4_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u32_x4)))
+svuint32x4_t svrshl(svuint32x4_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u64_x4)))
+svuint64x4_t svrshl(svuint64x4_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u16_x4)))
+svuint16x4_t svrshl(svuint16x4_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_x2)))
+svint8x2_t svrshl(svint8x2_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_x2)))
+svint32x2_t svrshl(svint32x2_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_x2)))
+svint64x2_t svrshl(svint64x2_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_x2)))
+svint16x2_t svrshl(svint16x2_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_x2)))
+svuint8x2_t svrshl(svuint8x2_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_x2)))
+svuint32x2_t svrshl(svuint32x2_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_x2)))
+svuint64x2_t svrshl(svuint64x2_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_x2)))
+svuint16x2_t svrshl(svuint16x2_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_x4)))
+svint8x4_t svrshl(svint8x4_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_x4)))
+svint32x4_t svrshl(svint32x4_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_x4)))
+svint64x4_t svrshl(svint64x4_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_x4)))
+svint16x4_t svrshl(svint16x4_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_x4)))
+svuint8x4_t svrshl(svuint8x4_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_x4)))
+svuint32x4_t svrshl(svuint32x4_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_x4)))
+svuint64x4_t svrshl(svuint64x4_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_x4)))
+svuint16x4_t svrshl(svuint16x4_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8_x2)))
+svuint8x2_t svsel(svcount_t, svuint8x2_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u32_x2)))
+svuint32x2_t svsel(svcount_t, svuint32x2_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u64_x2)))
+svuint64x2_t svsel(svcount_t, svuint64x2_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u16_x2)))
+svuint16x2_t svsel(svcount_t, svuint16x2_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_bf16_x2)))
+svbfloat16x2_t svsel(svcount_t, svbfloat16x2_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s8_x2)))
+svint8x2_t svsel(svcount_t, svint8x2_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f64_x2)))
+svfloat64x2_t svsel(svcount_t, svfloat64x2_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f32_x2)))
+svfloat32x2_t svsel(svcount_t, svfloat32x2_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16_x2)))
+svfloat16x2_t svsel(svcount_t, svfloat16x2_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s32_x2)))
+svint32x2_t svsel(svcount_t, svint32x2_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s64_x2)))
+svint64x2_t svsel(svcount_t, svint64x2_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s16_x2)))
+svint16x2_t svsel(svcount_t, svint16x2_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8_x4)))
+svuint8x4_t svsel(svcount_t, svuint8x4_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u32_x4)))
+svuint32x4_t svsel(svcount_t, svuint32x4_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u64_x4)))
+svuint64x4_t svsel(svcount_t, svuint64x4_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u16_x4)))
+svuint16x4_t svsel(svcount_t, svuint16x4_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_bf16_x4)))
+svbfloat16x4_t svsel(svcount_t, svbfloat16x4_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s8_x4)))
+svint8x4_t svsel(svcount_t, svint8x4_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f64_x4)))
+svfloat64x4_t svsel(svcount_t, svfloat64x4_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f32_x4)))
+svfloat32x4_t svsel(svcount_t, svfloat32x4_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16_x4)))
+svfloat16x4_t svsel(svcount_t, svfloat16x4_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s32_x4)))
+svint32x4_t svsel(svcount_t, svint32x4_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s64_x4)))
+svint64x4_t svsel(svcount_t, svint64x4_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s16_x4)))
+svint16x4_t svsel(svcount_t, svint16x4_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s32_s16_x2)))
+svint32x2_t svunpk_s32(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s64_s32_x2)))
+svint64x2_t svunpk_s64(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s16_s8_x2)))
+svint16x2_t svunpk_s16(svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u32_u16_x2)))
+svuint32x2_t svunpk_u32(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u64_u32_x2)))
+svuint64x2_t svunpk_u64(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u16_u8_x2)))
+svuint16x2_t svunpk_u16(svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s32_s16_x4)))
+svint32x4_t svunpk_s32(svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s64_s32_x4)))
+svint64x4_t svunpk_s64(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s16_s8_x4)))
+svint16x4_t svunpk_s16(svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u32_u16_x4)))
+svuint32x4_t svunpk_u32(svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u64_u32_x4)))
+svuint64x4_t svunpk_u64(svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u16_u8_x4)))
+svuint16x4_t svunpk_u16(svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u8_x2)))
+svuint8x2_t svuzp(svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u32_x2)))
+svuint32x2_t svuzp(svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u64_x2)))
+svuint64x2_t svuzp(svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u16_x2)))
+svuint16x2_t svuzp(svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_bf16_x2)))
+svbfloat16x2_t svuzp(svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s8_x2)))
+svint8x2_t svuzp(svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f64_x2)))
+svfloat64x2_t svuzp(svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f32_x2)))
+svfloat32x2_t svuzp(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f16_x2)))
+svfloat16x2_t svuzp(svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s32_x2)))
+svint32x2_t svuzp(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s64_x2)))
+svint64x2_t svuzp(svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s16_x2)))
+svint16x2_t svuzp(svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u8_x4)))
+svuint8x4_t svuzp(svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u32_x4)))
+svuint32x4_t svuzp(svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u64_x4)))
+svuint64x4_t svuzp(svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u16_x4)))
+svuint16x4_t svuzp(svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_bf16_x4)))
+svbfloat16x4_t svuzp(svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s8_x4)))
+svint8x4_t svuzp(svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f64_x4)))
+svfloat64x4_t svuzp(svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f32_x4)))
+svfloat32x4_t svuzp(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f16_x4)))
+svfloat16x4_t svuzp(svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s32_x4)))
+svint32x4_t svuzp(svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s64_x4)))
+svint64x4_t svuzp(svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s16_x4)))
+svint16x4_t svuzp(svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u8_x2)))
+svuint8x2_t svuzpq(svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u32_x2)))
+svuint32x2_t svuzpq(svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u64_x2)))
+svuint64x2_t svuzpq(svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u16_x2)))
+svuint16x2_t svuzpq(svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_bf16_x2)))
+svbfloat16x2_t svuzpq(svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s8_x2)))
+svint8x2_t svuzpq(svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f64_x2)))
+svfloat64x2_t svuzpq(svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f32_x2)))
+svfloat32x2_t svuzpq(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f16_x2)))
+svfloat16x2_t svuzpq(svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s32_x2)))
+svint32x2_t svuzpq(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s64_x2)))
+svint64x2_t svuzpq(svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s16_x2)))
+svint16x2_t svuzpq(svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u8_x4)))
+svuint8x4_t svuzpq(svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u32_x4)))
+svuint32x4_t svuzpq(svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u64_x4)))
+svuint64x4_t svuzpq(svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u16_x4)))
+svuint16x4_t svuzpq(svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_bf16_x4)))
+svbfloat16x4_t svuzpq(svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s8_x4)))
+svint8x4_t svuzpq(svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f64_x4)))
+svfloat64x4_t svuzpq(svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f32_x4)))
+svfloat32x4_t svuzpq(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f16_x4)))
+svfloat16x4_t svuzpq(svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s32_x4)))
+svint32x4_t svuzpq(svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s64_x4)))
+svint64x4_t svuzpq(svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s16_x4)))
+svint16x4_t svuzpq(svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u8_x2)))
+svuint8x2_t svzip(svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u32_x2)))
+svuint32x2_t svzip(svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u64_x2)))
+svuint64x2_t svzip(svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u16_x2)))
+svuint16x2_t svzip(svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_bf16_x2)))
+svbfloat16x2_t svzip(svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s8_x2)))
+svint8x2_t svzip(svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f64_x2)))
+svfloat64x2_t svzip(svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f32_x2)))
+svfloat32x2_t svzip(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f16_x2)))
+svfloat16x2_t svzip(svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s32_x2)))
+svint32x2_t svzip(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s64_x2)))
+svint64x2_t svzip(svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s16_x2)))
+svint16x2_t svzip(svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u8_x4)))
+svuint8x4_t svzip(svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u32_x4)))
+svuint32x4_t svzip(svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u64_x4)))
+svuint64x4_t svzip(svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u16_x4)))
+svuint16x4_t svzip(svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_bf16_x4)))
+svbfloat16x4_t svzip(svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s8_x4)))
+svint8x4_t svzip(svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f64_x4)))
+svfloat64x4_t svzip(svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f32_x4)))
+svfloat32x4_t svzip(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f16_x4)))
+svfloat16x4_t svzip(svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s32_x4)))
+svint32x4_t svzip(svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s64_x4)))
+svint64x4_t svzip(svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s16_x4)))
+svint16x4_t svzip(svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u8_x2)))
+svuint8x2_t svzipq(svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u32_x2)))
+svuint32x2_t svzipq(svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u64_x2)))
+svuint64x2_t svzipq(svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u16_x2)))
+svuint16x2_t svzipq(svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_bf16_x2)))
+svbfloat16x2_t svzipq(svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s8_x2)))
+svint8x2_t svzipq(svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f64_x2)))
+svfloat64x2_t svzipq(svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f32_x2)))
+svfloat32x2_t svzipq(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f16_x2)))
+svfloat16x2_t svzipq(svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s32_x2)))
+svint32x2_t svzipq(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s64_x2)))
+svint64x2_t svzipq(svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s16_x2)))
+svint16x2_t svzipq(svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u8_x4)))
+svuint8x4_t svzipq(svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u32_x4)))
+svuint32x4_t svzipq(svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u64_x4)))
+svuint64x4_t svzipq(svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u16_x4)))
+svuint16x4_t svzipq(svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_bf16_x4)))
+svbfloat16x4_t svzipq(svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s8_x4)))
+svint8x4_t svzipq(svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f64_x4)))
+svfloat64x4_t svzipq(svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f32_x4)))
+svfloat32x4_t svzipq(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f16_x4)))
+svfloat16x4_t svzipq(svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s32_x4)))
+svint32x4_t svzipq(svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s64_x4)))
+svint64x4_t svzipq(svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s16_x4)))
+svint16x4_t svzipq(svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_bf16_x2)))
+svbfloat16x2_t svclamp_single_bf16_x2(svbfloat16x2_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_bf16_x4)))
+svbfloat16x4_t svclamp_single_bf16_x4(svbfloat16x4_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_bf16_x2)))
+svbfloat16x2_t svmax_single_bf16_x2(svbfloat16x2_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_bf16_x4)))
+svbfloat16x4_t svmax_single_bf16_x4(svbfloat16x4_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_x2)))
+svbfloat16x2_t svmax_bf16_x2(svbfloat16x2_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_x4)))
+svbfloat16x4_t svmax_bf16_x4(svbfloat16x4_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_bf16_x2)))
+svbfloat16x2_t svmaxnm_single_bf16_x2(svbfloat16x2_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_bf16_x4)))
+svbfloat16x4_t svmaxnm_single_bf16_x4(svbfloat16x4_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_x2)))
+svbfloat16x2_t svmaxnm_bf16_x2(svbfloat16x2_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_x4)))
+svbfloat16x4_t svmaxnm_bf16_x4(svbfloat16x4_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_bf16_x2)))
+svbfloat16x2_t svmin_single_bf16_x2(svbfloat16x2_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_bf16_x4)))
+svbfloat16x4_t svmin_single_bf16_x4(svbfloat16x4_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_x2)))
+svbfloat16x2_t svmin_bf16_x2(svbfloat16x2_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_x4)))
+svbfloat16x4_t svmin_bf16_x4(svbfloat16x4_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_bf16_x2)))
+svbfloat16x2_t svminnm_single_bf16_x2(svbfloat16x2_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_bf16_x4)))
+svbfloat16x4_t svminnm_single_bf16_x4(svbfloat16x4_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_x2)))
+svbfloat16x2_t svminnm_bf16_x2(svbfloat16x2_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_x4)))
+svbfloat16x4_t svminnm_bf16_x4(svbfloat16x4_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_bf16_x2)))
+svbfloat16x2_t svclamp(svbfloat16x2_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_bf16_x4)))
+svbfloat16x4_t svclamp(svbfloat16x4_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_bf16_x2)))
+svbfloat16x2_t svmax(svbfloat16x2_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_bf16_x4)))
+svbfloat16x4_t svmax(svbfloat16x4_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_x2)))
+svbfloat16x2_t svmax(svbfloat16x2_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_x4)))
+svbfloat16x4_t svmax(svbfloat16x4_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_bf16_x2)))
+svbfloat16x2_t svmaxnm(svbfloat16x2_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_bf16_x4)))
+svbfloat16x4_t svmaxnm(svbfloat16x4_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_x2)))
+svbfloat16x2_t svmaxnm(svbfloat16x2_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_x4)))
+svbfloat16x4_t svmaxnm(svbfloat16x4_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_bf16_x2)))
+svbfloat16x2_t svmin(svbfloat16x2_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_bf16_x4)))
+svbfloat16x4_t svmin(svbfloat16x4_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_x2)))
+svbfloat16x2_t svmin(svbfloat16x2_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_x4)))
+svbfloat16x4_t svmin(svbfloat16x4_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_bf16_x2)))
+svbfloat16x2_t svminnm(svbfloat16x2_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_bf16_x4)))
+svbfloat16x4_t svminnm(svbfloat16x4_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_x2)))
+svbfloat16x2_t svminnm(svbfloat16x2_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_x4)))
+svbfloat16x4_t svminnm(svbfloat16x4_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u32base_u32offset)))
+svuint32_t svadrb_u32base_u32offset(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u64base_u64offset)))
+svuint64_t svadrb_u64base_u64offset(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u32base_s32offset)))
+svuint32_t svadrb_u32base_s32offset(svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u64base_s64offset)))
+svuint64_t svadrb_u64base_s64offset(svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u32base_u32index)))
+svuint32_t svadrd_u32base_u32index(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u64base_u64index)))
+svuint64_t svadrd_u64base_u64index(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u32base_s32index)))
+svuint32_t svadrd_u32base_s32index(svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u64base_s64index)))
+svuint64_t svadrd_u64base_s64index(svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u32base_u32index)))
+svuint32_t svadrh_u32base_u32index(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u64base_u64index)))
+svuint64_t svadrh_u64base_u64index(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u32base_s32index)))
+svuint32_t svadrh_u32base_s32index(svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u64base_s64index)))
+svuint64_t svadrh_u64base_s64index(svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u32base_u32index)))
+svuint32_t svadrw_u32base_u32index(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u64base_u64index)))
+svuint64_t svadrw_u64base_u64index(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u32base_s32index)))
+svuint32_t svadrw_u32base_s32index(svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u64base_s64index)))
+svuint64_t svadrw_u64base_s64index(svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_u32)))
+svuint32_t svcompact_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_u64)))
+svuint64_t svcompact_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_f64)))
+svfloat64_t svcompact_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_f32)))
+svfloat32_t svcompact_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_s32)))
+svint32_t svcompact_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_s64)))
+svint64_t svcompact_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexpa_f64)))
+svfloat64_t svexpa_f64(svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexpa_f32)))
+svfloat32_t svexpa_f32(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexpa_f16)))
+svfloat16_t svexpa_f16(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_index_u32)))
+svuint32_t svld1_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_index_u64)))
+svuint64_t svld1_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_index_f64)))
+svfloat64_t svld1_gather_u64base_index_f64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_index_f32)))
+svfloat32_t svld1_gather_u32base_index_f32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_index_s32)))
+svint32_t svld1_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_index_s64)))
+svint64_t svld1_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_offset_u32)))
+svuint32_t svld1_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_offset_u64)))
+svuint64_t svld1_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_offset_f64)))
+svfloat64_t svld1_gather_u64base_offset_f64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_offset_f32)))
+svfloat32_t svld1_gather_u32base_offset_f32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_offset_s32)))
+svint32_t svld1_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_offset_s64)))
+svint64_t svld1_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_u32)))
+svuint32_t svld1_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_u64)))
+svuint64_t svld1_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_f64)))
+svfloat64_t svld1_gather_u64base_f64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_f32)))
+svfloat32_t svld1_gather_u32base_f32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_s32)))
+svint32_t svld1_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_s64)))
+svint64_t svld1_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32index_u32)))
+svuint32_t svld1_gather_s32index_u32(svbool_t, uint32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32index_f32)))
+svfloat32_t svld1_gather_s32index_f32(svbool_t, float32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32index_s32)))
+svint32_t svld1_gather_s32index_s32(svbool_t, int32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32index_u32)))
+svuint32_t svld1_gather_u32index_u32(svbool_t, uint32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32index_f32)))
+svfloat32_t svld1_gather_u32index_f32(svbool_t, float32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32index_s32)))
+svint32_t svld1_gather_u32index_s32(svbool_t, int32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64index_u64)))
+svuint64_t svld1_gather_s64index_u64(svbool_t, uint64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64index_f64)))
+svfloat64_t svld1_gather_s64index_f64(svbool_t, float64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64index_s64)))
+svint64_t svld1_gather_s64index_s64(svbool_t, int64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64index_u64)))
+svuint64_t svld1_gather_u64index_u64(svbool_t, uint64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64index_f64)))
+svfloat64_t svld1_gather_u64index_f64(svbool_t, float64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64index_s64)))
+svint64_t svld1_gather_u64index_s64(svbool_t, int64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32offset_u32)))
+svuint32_t svld1_gather_s32offset_u32(svbool_t, uint32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32offset_f32)))
+svfloat32_t svld1_gather_s32offset_f32(svbool_t, float32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32offset_s32)))
+svint32_t svld1_gather_s32offset_s32(svbool_t, int32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32offset_u32)))
+svuint32_t svld1_gather_u32offset_u32(svbool_t, uint32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32offset_f32)))
+svfloat32_t svld1_gather_u32offset_f32(svbool_t, float32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32offset_s32)))
+svint32_t svld1_gather_u32offset_s32(svbool_t, int32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64offset_u64)))
+svuint64_t svld1_gather_s64offset_u64(svbool_t, uint64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64offset_f64)))
+svfloat64_t svld1_gather_s64offset_f64(svbool_t, float64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64offset_s64)))
+svint64_t svld1_gather_s64offset_s64(svbool_t, int64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64offset_u64)))
+svuint64_t svld1_gather_u64offset_u64(svbool_t, uint64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64offset_f64)))
+svfloat64_t svld1_gather_u64offset_f64(svbool_t, float64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64offset_s64)))
+svint64_t svld1_gather_u64offset_s64(svbool_t, int64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_offset_u32)))
+svuint32_t svld1sb_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_offset_u64)))
+svuint64_t svld1sb_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_offset_s32)))
+svint32_t svld1sb_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_offset_s64)))
+svint64_t svld1sb_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_u32)))
+svuint32_t svld1sb_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_u64)))
+svuint64_t svld1sb_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_s32)))
+svint32_t svld1sb_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_s64)))
+svint64_t svld1sb_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s32offset_u32)))
+svuint32_t svld1sb_gather_s32offset_u32(svbool_t, int8_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s32offset_s32)))
+svint32_t svld1sb_gather_s32offset_s32(svbool_t, int8_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32offset_u32)))
+svuint32_t svld1sb_gather_u32offset_u32(svbool_t, int8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32offset_s32)))
+svint32_t svld1sb_gather_u32offset_s32(svbool_t, int8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s64offset_u64)))
+svuint64_t svld1sb_gather_s64offset_u64(svbool_t, int8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s64offset_s64)))
+svint64_t svld1sb_gather_s64offset_s64(svbool_t, int8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64offset_u64)))
+svuint64_t svld1sb_gather_u64offset_u64(svbool_t, int8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64offset_s64)))
+svint64_t svld1sb_gather_u64offset_s64(svbool_t, int8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_index_u32)))
+svuint32_t svld1sh_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_index_u64)))
+svuint64_t svld1sh_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_index_s32)))
+svint32_t svld1sh_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_index_s64)))
+svint64_t svld1sh_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_offset_u32)))
+svuint32_t svld1sh_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_offset_u64)))
+svuint64_t svld1sh_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_offset_s32)))
+svint32_t svld1sh_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_offset_s64)))
+svint64_t svld1sh_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_u32)))
+svuint32_t svld1sh_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_u64)))
+svuint64_t svld1sh_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_s32)))
+svint32_t svld1sh_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_s64)))
+svint64_t svld1sh_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32index_u32)))
+svuint32_t svld1sh_gather_s32index_u32(svbool_t, int16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32index_s32)))
+svint32_t svld1sh_gather_s32index_s32(svbool_t, int16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32index_u32)))
+svuint32_t svld1sh_gather_u32index_u32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32index_s32)))
+svint32_t svld1sh_gather_u32index_s32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64index_u64)))
+svuint64_t svld1sh_gather_s64index_u64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64index_s64)))
+svint64_t svld1sh_gather_s64index_s64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64index_u64)))
+svuint64_t svld1sh_gather_u64index_u64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64index_s64)))
+svint64_t svld1sh_gather_u64index_s64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32offset_u32)))
+svuint32_t svld1sh_gather_s32offset_u32(svbool_t, int16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32offset_s32)))
+svint32_t svld1sh_gather_s32offset_s32(svbool_t, int16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32offset_u32)))
+svuint32_t svld1sh_gather_u32offset_u32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32offset_s32)))
+svint32_t svld1sh_gather_u32offset_s32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64offset_u64)))
+svuint64_t svld1sh_gather_s64offset_u64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64offset_s64)))
+svint64_t svld1sh_gather_s64offset_s64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64offset_u64)))
+svuint64_t svld1sh_gather_u64offset_u64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64offset_s64)))
+svint64_t svld1sh_gather_u64offset_s64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_index_u64)))
+svuint64_t svld1sw_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_index_s64)))
+svint64_t svld1sw_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_offset_u64)))
+svuint64_t svld1sw_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_offset_s64)))
+svint64_t svld1sw_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_u64)))
+svuint64_t svld1sw_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_s64)))
+svint64_t svld1sw_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64index_u64)))
+svuint64_t svld1sw_gather_s64index_u64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64index_s64)))
+svint64_t svld1sw_gather_s64index_s64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64index_u64)))
+svuint64_t svld1sw_gather_u64index_u64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64index_s64)))
+svint64_t svld1sw_gather_u64index_s64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64offset_u64)))
+svuint64_t svld1sw_gather_s64offset_u64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64offset_s64)))
+svint64_t svld1sw_gather_s64offset_s64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64offset_u64)))
+svuint64_t svld1sw_gather_u64offset_u64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64offset_s64)))
+svint64_t svld1sw_gather_u64offset_s64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_offset_u32)))
+svuint32_t svld1ub_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_offset_u64)))
+svuint64_t svld1ub_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_offset_s32)))
+svint32_t svld1ub_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_offset_s64)))
+svint64_t svld1ub_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_u32)))
+svuint32_t svld1ub_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_u64)))
+svuint64_t svld1ub_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_s32)))
+svint32_t svld1ub_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_s64)))
+svint64_t svld1ub_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s32offset_u32)))
+svuint32_t svld1ub_gather_s32offset_u32(svbool_t, uint8_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s32offset_s32)))
+svint32_t svld1ub_gather_s32offset_s32(svbool_t, uint8_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32offset_u32)))
+svuint32_t svld1ub_gather_u32offset_u32(svbool_t, uint8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32offset_s32)))
+svint32_t svld1ub_gather_u32offset_s32(svbool_t, uint8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s64offset_u64)))
+svuint64_t svld1ub_gather_s64offset_u64(svbool_t, uint8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s64offset_s64)))
+svint64_t svld1ub_gather_s64offset_s64(svbool_t, uint8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64offset_u64)))
+svuint64_t svld1ub_gather_u64offset_u64(svbool_t, uint8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64offset_s64)))
+svint64_t svld1ub_gather_u64offset_s64(svbool_t, uint8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_index_u32)))
+svuint32_t svld1uh_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_index_u64)))
+svuint64_t svld1uh_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_index_s32)))
+svint32_t svld1uh_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_index_s64)))
+svint64_t svld1uh_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_offset_u32)))
+svuint32_t svld1uh_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_offset_u64)))
+svuint64_t svld1uh_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_offset_s32)))
+svint32_t svld1uh_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_offset_s64)))
+svint64_t svld1uh_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_u32)))
+svuint32_t svld1uh_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_u64)))
+svuint64_t svld1uh_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_s32)))
+svint32_t svld1uh_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_s64)))
+svint64_t svld1uh_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32index_u32)))
+svuint32_t svld1uh_gather_s32index_u32(svbool_t, uint16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32index_s32)))
+svint32_t svld1uh_gather_s32index_s32(svbool_t, uint16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32index_u32)))
+svuint32_t svld1uh_gather_u32index_u32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32index_s32)))
+svint32_t svld1uh_gather_u32index_s32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64index_u64)))
+svuint64_t svld1uh_gather_s64index_u64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64index_s64)))
+svint64_t svld1uh_gather_s64index_s64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64index_u64)))
+svuint64_t svld1uh_gather_u64index_u64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64index_s64)))
+svint64_t svld1uh_gather_u64index_s64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32offset_u32)))
+svuint32_t svld1uh_gather_s32offset_u32(svbool_t, uint16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32offset_s32)))
+svint32_t svld1uh_gather_s32offset_s32(svbool_t, uint16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32offset_u32)))
+svuint32_t svld1uh_gather_u32offset_u32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32offset_s32)))
+svint32_t svld1uh_gather_u32offset_s32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64offset_u64)))
+svuint64_t svld1uh_gather_s64offset_u64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64offset_s64)))
+svint64_t svld1uh_gather_s64offset_s64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64offset_u64)))
+svuint64_t svld1uh_gather_u64offset_u64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64offset_s64)))
+svint64_t svld1uh_gather_u64offset_s64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_index_u64)))
+svuint64_t svld1uw_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_index_s64)))
+svint64_t svld1uw_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_offset_u64)))
+svuint64_t svld1uw_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_offset_s64)))
+svint64_t svld1uw_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_u64)))
+svuint64_t svld1uw_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_s64)))
+svint64_t svld1uw_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64index_u64)))
+svuint64_t svld1uw_gather_s64index_u64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64index_s64)))
+svint64_t svld1uw_gather_s64index_s64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64index_u64)))
+svuint64_t svld1uw_gather_u64index_u64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64index_s64)))
+svint64_t svld1uw_gather_u64index_s64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64offset_u64)))
+svuint64_t svld1uw_gather_s64offset_u64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64offset_s64)))
+svint64_t svld1uw_gather_s64offset_s64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64offset_u64)))
+svuint64_t svld1uw_gather_u64offset_u64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64offset_s64)))
+svint64_t svld1uw_gather_u64offset_s64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u8)))
+svuint8_t svldff1_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u32)))
+svuint32_t svldff1_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u64)))
+svuint64_t svldff1_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u16)))
+svuint16_t svldff1_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s8)))
+svint8_t svldff1_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_f64)))
+svfloat64_t svldff1_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_f32)))
+svfloat32_t svldff1_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_f16)))
+svfloat16_t svldff1_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s32)))
+svint32_t svldff1_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s64)))
+svint64_t svldff1_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s16)))
+svint16_t svldff1_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_index_u32)))
+svuint32_t svldff1_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_index_u64)))
+svuint64_t svldff1_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_index_f64)))
+svfloat64_t svldff1_gather_u64base_index_f64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_index_f32)))
+svfloat32_t svldff1_gather_u32base_index_f32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_index_s32)))
+svint32_t svldff1_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_index_s64)))
+svint64_t svldff1_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_offset_u32)))
+svuint32_t svldff1_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_offset_u64)))
+svuint64_t svldff1_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_offset_f64)))
+svfloat64_t svldff1_gather_u64base_offset_f64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_offset_f32)))
+svfloat32_t svldff1_gather_u32base_offset_f32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_offset_s32)))
+svint32_t svldff1_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_offset_s64)))
+svint64_t svldff1_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_u32)))
+svuint32_t svldff1_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_u64)))
+svuint64_t svldff1_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_f64)))
+svfloat64_t svldff1_gather_u64base_f64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_f32)))
+svfloat32_t svldff1_gather_u32base_f32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_s32)))
+svint32_t svldff1_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_s64)))
+svint64_t svldff1_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32index_u32)))
+svuint32_t svldff1_gather_s32index_u32(svbool_t, uint32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32index_f32)))
+svfloat32_t svldff1_gather_s32index_f32(svbool_t, float32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32index_s32)))
+svint32_t svldff1_gather_s32index_s32(svbool_t, int32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32index_u32)))
+svuint32_t svldff1_gather_u32index_u32(svbool_t, uint32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32index_f32)))
+svfloat32_t svldff1_gather_u32index_f32(svbool_t, float32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32index_s32)))
+svint32_t svldff1_gather_u32index_s32(svbool_t, int32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64index_u64)))
+svuint64_t svldff1_gather_s64index_u64(svbool_t, uint64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64index_f64)))
+svfloat64_t svldff1_gather_s64index_f64(svbool_t, float64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64index_s64)))
+svint64_t svldff1_gather_s64index_s64(svbool_t, int64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64index_u64)))
+svuint64_t svldff1_gather_u64index_u64(svbool_t, uint64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64index_f64)))
+svfloat64_t svldff1_gather_u64index_f64(svbool_t, float64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64index_s64)))
+svint64_t svldff1_gather_u64index_s64(svbool_t, int64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32offset_u32)))
+svuint32_t svldff1_gather_s32offset_u32(svbool_t, uint32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32offset_f32)))
+svfloat32_t svldff1_gather_s32offset_f32(svbool_t, float32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32offset_s32)))
+svint32_t svldff1_gather_s32offset_s32(svbool_t, int32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32offset_u32)))
+svuint32_t svldff1_gather_u32offset_u32(svbool_t, uint32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32offset_f32)))
+svfloat32_t svldff1_gather_u32offset_f32(svbool_t, float32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32offset_s32)))
+svint32_t svldff1_gather_u32offset_s32(svbool_t, int32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64offset_u64)))
+svuint64_t svldff1_gather_s64offset_u64(svbool_t, uint64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64offset_f64)))
+svfloat64_t svldff1_gather_s64offset_f64(svbool_t, float64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64offset_s64)))
+svint64_t svldff1_gather_s64offset_s64(svbool_t, int64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64offset_u64)))
+svuint64_t svldff1_gather_u64offset_u64(svbool_t, uint64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64offset_f64)))
+svfloat64_t svldff1_gather_u64offset_f64(svbool_t, float64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64offset_s64)))
+svint64_t svldff1_gather_u64offset_s64(svbool_t, int64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u8)))
+svuint8_t svldff1_vnum_u8(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u32)))
+svuint32_t svldff1_vnum_u32(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u64)))
+svuint64_t svldff1_vnum_u64(svbool_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u16)))
+svuint16_t svldff1_vnum_u16(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s8)))
+svint8_t svldff1_vnum_s8(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_f64)))
+svfloat64_t svldff1_vnum_f64(svbool_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_f32)))
+svfloat32_t svldff1_vnum_f32(svbool_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_f16)))
+svfloat16_t svldff1_vnum_f16(svbool_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s32)))
+svint32_t svldff1_vnum_s32(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s64)))
+svint64_t svldff1_vnum_s64(svbool_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s16)))
+svint16_t svldff1_vnum_s16(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_offset_u32)))
+svuint32_t svldff1sb_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_offset_u64)))
+svuint64_t svldff1sb_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_offset_s32)))
+svint32_t svldff1sb_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_offset_s64)))
+svint64_t svldff1sb_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_u32)))
+svuint32_t svldff1sb_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_u64)))
+svuint64_t svldff1sb_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_s32)))
+svint32_t svldff1sb_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_s64)))
+svint64_t svldff1sb_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s32offset_u32)))
+svuint32_t svldff1sb_gather_s32offset_u32(svbool_t, int8_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s32offset_s32)))
+svint32_t svldff1sb_gather_s32offset_s32(svbool_t, int8_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32offset_u32)))
+svuint32_t svldff1sb_gather_u32offset_u32(svbool_t, int8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32offset_s32)))
+svint32_t svldff1sb_gather_u32offset_s32(svbool_t, int8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s64offset_u64)))
+svuint64_t svldff1sb_gather_s64offset_u64(svbool_t, int8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s64offset_s64)))
+svint64_t svldff1sb_gather_s64offset_s64(svbool_t, int8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64offset_u64)))
+svuint64_t svldff1sb_gather_u64offset_u64(svbool_t, int8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64offset_s64)))
+svint64_t svldff1sb_gather_u64offset_s64(svbool_t, int8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_vnum_u32)))
+svuint32_t svldff1sb_vnum_u32(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_vnum_u64)))
+svuint64_t svldff1sb_vnum_u64(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_vnum_u16)))
+svuint16_t svldff1sb_vnum_u16(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_vnum_s32)))
+svint32_t svldff1sb_vnum_s32(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_vnum_s64)))
+svint64_t svldff1sb_vnum_s64(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_vnum_s16)))
+svint16_t svldff1sb_vnum_s16(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_u32)))
+svuint32_t svldff1sb_u32(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_u64)))
+svuint64_t svldff1sb_u64(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_u16)))
+svuint16_t svldff1sb_u16(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_s32)))
+svint32_t svldff1sb_s32(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_s64)))
+svint64_t svldff1sb_s64(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_s16)))
+svint16_t svldff1sb_s16(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_index_u32)))
+svuint32_t svldff1sh_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_index_u64)))
+svuint64_t svldff1sh_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_index_s32)))
+svint32_t svldff1sh_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_index_s64)))
+svint64_t svldff1sh_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_offset_u32)))
+svuint32_t svldff1sh_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_offset_u64)))
+svuint64_t svldff1sh_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_offset_s32)))
+svint32_t svldff1sh_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_offset_s64)))
+svint64_t svldff1sh_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_u32)))
+svuint32_t svldff1sh_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_u64)))
+svuint64_t svldff1sh_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_s32)))
+svint32_t svldff1sh_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_s64)))
+svint64_t svldff1sh_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32index_u32)))
+svuint32_t svldff1sh_gather_s32index_u32(svbool_t, int16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32index_s32)))
+svint32_t svldff1sh_gather_s32index_s32(svbool_t, int16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32index_u32)))
+svuint32_t svldff1sh_gather_u32index_u32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32index_s32)))
+svint32_t svldff1sh_gather_u32index_s32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64index_u64)))
+svuint64_t svldff1sh_gather_s64index_u64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64index_s64)))
+svint64_t svldff1sh_gather_s64index_s64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64index_u64)))
+svuint64_t svldff1sh_gather_u64index_u64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64index_s64)))
+svint64_t svldff1sh_gather_u64index_s64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32offset_u32)))
+svuint32_t svldff1sh_gather_s32offset_u32(svbool_t, int16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32offset_s32)))
+svint32_t svldff1sh_gather_s32offset_s32(svbool_t, int16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32offset_u32)))
+svuint32_t svldff1sh_gather_u32offset_u32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32offset_s32)))
+svint32_t svldff1sh_gather_u32offset_s32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64offset_u64)))
+svuint64_t svldff1sh_gather_s64offset_u64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64offset_s64)))
+svint64_t svldff1sh_gather_s64offset_s64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64offset_u64)))
+svuint64_t svldff1sh_gather_u64offset_u64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64offset_s64)))
+svint64_t svldff1sh_gather_u64offset_s64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_vnum_u32)))
+svuint32_t svldff1sh_vnum_u32(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_vnum_u64)))
+svuint64_t svldff1sh_vnum_u64(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_vnum_s32)))
+svint32_t svldff1sh_vnum_s32(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_vnum_s64)))
+svint64_t svldff1sh_vnum_s64(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_u32)))
+svuint32_t svldff1sh_u32(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_u64)))
+svuint64_t svldff1sh_u64(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_s32)))
+svint32_t svldff1sh_s32(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_s64)))
+svint64_t svldff1sh_s64(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_index_u64)))
+svuint64_t svldff1sw_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_index_s64)))
+svint64_t svldff1sw_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_offset_u64)))
+svuint64_t svldff1sw_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_offset_s64)))
+svint64_t svldff1sw_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_u64)))
+svuint64_t svldff1sw_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_s64)))
+svint64_t svldff1sw_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64index_u64)))
+svuint64_t svldff1sw_gather_s64index_u64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64index_s64)))
+svint64_t svldff1sw_gather_s64index_s64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64index_u64)))
+svuint64_t svldff1sw_gather_u64index_u64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64index_s64)))
+svint64_t svldff1sw_gather_u64index_s64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64offset_u64)))
+svuint64_t svldff1sw_gather_s64offset_u64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64offset_s64)))
+svint64_t svldff1sw_gather_s64offset_s64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64offset_u64)))
+svuint64_t svldff1sw_gather_u64offset_u64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64offset_s64)))
+svint64_t svldff1sw_gather_u64offset_s64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_vnum_u64)))
+svuint64_t svldff1sw_vnum_u64(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_vnum_s64)))
+svint64_t svldff1sw_vnum_s64(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_u64)))
+svuint64_t svldff1sw_u64(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_s64)))
+svint64_t svldff1sw_s64(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_offset_u32)))
+svuint32_t svldff1ub_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_offset_u64)))
+svuint64_t svldff1ub_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_offset_s32)))
+svint32_t svldff1ub_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_offset_s64)))
+svint64_t svldff1ub_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_u32)))
+svuint32_t svldff1ub_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_u64)))
+svuint64_t svldff1ub_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_s32)))
+svint32_t svldff1ub_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_s64)))
+svint64_t svldff1ub_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s32offset_u32)))
+svuint32_t svldff1ub_gather_s32offset_u32(svbool_t, uint8_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s32offset_s32)))
+svint32_t svldff1ub_gather_s32offset_s32(svbool_t, uint8_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32offset_u32)))
+svuint32_t svldff1ub_gather_u32offset_u32(svbool_t, uint8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32offset_s32)))
+svint32_t svldff1ub_gather_u32offset_s32(svbool_t, uint8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s64offset_u64)))
+svuint64_t svldff1ub_gather_s64offset_u64(svbool_t, uint8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s64offset_s64)))
+svint64_t svldff1ub_gather_s64offset_s64(svbool_t, uint8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64offset_u64)))
+svuint64_t svldff1ub_gather_u64offset_u64(svbool_t, uint8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64offset_s64)))
+svint64_t svldff1ub_gather_u64offset_s64(svbool_t, uint8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_vnum_u32)))
+svuint32_t svldff1ub_vnum_u32(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_vnum_u64)))
+svuint64_t svldff1ub_vnum_u64(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_vnum_u16)))
+svuint16_t svldff1ub_vnum_u16(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_vnum_s32)))
+svint32_t svldff1ub_vnum_s32(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_vnum_s64)))
+svint64_t svldff1ub_vnum_s64(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_vnum_s16)))
+svint16_t svldff1ub_vnum_s16(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_u32)))
+svuint32_t svldff1ub_u32(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_u64)))
+svuint64_t svldff1ub_u64(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_u16)))
+svuint16_t svldff1ub_u16(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_s32)))
+svint32_t svldff1ub_s32(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_s64)))
+svint64_t svldff1ub_s64(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_s16)))
+svint16_t svldff1ub_s16(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_index_u32)))
+svuint32_t svldff1uh_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_index_u64)))
+svuint64_t svldff1uh_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_index_s32)))
+svint32_t svldff1uh_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_index_s64)))
+svint64_t svldff1uh_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_offset_u32)))
+svuint32_t svldff1uh_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_offset_u64)))
+svuint64_t svldff1uh_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_offset_s32)))
+svint32_t svldff1uh_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_offset_s64)))
+svint64_t svldff1uh_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_u32)))
+svuint32_t svldff1uh_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_u64)))
+svuint64_t svldff1uh_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_s32)))
+svint32_t svldff1uh_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_s64)))
+svint64_t svldff1uh_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32index_u32)))
+svuint32_t svldff1uh_gather_s32index_u32(svbool_t, uint16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32index_s32)))
+svint32_t svldff1uh_gather_s32index_s32(svbool_t, uint16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32index_u32)))
+svuint32_t svldff1uh_gather_u32index_u32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32index_s32)))
+svint32_t svldff1uh_gather_u32index_s32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64index_u64)))
+svuint64_t svldff1uh_gather_s64index_u64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64index_s64)))
+svint64_t svldff1uh_gather_s64index_s64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64index_u64)))
+svuint64_t svldff1uh_gather_u64index_u64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64index_s64)))
+svint64_t svldff1uh_gather_u64index_s64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32offset_u32)))
+svuint32_t svldff1uh_gather_s32offset_u32(svbool_t, uint16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32offset_s32)))
+svint32_t svldff1uh_gather_s32offset_s32(svbool_t, uint16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32offset_u32)))
+svuint32_t svldff1uh_gather_u32offset_u32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32offset_s32)))
+svint32_t svldff1uh_gather_u32offset_s32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64offset_u64)))
+svuint64_t svldff1uh_gather_s64offset_u64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64offset_s64)))
+svint64_t svldff1uh_gather_s64offset_s64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64offset_u64)))
+svuint64_t svldff1uh_gather_u64offset_u64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64offset_s64)))
+svint64_t svldff1uh_gather_u64offset_s64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_vnum_u32)))
+svuint32_t svldff1uh_vnum_u32(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_vnum_u64)))
+svuint64_t svldff1uh_vnum_u64(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_vnum_s32)))
+svint32_t svldff1uh_vnum_s32(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_vnum_s64)))
+svint64_t svldff1uh_vnum_s64(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_u32)))
+svuint32_t svldff1uh_u32(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_u64)))
+svuint64_t svldff1uh_u64(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_s32)))
+svint32_t svldff1uh_s32(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_s64)))
+svint64_t svldff1uh_s64(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_index_u64)))
+svuint64_t svldff1uw_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_index_s64)))
+svint64_t svldff1uw_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_offset_u64)))
+svuint64_t svldff1uw_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_offset_s64)))
+svint64_t svldff1uw_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_u64)))
+svuint64_t svldff1uw_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_s64)))
+svint64_t svldff1uw_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64index_u64)))
+svuint64_t svldff1uw_gather_s64index_u64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64index_s64)))
+svint64_t svldff1uw_gather_s64index_s64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64index_u64)))
+svuint64_t svldff1uw_gather_u64index_u64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64index_s64)))
+svint64_t svldff1uw_gather_u64index_s64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64offset_u64)))
+svuint64_t svldff1uw_gather_s64offset_u64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64offset_s64)))
+svint64_t svldff1uw_gather_s64offset_s64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64offset_u64)))
+svuint64_t svldff1uw_gather_u64offset_u64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64offset_s64)))
+svint64_t svldff1uw_gather_u64offset_s64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_vnum_u64)))
+svuint64_t svldff1uw_vnum_u64(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_vnum_s64)))
+svint64_t svldff1uw_vnum_s64(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_u64)))
+svuint64_t svldff1uw_u64(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_s64)))
+svint64_t svldff1uw_s64(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u8)))
+svuint8_t svldnf1_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u32)))
+svuint32_t svldnf1_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u64)))
+svuint64_t svldnf1_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u16)))
+svuint16_t svldnf1_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s8)))
+svint8_t svldnf1_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_f64)))
+svfloat64_t svldnf1_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_f32)))
+svfloat32_t svldnf1_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_f16)))
+svfloat16_t svldnf1_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s32)))
+svint32_t svldnf1_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s64)))
+svint64_t svldnf1_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s16)))
+svint16_t svldnf1_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u8)))
+svuint8_t svldnf1_vnum_u8(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u32)))
+svuint32_t svldnf1_vnum_u32(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u64)))
+svuint64_t svldnf1_vnum_u64(svbool_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u16)))
+svuint16_t svldnf1_vnum_u16(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s8)))
+svint8_t svldnf1_vnum_s8(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_f64)))
+svfloat64_t svldnf1_vnum_f64(svbool_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_f32)))
+svfloat32_t svldnf1_vnum_f32(svbool_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_f16)))
+svfloat16_t svldnf1_vnum_f16(svbool_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s32)))
+svint32_t svldnf1_vnum_s32(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s64)))
+svint64_t svldnf1_vnum_s64(svbool_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s16)))
+svint16_t svldnf1_vnum_s16(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_vnum_u32)))
+svuint32_t svldnf1sb_vnum_u32(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_vnum_u64)))
+svuint64_t svldnf1sb_vnum_u64(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_vnum_u16)))
+svuint16_t svldnf1sb_vnum_u16(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_vnum_s32)))
+svint32_t svldnf1sb_vnum_s32(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_vnum_s64)))
+svint64_t svldnf1sb_vnum_s64(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_vnum_s16)))
+svint16_t svldnf1sb_vnum_s16(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_u32)))
+svuint32_t svldnf1sb_u32(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_u64)))
+svuint64_t svldnf1sb_u64(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_u16)))
+svuint16_t svldnf1sb_u16(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_s32)))
+svint32_t svldnf1sb_s32(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_s64)))
+svint64_t svldnf1sb_s64(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_s16)))
+svint16_t svldnf1sb_s16(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_vnum_u32)))
+svuint32_t svldnf1sh_vnum_u32(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_vnum_u64)))
+svuint64_t svldnf1sh_vnum_u64(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_vnum_s32)))
+svint32_t svldnf1sh_vnum_s32(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_vnum_s64)))
+svint64_t svldnf1sh_vnum_s64(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_u32)))
+svuint32_t svldnf1sh_u32(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_u64)))
+svuint64_t svldnf1sh_u64(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_s32)))
+svint32_t svldnf1sh_s32(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_s64)))
+svint64_t svldnf1sh_s64(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sw_vnum_u64)))
+svuint64_t svldnf1sw_vnum_u64(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sw_vnum_s64)))
+svint64_t svldnf1sw_vnum_s64(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sw_u64)))
+svuint64_t svldnf1sw_u64(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sw_s64)))
+svint64_t svldnf1sw_s64(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_vnum_u32)))
+svuint32_t svldnf1ub_vnum_u32(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_vnum_u64)))
+svuint64_t svldnf1ub_vnum_u64(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_vnum_u16)))
+svuint16_t svldnf1ub_vnum_u16(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_vnum_s32)))
+svint32_t svldnf1ub_vnum_s32(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_vnum_s64)))
+svint64_t svldnf1ub_vnum_s64(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_vnum_s16)))
+svint16_t svldnf1ub_vnum_s16(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_u32)))
+svuint32_t svldnf1ub_u32(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_u64)))
+svuint64_t svldnf1ub_u64(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_u16)))
+svuint16_t svldnf1ub_u16(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_s32)))
+svint32_t svldnf1ub_s32(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_s64)))
+svint64_t svldnf1ub_s64(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_s16)))
+svint16_t svldnf1ub_s16(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_vnum_u32)))
+svuint32_t svldnf1uh_vnum_u32(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_vnum_u64)))
+svuint64_t svldnf1uh_vnum_u64(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_vnum_s32)))
+svint32_t svldnf1uh_vnum_s32(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_vnum_s64)))
+svint64_t svldnf1uh_vnum_s64(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_u32)))
+svuint32_t svldnf1uh_u32(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_u64)))
+svuint64_t svldnf1uh_u64(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_s32)))
+svint32_t svldnf1uh_s32(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_s64)))
+svint64_t svldnf1uh_s64(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uw_vnum_u64)))
+svuint64_t svldnf1uw_vnum_u64(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uw_vnum_s64)))
+svint64_t svldnf1uw_vnum_s64(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uw_u64)))
+svuint64_t svldnf1uw_u64(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uw_s64)))
+svint64_t svldnf1uw_s64(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u32base)))
+void svprfb_gather_u32base(svbool_t, svuint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u64base)))
+void svprfb_gather_u64base(svbool_t, svuint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u32base_offset)))
+void svprfb_gather_u32base_offset(svbool_t, svuint32_t, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u64base_offset)))
+void svprfb_gather_u64base_offset(svbool_t, svuint64_t, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_s32offset)))
+void svprfb_gather_s32offset(svbool_t, void const *, svint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u32offset)))
+void svprfb_gather_u32offset(svbool_t, void const *, svuint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_s64offset)))
+void svprfb_gather_s64offset(svbool_t, void const *, svint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u64offset)))
+void svprfb_gather_u64offset(svbool_t, void const *, svuint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u32base)))
+void svprfd_gather_u32base(svbool_t, svuint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u64base)))
+void svprfd_gather_u64base(svbool_t, svuint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u32base_index)))
+void svprfd_gather_u32base_index(svbool_t, svuint32_t, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u64base_index)))
+void svprfd_gather_u64base_index(svbool_t, svuint64_t, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_s32index)))
+void svprfd_gather_s32index(svbool_t, void const *, svint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u32index)))
+void svprfd_gather_u32index(svbool_t, void const *, svuint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_s64index)))
+void svprfd_gather_s64index(svbool_t, void const *, svint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u64index)))
+void svprfd_gather_u64index(svbool_t, void const *, svuint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u32base)))
+void svprfh_gather_u32base(svbool_t, svuint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u64base)))
+void svprfh_gather_u64base(svbool_t, svuint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u32base_index)))
+void svprfh_gather_u32base_index(svbool_t, svuint32_t, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u64base_index)))
+void svprfh_gather_u64base_index(svbool_t, svuint64_t, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_s32index)))
+void svprfh_gather_s32index(svbool_t, void const *, svint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u32index)))
+void svprfh_gather_u32index(svbool_t, void const *, svuint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_s64index)))
+void svprfh_gather_s64index(svbool_t, void const *, svint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u64index)))
+void svprfh_gather_u64index(svbool_t, void const *, svuint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u32base)))
+void svprfw_gather_u32base(svbool_t, svuint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u64base)))
+void svprfw_gather_u64base(svbool_t, svuint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u32base_index)))
+void svprfw_gather_u32base_index(svbool_t, svuint32_t, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u64base_index)))
+void svprfw_gather_u64base_index(svbool_t, svuint64_t, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_s32index)))
+void svprfw_gather_s32index(svbool_t, void const *, svint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u32index)))
+void svprfw_gather_u32index(svbool_t, void const *, svuint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_s64index)))
+void svprfw_gather_s64index(svbool_t, void const *, svint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u64index)))
+void svprfw_gather_u64index(svbool_t, void const *, svuint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrdffr)))
+svbool_t svrdffr(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrdffr_z)))
+svbool_t svrdffr_z(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsetffr)))
+void svsetffr(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_index_u32)))
+void svst1_scatter_u32base_index_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_index_u64)))
+void svst1_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_index_f64)))
+void svst1_scatter_u64base_index_f64(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_index_f32)))
+void svst1_scatter_u32base_index_f32(svbool_t, svuint32_t, int64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_index_s32)))
+void svst1_scatter_u32base_index_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_index_s64)))
+void svst1_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_offset_u32)))
+void svst1_scatter_u32base_offset_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_offset_u64)))
+void svst1_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_offset_f64)))
+void svst1_scatter_u64base_offset_f64(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_offset_f32)))
+void svst1_scatter_u32base_offset_f32(svbool_t, svuint32_t, int64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_offset_s32)))
+void svst1_scatter_u32base_offset_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_offset_s64)))
+void svst1_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_u32)))
+void svst1_scatter_u32base_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_u64)))
+void svst1_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_f64)))
+void svst1_scatter_u64base_f64(svbool_t, svuint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_f32)))
+void svst1_scatter_u32base_f32(svbool_t, svuint32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_s32)))
+void svst1_scatter_u32base_s32(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_s64)))
+void svst1_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32index_u32)))
+void svst1_scatter_s32index_u32(svbool_t, uint32_t *, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32index_f32)))
+void svst1_scatter_s32index_f32(svbool_t, float32_t *, svint32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32index_s32)))
+void svst1_scatter_s32index_s32(svbool_t, int32_t *, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32index_u32)))
+void svst1_scatter_u32index_u32(svbool_t, uint32_t *, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32index_f32)))
+void svst1_scatter_u32index_f32(svbool_t, float32_t *, svuint32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32index_s32)))
+void svst1_scatter_u32index_s32(svbool_t, int32_t *, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64index_u64)))
+void svst1_scatter_s64index_u64(svbool_t, uint64_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64index_f64)))
+void svst1_scatter_s64index_f64(svbool_t, float64_t *, svint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64index_s64)))
+void svst1_scatter_s64index_s64(svbool_t, int64_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64index_u64)))
+void svst1_scatter_u64index_u64(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64index_f64)))
+void svst1_scatter_u64index_f64(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64index_s64)))
+void svst1_scatter_u64index_s64(svbool_t, int64_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32offset_u32)))
+void svst1_scatter_s32offset_u32(svbool_t, uint32_t *, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32offset_f32)))
+void svst1_scatter_s32offset_f32(svbool_t, float32_t *, svint32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32offset_s32)))
+void svst1_scatter_s32offset_s32(svbool_t, int32_t *, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32offset_u32)))
+void svst1_scatter_u32offset_u32(svbool_t, uint32_t *, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32offset_f32)))
+void svst1_scatter_u32offset_f32(svbool_t, float32_t *, svuint32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32offset_s32)))
+void svst1_scatter_u32offset_s32(svbool_t, int32_t *, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64offset_u64)))
+void svst1_scatter_s64offset_u64(svbool_t, uint64_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64offset_f64)))
+void svst1_scatter_s64offset_f64(svbool_t, float64_t *, svint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64offset_s64)))
+void svst1_scatter_s64offset_s64(svbool_t, int64_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64offset_u64)))
+void svst1_scatter_u64offset_u64(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64offset_f64)))
+void svst1_scatter_u64offset_f64(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64offset_s64)))
+void svst1_scatter_u64offset_s64(svbool_t, int64_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_offset_u32)))
+void svst1b_scatter_u32base_offset_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_offset_u64)))
+void svst1b_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_offset_s32)))
+void svst1b_scatter_u32base_offset_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_offset_s64)))
+void svst1b_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_u32)))
+void svst1b_scatter_u32base_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_u64)))
+void svst1b_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_s32)))
+void svst1b_scatter_u32base_s32(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_s64)))
+void svst1b_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s32offset_s32)))
+void svst1b_scatter_s32offset_s32(svbool_t, int8_t *, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s32offset_u32)))
+void svst1b_scatter_s32offset_u32(svbool_t, uint8_t *, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32offset_s32)))
+void svst1b_scatter_u32offset_s32(svbool_t, int8_t *, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32offset_u32)))
+void svst1b_scatter_u32offset_u32(svbool_t, uint8_t *, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s64offset_s64)))
+void svst1b_scatter_s64offset_s64(svbool_t, int8_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s64offset_u64)))
+void svst1b_scatter_s64offset_u64(svbool_t, uint8_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64offset_s64)))
+void svst1b_scatter_u64offset_s64(svbool_t, int8_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64offset_u64)))
+void svst1b_scatter_u64offset_u64(svbool_t, uint8_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_index_u32)))
+void svst1h_scatter_u32base_index_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_index_u64)))
+void svst1h_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_index_s32)))
+void svst1h_scatter_u32base_index_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_index_s64)))
+void svst1h_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_offset_u32)))
+void svst1h_scatter_u32base_offset_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_offset_u64)))
+void svst1h_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_offset_s32)))
+void svst1h_scatter_u32base_offset_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_offset_s64)))
+void svst1h_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_u32)))
+void svst1h_scatter_u32base_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_u64)))
+void svst1h_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_s32)))
+void svst1h_scatter_u32base_s32(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_s64)))
+void svst1h_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32index_s32)))
+void svst1h_scatter_s32index_s32(svbool_t, int16_t *, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32index_u32)))
+void svst1h_scatter_s32index_u32(svbool_t, uint16_t *, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32index_s32)))
+void svst1h_scatter_u32index_s32(svbool_t, int16_t *, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32index_u32)))
+void svst1h_scatter_u32index_u32(svbool_t, uint16_t *, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64index_s64)))
+void svst1h_scatter_s64index_s64(svbool_t, int16_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64index_u64)))
+void svst1h_scatter_s64index_u64(svbool_t, uint16_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64index_s64)))
+void svst1h_scatter_u64index_s64(svbool_t, int16_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64index_u64)))
+void svst1h_scatter_u64index_u64(svbool_t, uint16_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32offset_s32)))
+void svst1h_scatter_s32offset_s32(svbool_t, int16_t *, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32offset_u32)))
+void svst1h_scatter_s32offset_u32(svbool_t, uint16_t *, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32offset_s32)))
+void svst1h_scatter_u32offset_s32(svbool_t, int16_t *, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32offset_u32)))
+void svst1h_scatter_u32offset_u32(svbool_t, uint16_t *, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64offset_s64)))
+void svst1h_scatter_s64offset_s64(svbool_t, int16_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64offset_u64)))
+void svst1h_scatter_s64offset_u64(svbool_t, uint16_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64offset_s64)))
+void svst1h_scatter_u64offset_s64(svbool_t, int16_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64offset_u64)))
+void svst1h_scatter_u64offset_u64(svbool_t, uint16_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_index_u64)))
+void svst1w_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_index_s64)))
+void svst1w_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_offset_u64)))
+void svst1w_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_offset_s64)))
+void svst1w_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_u64)))
+void svst1w_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_s64)))
+void svst1w_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64index_s64)))
+void svst1w_scatter_s64index_s64(svbool_t, int32_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64index_u64)))
+void svst1w_scatter_s64index_u64(svbool_t, uint32_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64index_s64)))
+void svst1w_scatter_u64index_s64(svbool_t, int32_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64index_u64)))
+void svst1w_scatter_u64index_u64(svbool_t, uint32_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64offset_s64)))
+void svst1w_scatter_s64offset_s64(svbool_t, int32_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64offset_u64)))
+void svst1w_scatter_s64offset_u64(svbool_t, uint32_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64offset_s64)))
+void svst1w_scatter_u64offset_s64(svbool_t, int32_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64offset_u64)))
+void svst1w_scatter_u64offset_u64(svbool_t, uint32_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtmad_f64)))
+svfloat64_t svtmad_f64(svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtmad_f32)))
+svfloat32_t svtmad_f32(svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtmad_f16)))
+svfloat16_t svtmad_f16(svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtsmul_f64)))
+svfloat64_t svtsmul_f64(svfloat64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtsmul_f32)))
+svfloat32_t svtsmul_f32(svfloat32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtsmul_f16)))
+svfloat16_t svtsmul_f16(svfloat16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtssel_f64)))
+svfloat64_t svtssel_f64(svfloat64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtssel_f32)))
+svfloat32_t svtssel_f32(svfloat32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtssel_f16)))
+svfloat16_t svtssel_f16(svfloat16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwrffr)))
+void svwrffr(svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u32base_u32offset)))
+svuint32_t svadrb_offset(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u64base_u64offset)))
+svuint64_t svadrb_offset(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u32base_s32offset)))
+svuint32_t svadrb_offset(svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u64base_s64offset)))
+svuint64_t svadrb_offset(svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u32base_u32index)))
+svuint32_t svadrd_index(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u64base_u64index)))
+svuint64_t svadrd_index(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u32base_s32index)))
+svuint32_t svadrd_index(svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u64base_s64index)))
+svuint64_t svadrd_index(svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u32base_u32index)))
+svuint32_t svadrh_index(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u64base_u64index)))
+svuint64_t svadrh_index(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u32base_s32index)))
+svuint32_t svadrh_index(svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u64base_s64index)))
+svuint64_t svadrh_index(svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u32base_u32index)))
+svuint32_t svadrw_index(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u64base_u64index)))
+svuint64_t svadrw_index(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u32base_s32index)))
+svuint32_t svadrw_index(svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u64base_s64index)))
+svuint64_t svadrw_index(svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_u32)))
+svuint32_t svcompact(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_u64)))
+svuint64_t svcompact(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_f64)))
+svfloat64_t svcompact(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_f32)))
+svfloat32_t svcompact(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_s32)))
+svint32_t svcompact(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_s64)))
+svint64_t svcompact(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexpa_f64)))
+svfloat64_t svexpa(svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexpa_f32)))
+svfloat32_t svexpa(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexpa_f16)))
+svfloat16_t svexpa(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_index_u32)))
+svuint32_t svld1_gather_index_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_index_u64)))
+svuint64_t svld1_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_index_f64)))
+svfloat64_t svld1_gather_index_f64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_index_f32)))
+svfloat32_t svld1_gather_index_f32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_index_s32)))
+svint32_t svld1_gather_index_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_index_s64)))
+svint64_t svld1_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_offset_u32)))
+svuint32_t svld1_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_offset_u64)))
+svuint64_t svld1_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_offset_f64)))
+svfloat64_t svld1_gather_offset_f64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_offset_f32)))
+svfloat32_t svld1_gather_offset_f32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_offset_s32)))
+svint32_t svld1_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_offset_s64)))
+svint64_t svld1_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_u32)))
+svuint32_t svld1_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_u64)))
+svuint64_t svld1_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_f64)))
+svfloat64_t svld1_gather_f64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_f32)))
+svfloat32_t svld1_gather_f32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_s32)))
+svint32_t svld1_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_s64)))
+svint64_t svld1_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32index_u32)))
+svuint32_t svld1_gather_index(svbool_t, uint32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32index_f32)))
+svfloat32_t svld1_gather_index(svbool_t, float32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32index_s32)))
+svint32_t svld1_gather_index(svbool_t, int32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32index_u32)))
+svuint32_t svld1_gather_index(svbool_t, uint32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32index_f32)))
+svfloat32_t svld1_gather_index(svbool_t, float32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32index_s32)))
+svint32_t svld1_gather_index(svbool_t, int32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64index_u64)))
+svuint64_t svld1_gather_index(svbool_t, uint64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64index_f64)))
+svfloat64_t svld1_gather_index(svbool_t, float64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64index_s64)))
+svint64_t svld1_gather_index(svbool_t, int64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64index_u64)))
+svuint64_t svld1_gather_index(svbool_t, uint64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64index_f64)))
+svfloat64_t svld1_gather_index(svbool_t, float64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64index_s64)))
+svint64_t svld1_gather_index(svbool_t, int64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32offset_u32)))
+svuint32_t svld1_gather_offset(svbool_t, uint32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32offset_f32)))
+svfloat32_t svld1_gather_offset(svbool_t, float32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32offset_s32)))
+svint32_t svld1_gather_offset(svbool_t, int32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32offset_u32)))
+svuint32_t svld1_gather_offset(svbool_t, uint32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32offset_f32)))
+svfloat32_t svld1_gather_offset(svbool_t, float32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32offset_s32)))
+svint32_t svld1_gather_offset(svbool_t, int32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64offset_u64)))
+svuint64_t svld1_gather_offset(svbool_t, uint64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64offset_f64)))
+svfloat64_t svld1_gather_offset(svbool_t, float64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64offset_s64)))
+svint64_t svld1_gather_offset(svbool_t, int64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64offset_u64)))
+svuint64_t svld1_gather_offset(svbool_t, uint64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64offset_f64)))
+svfloat64_t svld1_gather_offset(svbool_t, float64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64offset_s64)))
+svint64_t svld1_gather_offset(svbool_t, int64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_offset_u32)))
+svuint32_t svld1sb_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_offset_u64)))
+svuint64_t svld1sb_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_offset_s32)))
+svint32_t svld1sb_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_offset_s64)))
+svint64_t svld1sb_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_u32)))
+svuint32_t svld1sb_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_u64)))
+svuint64_t svld1sb_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_s32)))
+svint32_t svld1sb_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_s64)))
+svint64_t svld1sb_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s32offset_u32)))
+svuint32_t svld1sb_gather_offset_u32(svbool_t, int8_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s32offset_s32)))
+svint32_t svld1sb_gather_offset_s32(svbool_t, int8_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32offset_u32)))
+svuint32_t svld1sb_gather_offset_u32(svbool_t, int8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32offset_s32)))
+svint32_t svld1sb_gather_offset_s32(svbool_t, int8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s64offset_u64)))
+svuint64_t svld1sb_gather_offset_u64(svbool_t, int8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s64offset_s64)))
+svint64_t svld1sb_gather_offset_s64(svbool_t, int8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64offset_u64)))
+svuint64_t svld1sb_gather_offset_u64(svbool_t, int8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64offset_s64)))
+svint64_t svld1sb_gather_offset_s64(svbool_t, int8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_index_u32)))
+svuint32_t svld1sh_gather_index_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_index_u64)))
+svuint64_t svld1sh_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_index_s32)))
+svint32_t svld1sh_gather_index_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_index_s64)))
+svint64_t svld1sh_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_offset_u32)))
+svuint32_t svld1sh_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_offset_u64)))
+svuint64_t svld1sh_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_offset_s32)))
+svint32_t svld1sh_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_offset_s64)))
+svint64_t svld1sh_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_u32)))
+svuint32_t svld1sh_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_u64)))
+svuint64_t svld1sh_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_s32)))
+svint32_t svld1sh_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_s64)))
+svint64_t svld1sh_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32index_u32)))
+svuint32_t svld1sh_gather_index_u32(svbool_t, int16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32index_s32)))
+svint32_t svld1sh_gather_index_s32(svbool_t, int16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32index_u32)))
+svuint32_t svld1sh_gather_index_u32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32index_s32)))
+svint32_t svld1sh_gather_index_s32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64index_u64)))
+svuint64_t svld1sh_gather_index_u64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64index_s64)))
+svint64_t svld1sh_gather_index_s64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64index_u64)))
+svuint64_t svld1sh_gather_index_u64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64index_s64)))
+svint64_t svld1sh_gather_index_s64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32offset_u32)))
+svuint32_t svld1sh_gather_offset_u32(svbool_t, int16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32offset_s32)))
+svint32_t svld1sh_gather_offset_s32(svbool_t, int16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32offset_u32)))
+svuint32_t svld1sh_gather_offset_u32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32offset_s32)))
+svint32_t svld1sh_gather_offset_s32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64offset_u64)))
+svuint64_t svld1sh_gather_offset_u64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64offset_s64)))
+svint64_t svld1sh_gather_offset_s64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64offset_u64)))
+svuint64_t svld1sh_gather_offset_u64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64offset_s64)))
+svint64_t svld1sh_gather_offset_s64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_index_u64)))
+svuint64_t svld1sw_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_index_s64)))
+svint64_t svld1sw_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_offset_u64)))
+svuint64_t svld1sw_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_offset_s64)))
+svint64_t svld1sw_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_u64)))
+svuint64_t svld1sw_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_s64)))
+svint64_t svld1sw_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64index_u64)))
+svuint64_t svld1sw_gather_index_u64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64index_s64)))
+svint64_t svld1sw_gather_index_s64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64index_u64)))
+svuint64_t svld1sw_gather_index_u64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64index_s64)))
+svint64_t svld1sw_gather_index_s64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64offset_u64)))
+svuint64_t svld1sw_gather_offset_u64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64offset_s64)))
+svint64_t svld1sw_gather_offset_s64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64offset_u64)))
+svuint64_t svld1sw_gather_offset_u64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64offset_s64)))
+svint64_t svld1sw_gather_offset_s64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_offset_u32)))
+svuint32_t svld1ub_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_offset_u64)))
+svuint64_t svld1ub_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_offset_s32)))
+svint32_t svld1ub_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_offset_s64)))
+svint64_t svld1ub_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_u32)))
+svuint32_t svld1ub_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_u64)))
+svuint64_t svld1ub_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_s32)))
+svint32_t svld1ub_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_s64)))
+svint64_t svld1ub_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s32offset_u32)))
+svuint32_t svld1ub_gather_offset_u32(svbool_t, uint8_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s32offset_s32)))
+svint32_t svld1ub_gather_offset_s32(svbool_t, uint8_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32offset_u32)))
+svuint32_t svld1ub_gather_offset_u32(svbool_t, uint8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32offset_s32)))
+svint32_t svld1ub_gather_offset_s32(svbool_t, uint8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s64offset_u64)))
+svuint64_t svld1ub_gather_offset_u64(svbool_t, uint8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s64offset_s64)))
+svint64_t svld1ub_gather_offset_s64(svbool_t, uint8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64offset_u64)))
+svuint64_t svld1ub_gather_offset_u64(svbool_t, uint8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64offset_s64)))
+svint64_t svld1ub_gather_offset_s64(svbool_t, uint8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_index_u32)))
+svuint32_t svld1uh_gather_index_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_index_u64)))
+svuint64_t svld1uh_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_index_s32)))
+svint32_t svld1uh_gather_index_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_index_s64)))
+svint64_t svld1uh_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_offset_u32)))
+svuint32_t svld1uh_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_offset_u64)))
+svuint64_t svld1uh_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_offset_s32)))
+svint32_t svld1uh_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_offset_s64)))
+svint64_t svld1uh_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_u32)))
+svuint32_t svld1uh_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_u64)))
+svuint64_t svld1uh_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_s32)))
+svint32_t svld1uh_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_s64)))
+svint64_t svld1uh_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32index_u32)))
+svuint32_t svld1uh_gather_index_u32(svbool_t, uint16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32index_s32)))
+svint32_t svld1uh_gather_index_s32(svbool_t, uint16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32index_u32)))
+svuint32_t svld1uh_gather_index_u32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32index_s32)))
+svint32_t svld1uh_gather_index_s32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64index_u64)))
+svuint64_t svld1uh_gather_index_u64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64index_s64)))
+svint64_t svld1uh_gather_index_s64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64index_u64)))
+svuint64_t svld1uh_gather_index_u64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64index_s64)))
+svint64_t svld1uh_gather_index_s64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32offset_u32)))
+svuint32_t svld1uh_gather_offset_u32(svbool_t, uint16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32offset_s32)))
+svint32_t svld1uh_gather_offset_s32(svbool_t, uint16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32offset_u32)))
+svuint32_t svld1uh_gather_offset_u32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32offset_s32)))
+svint32_t svld1uh_gather_offset_s32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64offset_u64)))
+svuint64_t svld1uh_gather_offset_u64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64offset_s64)))
+svint64_t svld1uh_gather_offset_s64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64offset_u64)))
+svuint64_t svld1uh_gather_offset_u64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64offset_s64)))
+svint64_t svld1uh_gather_offset_s64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_index_u64)))
+svuint64_t svld1uw_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_index_s64)))
+svint64_t svld1uw_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_offset_u64)))
+svuint64_t svld1uw_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_offset_s64)))
+svint64_t svld1uw_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_u64)))
+svuint64_t svld1uw_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_s64)))
+svint64_t svld1uw_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64index_u64)))
+svuint64_t svld1uw_gather_index_u64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64index_s64)))
+svint64_t svld1uw_gather_index_s64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64index_u64)))
+svuint64_t svld1uw_gather_index_u64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64index_s64)))
+svint64_t svld1uw_gather_index_s64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64offset_u64)))
+svuint64_t svld1uw_gather_offset_u64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64offset_s64)))
+svint64_t svld1uw_gather_offset_s64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64offset_u64)))
+svuint64_t svld1uw_gather_offset_u64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64offset_s64)))
+svint64_t svld1uw_gather_offset_s64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u8)))
+svuint8_t svldff1(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u32)))
+svuint32_t svldff1(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u64)))
+svuint64_t svldff1(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u16)))
+svuint16_t svldff1(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s8)))
+svint8_t svldff1(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_f64)))
+svfloat64_t svldff1(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_f32)))
+svfloat32_t svldff1(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_f16)))
+svfloat16_t svldff1(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s32)))
+svint32_t svldff1(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s64)))
+svint64_t svldff1(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s16)))
+svint16_t svldff1(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_index_u32)))
+svuint32_t svldff1_gather_index_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_index_u64)))
+svuint64_t svldff1_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_index_f64)))
+svfloat64_t svldff1_gather_index_f64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_index_f32)))
+svfloat32_t svldff1_gather_index_f32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_index_s32)))
+svint32_t svldff1_gather_index_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_index_s64)))
+svint64_t svldff1_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_offset_u32)))
+svuint32_t svldff1_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_offset_u64)))
+svuint64_t svldff1_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_offset_f64)))
+svfloat64_t svldff1_gather_offset_f64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_offset_f32)))
+svfloat32_t svldff1_gather_offset_f32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_offset_s32)))
+svint32_t svldff1_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_offset_s64)))
+svint64_t svldff1_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_u32)))
+svuint32_t svldff1_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_u64)))
+svuint64_t svldff1_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_f64)))
+svfloat64_t svldff1_gather_f64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_f32)))
+svfloat32_t svldff1_gather_f32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_s32)))
+svint32_t svldff1_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_s64)))
+svint64_t svldff1_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32index_u32)))
+svuint32_t svldff1_gather_index(svbool_t, uint32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32index_f32)))
+svfloat32_t svldff1_gather_index(svbool_t, float32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32index_s32)))
+svint32_t svldff1_gather_index(svbool_t, int32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32index_u32)))
+svuint32_t svldff1_gather_index(svbool_t, uint32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32index_f32)))
+svfloat32_t svldff1_gather_index(svbool_t, float32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32index_s32)))
+svint32_t svldff1_gather_index(svbool_t, int32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64index_u64)))
+svuint64_t svldff1_gather_index(svbool_t, uint64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64index_f64)))
+svfloat64_t svldff1_gather_index(svbool_t, float64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64index_s64)))
+svint64_t svldff1_gather_index(svbool_t, int64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64index_u64)))
+svuint64_t svldff1_gather_index(svbool_t, uint64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64index_f64)))
+svfloat64_t svldff1_gather_index(svbool_t, float64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64index_s64)))
+svint64_t svldff1_gather_index(svbool_t, int64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32offset_u32)))
+svuint32_t svldff1_gather_offset(svbool_t, uint32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32offset_f32)))
+svfloat32_t svldff1_gather_offset(svbool_t, float32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32offset_s32)))
+svint32_t svldff1_gather_offset(svbool_t, int32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32offset_u32)))
+svuint32_t svldff1_gather_offset(svbool_t, uint32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32offset_f32)))
+svfloat32_t svldff1_gather_offset(svbool_t, float32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32offset_s32)))
+svint32_t svldff1_gather_offset(svbool_t, int32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64offset_u64)))
+svuint64_t svldff1_gather_offset(svbool_t, uint64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64offset_f64)))
+svfloat64_t svldff1_gather_offset(svbool_t, float64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64offset_s64)))
+svint64_t svldff1_gather_offset(svbool_t, int64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64offset_u64)))
+svuint64_t svldff1_gather_offset(svbool_t, uint64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64offset_f64)))
+svfloat64_t svldff1_gather_offset(svbool_t, float64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64offset_s64)))
+svint64_t svldff1_gather_offset(svbool_t, int64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u8)))
+svuint8_t svldff1_vnum(svbool_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u32)))
+svuint32_t svldff1_vnum(svbool_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u64)))
+svuint64_t svldff1_vnum(svbool_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u16)))
+svuint16_t svldff1_vnum(svbool_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s8)))
+svint8_t svldff1_vnum(svbool_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_f64)))
+svfloat64_t svldff1_vnum(svbool_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_f32)))
+svfloat32_t svldff1_vnum(svbool_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_f16)))
+svfloat16_t svldff1_vnum(svbool_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s32)))
+svint32_t svldff1_vnum(svbool_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s64)))
+svint64_t svldff1_vnum(svbool_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s16)))
+svint16_t svldff1_vnum(svbool_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_offset_u32)))
+svuint32_t svldff1sb_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_offset_u64)))
+svuint64_t svldff1sb_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_offset_s32)))
+svint32_t svldff1sb_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_offset_s64)))
+svint64_t svldff1sb_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_u32)))
+svuint32_t svldff1sb_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_u64)))
+svuint64_t svldff1sb_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_s32)))
+svint32_t svldff1sb_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_s64)))
+svint64_t svldff1sb_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s32offset_u32)))
+svuint32_t svldff1sb_gather_offset_u32(svbool_t, int8_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s32offset_s32)))
+svint32_t svldff1sb_gather_offset_s32(svbool_t, int8_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32offset_u32)))
+svuint32_t svldff1sb_gather_offset_u32(svbool_t, int8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32offset_s32)))
+svint32_t svldff1sb_gather_offset_s32(svbool_t, int8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s64offset_u64)))
+svuint64_t svldff1sb_gather_offset_u64(svbool_t, int8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s64offset_s64)))
+svint64_t svldff1sb_gather_offset_s64(svbool_t, int8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64offset_u64)))
+svuint64_t svldff1sb_gather_offset_u64(svbool_t, int8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64offset_s64)))
+svint64_t svldff1sb_gather_offset_s64(svbool_t, int8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_index_u32)))
+svuint32_t svldff1sh_gather_index_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_index_u64)))
+svuint64_t svldff1sh_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_index_s32)))
+svint32_t svldff1sh_gather_index_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_index_s64)))
+svint64_t svldff1sh_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_offset_u32)))
+svuint32_t svldff1sh_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_offset_u64)))
+svuint64_t svldff1sh_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_offset_s32)))
+svint32_t svldff1sh_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_offset_s64)))
+svint64_t svldff1sh_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_u32)))
+svuint32_t svldff1sh_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_u64)))
+svuint64_t svldff1sh_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_s32)))
+svint32_t svldff1sh_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_s64)))
+svint64_t svldff1sh_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32index_u32)))
+svuint32_t svldff1sh_gather_index_u32(svbool_t, int16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32index_s32)))
+svint32_t svldff1sh_gather_index_s32(svbool_t, int16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32index_u32)))
+svuint32_t svldff1sh_gather_index_u32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32index_s32)))
+svint32_t svldff1sh_gather_index_s32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64index_u64)))
+svuint64_t svldff1sh_gather_index_u64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64index_s64)))
+svint64_t svldff1sh_gather_index_s64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64index_u64)))
+svuint64_t svldff1sh_gather_index_u64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64index_s64)))
+svint64_t svldff1sh_gather_index_s64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32offset_u32)))
+svuint32_t svldff1sh_gather_offset_u32(svbool_t, int16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32offset_s32)))
+svint32_t svldff1sh_gather_offset_s32(svbool_t, int16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32offset_u32)))
+svuint32_t svldff1sh_gather_offset_u32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32offset_s32)))
+svint32_t svldff1sh_gather_offset_s32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64offset_u64)))
+svuint64_t svldff1sh_gather_offset_u64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64offset_s64)))
+svint64_t svldff1sh_gather_offset_s64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64offset_u64)))
+svuint64_t svldff1sh_gather_offset_u64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64offset_s64)))
+svint64_t svldff1sh_gather_offset_s64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_index_u64)))
+svuint64_t svldff1sw_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_index_s64)))
+svint64_t svldff1sw_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_offset_u64)))
+svuint64_t svldff1sw_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_offset_s64)))
+svint64_t svldff1sw_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_u64)))
+svuint64_t svldff1sw_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_s64)))
+svint64_t svldff1sw_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64index_u64)))
+svuint64_t svldff1sw_gather_index_u64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64index_s64)))
+svint64_t svldff1sw_gather_index_s64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64index_u64)))
+svuint64_t svldff1sw_gather_index_u64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64index_s64)))
+svint64_t svldff1sw_gather_index_s64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64offset_u64)))
+svuint64_t svldff1sw_gather_offset_u64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64offset_s64)))
+svint64_t svldff1sw_gather_offset_s64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64offset_u64)))
+svuint64_t svldff1sw_gather_offset_u64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64offset_s64)))
+svint64_t svldff1sw_gather_offset_s64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_offset_u32)))
+svuint32_t svldff1ub_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_offset_u64)))
+svuint64_t svldff1ub_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_offset_s32)))
+svint32_t svldff1ub_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_offset_s64)))
+svint64_t svldff1ub_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_u32)))
+svuint32_t svldff1ub_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_u64)))
+svuint64_t svldff1ub_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_s32)))
+svint32_t svldff1ub_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_s64)))
+svint64_t svldff1ub_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s32offset_u32)))
+svuint32_t svldff1ub_gather_offset_u32(svbool_t, uint8_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s32offset_s32)))
+svint32_t svldff1ub_gather_offset_s32(svbool_t, uint8_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32offset_u32)))
+svuint32_t svldff1ub_gather_offset_u32(svbool_t, uint8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32offset_s32)))
+svint32_t svldff1ub_gather_offset_s32(svbool_t, uint8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s64offset_u64)))
+svuint64_t svldff1ub_gather_offset_u64(svbool_t, uint8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s64offset_s64)))
+svint64_t svldff1ub_gather_offset_s64(svbool_t, uint8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64offset_u64)))
+svuint64_t svldff1ub_gather_offset_u64(svbool_t, uint8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64offset_s64)))
+svint64_t svldff1ub_gather_offset_s64(svbool_t, uint8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_index_u32)))
+svuint32_t svldff1uh_gather_index_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_index_u64)))
+svuint64_t svldff1uh_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_index_s32)))
+svint32_t svldff1uh_gather_index_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_index_s64)))
+svint64_t svldff1uh_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_offset_u32)))
+svuint32_t svldff1uh_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_offset_u64)))
+svuint64_t svldff1uh_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_offset_s32)))
+svint32_t svldff1uh_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_offset_s64)))
+svint64_t svldff1uh_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_u32)))
+svuint32_t svldff1uh_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_u64)))
+svuint64_t svldff1uh_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_s32)))
+svint32_t svldff1uh_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_s64)))
+svint64_t svldff1uh_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32index_u32)))
+svuint32_t svldff1uh_gather_index_u32(svbool_t, uint16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32index_s32)))
+svint32_t svldff1uh_gather_index_s32(svbool_t, uint16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32index_u32)))
+svuint32_t svldff1uh_gather_index_u32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32index_s32)))
+svint32_t svldff1uh_gather_index_s32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64index_u64)))
+svuint64_t svldff1uh_gather_index_u64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64index_s64)))
+svint64_t svldff1uh_gather_index_s64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64index_u64)))
+svuint64_t svldff1uh_gather_index_u64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64index_s64)))
+svint64_t svldff1uh_gather_index_s64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32offset_u32)))
+svuint32_t svldff1uh_gather_offset_u32(svbool_t, uint16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32offset_s32)))
+svint32_t svldff1uh_gather_offset_s32(svbool_t, uint16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32offset_u32)))
+svuint32_t svldff1uh_gather_offset_u32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32offset_s32)))
+svint32_t svldff1uh_gather_offset_s32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64offset_u64)))
+svuint64_t svldff1uh_gather_offset_u64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64offset_s64)))
+svint64_t svldff1uh_gather_offset_s64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64offset_u64)))
+svuint64_t svldff1uh_gather_offset_u64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64offset_s64)))
+svint64_t svldff1uh_gather_offset_s64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_index_u64)))
+svuint64_t svldff1uw_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_index_s64)))
+svint64_t svldff1uw_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_offset_u64)))
+svuint64_t svldff1uw_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_offset_s64)))
+svint64_t svldff1uw_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_u64)))
+svuint64_t svldff1uw_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_s64)))
+svint64_t svldff1uw_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64index_u64)))
+svuint64_t svldff1uw_gather_index_u64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64index_s64)))
+svint64_t svldff1uw_gather_index_s64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64index_u64)))
+svuint64_t svldff1uw_gather_index_u64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64index_s64)))
+svint64_t svldff1uw_gather_index_s64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64offset_u64)))
+svuint64_t svldff1uw_gather_offset_u64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64offset_s64)))
+svint64_t svldff1uw_gather_offset_s64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64offset_u64)))
+svuint64_t svldff1uw_gather_offset_u64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64offset_s64)))
+svint64_t svldff1uw_gather_offset_s64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u8)))
+svuint8_t svldnf1(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u32)))
+svuint32_t svldnf1(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u64)))
+svuint64_t svldnf1(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u16)))
+svuint16_t svldnf1(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s8)))
+svint8_t svldnf1(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_f64)))
+svfloat64_t svldnf1(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_f32)))
+svfloat32_t svldnf1(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_f16)))
+svfloat16_t svldnf1(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s32)))
+svint32_t svldnf1(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s64)))
+svint64_t svldnf1(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s16)))
+svint16_t svldnf1(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u8)))
+svuint8_t svldnf1_vnum(svbool_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u32)))
+svuint32_t svldnf1_vnum(svbool_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u64)))
+svuint64_t svldnf1_vnum(svbool_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u16)))
+svuint16_t svldnf1_vnum(svbool_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s8)))
+svint8_t svldnf1_vnum(svbool_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_f64)))
+svfloat64_t svldnf1_vnum(svbool_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_f32)))
+svfloat32_t svldnf1_vnum(svbool_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_f16)))
+svfloat16_t svldnf1_vnum(svbool_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s32)))
+svint32_t svldnf1_vnum(svbool_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s64)))
+svint64_t svldnf1_vnum(svbool_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s16)))
+svint16_t svldnf1_vnum(svbool_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u32base)))
+void svprfb_gather(svbool_t, svuint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u64base)))
+void svprfb_gather(svbool_t, svuint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u32base_offset)))
+void svprfb_gather_offset(svbool_t, svuint32_t, int64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u64base_offset)))
+void svprfb_gather_offset(svbool_t, svuint64_t, int64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_s32offset)))
+void svprfb_gather_offset(svbool_t, void const *, svint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u32offset)))
+void svprfb_gather_offset(svbool_t, void const *, svuint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_s64offset)))
+void svprfb_gather_offset(svbool_t, void const *, svint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u64offset)))
+void svprfb_gather_offset(svbool_t, void const *, svuint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u32base)))
+void svprfd_gather(svbool_t, svuint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u64base)))
+void svprfd_gather(svbool_t, svuint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u32base_index)))
+void svprfd_gather_index(svbool_t, svuint32_t, int64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u64base_index)))
+void svprfd_gather_index(svbool_t, svuint64_t, int64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_s32index)))
+void svprfd_gather_index(svbool_t, void const *, svint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u32index)))
+void svprfd_gather_index(svbool_t, void const *, svuint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_s64index)))
+void svprfd_gather_index(svbool_t, void const *, svint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u64index)))
+void svprfd_gather_index(svbool_t, void const *, svuint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u32base)))
+void svprfh_gather(svbool_t, svuint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u64base)))
+void svprfh_gather(svbool_t, svuint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u32base_index)))
+void svprfh_gather_index(svbool_t, svuint32_t, int64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u64base_index)))
+void svprfh_gather_index(svbool_t, svuint64_t, int64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_s32index)))
+void svprfh_gather_index(svbool_t, void const *, svint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u32index)))
+void svprfh_gather_index(svbool_t, void const *, svuint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_s64index)))
+void svprfh_gather_index(svbool_t, void const *, svint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u64index)))
+void svprfh_gather_index(svbool_t, void const *, svuint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u32base)))
+void svprfw_gather(svbool_t, svuint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u64base)))
+void svprfw_gather(svbool_t, svuint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u32base_index)))
+void svprfw_gather_index(svbool_t, svuint32_t, int64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u64base_index)))
+void svprfw_gather_index(svbool_t, svuint64_t, int64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_s32index)))
+void svprfw_gather_index(svbool_t, void const *, svint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u32index)))
+void svprfw_gather_index(svbool_t, void const *, svuint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_s64index)))
+void svprfw_gather_index(svbool_t, void const *, svint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u64index)))
+void svprfw_gather_index(svbool_t, void const *, svuint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_index_u32)))
+void svst1_scatter_index(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_index_u64)))
+void svst1_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_index_f64)))
+void svst1_scatter_index(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_index_f32)))
+void svst1_scatter_index(svbool_t, svuint32_t, int64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_index_s32)))
+void svst1_scatter_index(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_index_s64)))
+void svst1_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_offset_u32)))
+void svst1_scatter_offset(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_offset_u64)))
+void svst1_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_offset_f64)))
+void svst1_scatter_offset(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_offset_f32)))
+void svst1_scatter_offset(svbool_t, svuint32_t, int64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_offset_s32)))
+void svst1_scatter_offset(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_offset_s64)))
+void svst1_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_u32)))
+void svst1_scatter(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_u64)))
+void svst1_scatter(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_f64)))
+void svst1_scatter(svbool_t, svuint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_f32)))
+void svst1_scatter(svbool_t, svuint32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_s32)))
+void svst1_scatter(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_s64)))
+void svst1_scatter(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32index_u32)))
+void svst1_scatter_index(svbool_t, uint32_t *, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32index_f32)))
+void svst1_scatter_index(svbool_t, float32_t *, svint32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32index_s32)))
+void svst1_scatter_index(svbool_t, int32_t *, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32index_u32)))
+void svst1_scatter_index(svbool_t, uint32_t *, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32index_f32)))
+void svst1_scatter_index(svbool_t, float32_t *, svuint32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32index_s32)))
+void svst1_scatter_index(svbool_t, int32_t *, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64index_u64)))
+void svst1_scatter_index(svbool_t, uint64_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64index_f64)))
+void svst1_scatter_index(svbool_t, float64_t *, svint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64index_s64)))
+void svst1_scatter_index(svbool_t, int64_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64index_u64)))
+void svst1_scatter_index(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64index_f64)))
+void svst1_scatter_index(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64index_s64)))
+void svst1_scatter_index(svbool_t, int64_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32offset_u32)))
+void svst1_scatter_offset(svbool_t, uint32_t *, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32offset_f32)))
+void svst1_scatter_offset(svbool_t, float32_t *, svint32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32offset_s32)))
+void svst1_scatter_offset(svbool_t, int32_t *, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32offset_u32)))
+void svst1_scatter_offset(svbool_t, uint32_t *, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32offset_f32)))
+void svst1_scatter_offset(svbool_t, float32_t *, svuint32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32offset_s32)))
+void svst1_scatter_offset(svbool_t, int32_t *, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64offset_u64)))
+void svst1_scatter_offset(svbool_t, uint64_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64offset_f64)))
+void svst1_scatter_offset(svbool_t, float64_t *, svint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64offset_s64)))
+void svst1_scatter_offset(svbool_t, int64_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64offset_u64)))
+void svst1_scatter_offset(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64offset_f64)))
+void svst1_scatter_offset(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64offset_s64)))
+void svst1_scatter_offset(svbool_t, int64_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_offset_u32)))
+void svst1b_scatter_offset(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_offset_u64)))
+void svst1b_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_offset_s32)))
+void svst1b_scatter_offset(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_offset_s64)))
+void svst1b_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_u32)))
+void svst1b_scatter(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_u64)))
+void svst1b_scatter(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_s32)))
+void svst1b_scatter(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_s64)))
+void svst1b_scatter(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s32offset_s32)))
+void svst1b_scatter_offset(svbool_t, int8_t *, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s32offset_u32)))
+void svst1b_scatter_offset(svbool_t, uint8_t *, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32offset_s32)))
+void svst1b_scatter_offset(svbool_t, int8_t *, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32offset_u32)))
+void svst1b_scatter_offset(svbool_t, uint8_t *, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s64offset_s64)))
+void svst1b_scatter_offset(svbool_t, int8_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s64offset_u64)))
+void svst1b_scatter_offset(svbool_t, uint8_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64offset_s64)))
+void svst1b_scatter_offset(svbool_t, int8_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64offset_u64)))
+void svst1b_scatter_offset(svbool_t, uint8_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_index_u32)))
+void svst1h_scatter_index(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_index_u64)))
+void svst1h_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_index_s32)))
+void svst1h_scatter_index(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_index_s64)))
+void svst1h_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_offset_u32)))
+void svst1h_scatter_offset(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_offset_u64)))
+void svst1h_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_offset_s32)))
+void svst1h_scatter_offset(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_offset_s64)))
+void svst1h_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_u32)))
+void svst1h_scatter(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_u64)))
+void svst1h_scatter(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_s32)))
+void svst1h_scatter(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_s64)))
+void svst1h_scatter(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32index_s32)))
+void svst1h_scatter_index(svbool_t, int16_t *, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32index_u32)))
+void svst1h_scatter_index(svbool_t, uint16_t *, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32index_s32)))
+void svst1h_scatter_index(svbool_t, int16_t *, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32index_u32)))
+void svst1h_scatter_index(svbool_t, uint16_t *, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64index_s64)))
+void svst1h_scatter_index(svbool_t, int16_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64index_u64)))
+void svst1h_scatter_index(svbool_t, uint16_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64index_s64)))
+void svst1h_scatter_index(svbool_t, int16_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64index_u64)))
+void svst1h_scatter_index(svbool_t, uint16_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32offset_s32)))
+void svst1h_scatter_offset(svbool_t, int16_t *, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32offset_u32)))
+void svst1h_scatter_offset(svbool_t, uint16_t *, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32offset_s32)))
+void svst1h_scatter_offset(svbool_t, int16_t *, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32offset_u32)))
+void svst1h_scatter_offset(svbool_t, uint16_t *, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64offset_s64)))
+void svst1h_scatter_offset(svbool_t, int16_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64offset_u64)))
+void svst1h_scatter_offset(svbool_t, uint16_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64offset_s64)))
+void svst1h_scatter_offset(svbool_t, int16_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64offset_u64)))
+void svst1h_scatter_offset(svbool_t, uint16_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_index_u64)))
+void svst1w_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_index_s64)))
+void svst1w_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_offset_u64)))
+void svst1w_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_offset_s64)))
+void svst1w_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_u64)))
+void svst1w_scatter(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_s64)))
+void svst1w_scatter(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64index_s64)))
+void svst1w_scatter_index(svbool_t, int32_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64index_u64)))
+void svst1w_scatter_index(svbool_t, uint32_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64index_s64)))
+void svst1w_scatter_index(svbool_t, int32_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64index_u64)))
+void svst1w_scatter_index(svbool_t, uint32_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64offset_s64)))
+void svst1w_scatter_offset(svbool_t, int32_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64offset_u64)))
+void svst1w_scatter_offset(svbool_t, uint32_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64offset_s64)))
+void svst1w_scatter_offset(svbool_t, int32_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64offset_u64)))
+void svst1w_scatter_offset(svbool_t, uint32_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtmad_f64)))
+svfloat64_t svtmad(svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtmad_f32)))
+svfloat32_t svtmad(svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtmad_f16)))
+svfloat16_t svtmad(svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtsmul_f64)))
+svfloat64_t svtsmul(svfloat64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtsmul_f32)))
+svfloat32_t svtsmul(svfloat32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtsmul_f16)))
+svfloat16_t svtsmul(svfloat16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtssel_f64)))
+svfloat64_t svtssel(svfloat64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtssel_f32)))
+svfloat32_t svtssel(svfloat32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtssel_f16)))
+svfloat16_t svtssel(svfloat16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmmla_f32)))
+svfloat32_t svbfmmla_f32(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_bf16)))
+svbfloat16_t svldff1_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_bf16)))
+svbfloat16_t svldff1_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_bf16)))
+svbfloat16_t svldnf1_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_bf16)))
+svbfloat16_t svldnf1_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmmla_f32)))
+svfloat32_t svbfmmla(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_bf16)))
+svbfloat16_t svldff1(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_bf16)))
+svbfloat16_t svldff1_vnum(svbool_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_bf16)))
+svbfloat16_t svldnf1(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_bf16)))
+svbfloat16_t svldnf1_vnum(svbool_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_bf16)))
+svbfloat16_t svtrn1q_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_bf16)))
+svbfloat16_t svtrn2q_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_bf16)))
+svbfloat16_t svuzp1q_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_bf16)))
+svbfloat16_t svuzp2q_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_bf16)))
+svbfloat16_t svzip1q_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_bf16)))
+svbfloat16_t svzip2q_bf16(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_bf16)))
+svbfloat16_t svtrn1q(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_bf16)))
+svbfloat16_t svtrn2q(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_bf16)))
+svbfloat16_t svuzp1q(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_bf16)))
+svbfloat16_t svuzp2q(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_bf16)))
+svbfloat16_t svzip1q(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_bf16)))
+svbfloat16_t svzip2q(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfdot_n_f32)))
+svfloat32_t svbfdot_n_f32(svfloat32_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfdot_f32)))
+svfloat32_t svbfdot_f32(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfdot_lane_f32)))
+svfloat32_t svbfdot_lane_f32(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalb_n_f32)))
+svfloat32_t svbfmlalb_n_f32(svfloat32_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalb_f32)))
+svfloat32_t svbfmlalb_f32(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalb_lane_f32)))
+svfloat32_t svbfmlalb_lane_f32(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalt_n_f32)))
+svfloat32_t svbfmlalt_n_f32(svfloat32_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalt_f32)))
+svfloat32_t svbfmlalt_f32(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalt_lane_f32)))
+svfloat32_t svbfmlalt_lane_f32(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_bf16)))
+bfloat16_t svclasta_n_bf16(svbool_t, bfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_bf16)))
+svbfloat16_t svclasta_bf16(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_bf16)))
+bfloat16_t svclastb_n_bf16(svbool_t, bfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_bf16)))
+svbfloat16_t svclastb_bf16(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_bf16_m)))
+svuint16_t svcnt_bf16_m(svuint16_t, svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_bf16_x)))
+svuint16_t svcnt_bf16_x(svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_bf16_z)))
+svuint16_t svcnt_bf16_z(svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_bf16)))
+svbfloat16x2_t svcreate2_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_bf16)))
+svbfloat16x3_t svcreate3_bf16(svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_bf16)))
+svbfloat16x4_t svcreate4_bf16(svbfloat16_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_m)))
+svbfloat16_t svcvt_bf16_f32_m(svbfloat16_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_x)))
+svbfloat16_t svcvt_bf16_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_z)))
+svbfloat16_t svcvt_bf16_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtnt_bf16_f32_m)))
+svbfloat16_t svcvtnt_bf16_f32_m(svbfloat16_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16)))
+svbfloat16_t svdup_n_bf16(bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16_m)))
+svbfloat16_t svdup_n_bf16_m(svbfloat16_t, svbool_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16_x)))
+svbfloat16_t svdup_n_bf16_x(svbool_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16_z)))
+svbfloat16_t svdup_n_bf16_z(svbool_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_bf16)))
+svbfloat16_t svdup_lane_bf16(svbfloat16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_bf16)))
+svbfloat16_t svdupq_n_bf16(bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_bf16)))
+svbfloat16_t svdupq_lane_bf16(svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_bf16)))
+svbfloat16_t svext_bf16(svbfloat16_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_bf16)))
+svbfloat16_t svget2_bf16(svbfloat16x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_bf16)))
+svbfloat16_t svget3_bf16(svbfloat16x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_bf16)))
+svbfloat16_t svget4_bf16(svbfloat16x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_bf16)))
+svbfloat16_t svinsr_n_bf16(svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_bf16)))
+bfloat16_t svlasta_bf16(svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_bf16)))
+bfloat16_t svlastb_bf16(svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_bf16)))
+svbfloat16_t svld1_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_bf16)))
+svbfloat16_t svld1_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_bf16)))
+svbfloat16_t svld1rq_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_bf16)))
+svbfloat16x2_t svld2_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_bf16)))
+svbfloat16x2_t svld2_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_bf16)))
+svbfloat16x3_t svld3_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_bf16)))
+svbfloat16x3_t svld3_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_bf16)))
+svbfloat16x4_t svld4_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_bf16)))
+svbfloat16x4_t svld4_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_bf16)))
+svbfloat16_t svldnt1_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_bf16)))
+svbfloat16_t svldnt1_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_bf16)))
+uint64_t svlen_bf16(svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_bf16)))
+svbfloat16_t svrev_bf16(svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_bf16)))
+svbfloat16_t svsel_bf16(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_bf16)))
+svbfloat16x2_t svset2_bf16(svbfloat16x2_t, uint64_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_bf16)))
+svbfloat16x3_t svset3_bf16(svbfloat16x3_t, uint64_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_bf16)))
+svbfloat16x4_t svset4_bf16(svbfloat16x4_t, uint64_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_bf16)))
+svbfloat16_t svsplice_bf16(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_bf16)))
+void svst1_bf16(svbool_t, bfloat16_t *, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_bf16)))
+void svst1_vnum_bf16(svbool_t, bfloat16_t *, int64_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_bf16)))
+void svst2_bf16(svbool_t, bfloat16_t *, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_bf16)))
+void svst2_vnum_bf16(svbool_t, bfloat16_t *, int64_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_bf16)))
+void svst3_bf16(svbool_t, bfloat16_t *, svbfloat16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_bf16)))
+void svst3_vnum_bf16(svbool_t, bfloat16_t *, int64_t, svbfloat16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_bf16)))
+void svst4_bf16(svbool_t, bfloat16_t *, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_bf16)))
+void svst4_vnum_bf16(svbool_t, bfloat16_t *, int64_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_bf16)))
+void svstnt1_bf16(svbool_t, bfloat16_t *, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_bf16)))
+void svstnt1_vnum_bf16(svbool_t, bfloat16_t *, int64_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_bf16)))
+svbfloat16_t svtbl_bf16(svbfloat16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_bf16)))
+svbfloat16_t svtrn1_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_bf16)))
+svbfloat16_t svtrn2_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_bf16)))
+svbfloat16x2_t svundef2_bf16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_bf16)))
+svbfloat16x3_t svundef3_bf16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_bf16)))
+svbfloat16x4_t svundef4_bf16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_bf16)))
+svbfloat16_t svundef_bf16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_bf16)))
+svbfloat16_t svuzp1_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_bf16)))
+svbfloat16_t svuzp2_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_bf16)))
+svbfloat16_t svzip1_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_bf16)))
+svbfloat16_t svzip2_bf16(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfdot_n_f32)))
+svfloat32_t svbfdot(svfloat32_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfdot_f32)))
+svfloat32_t svbfdot(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfdot_lane_f32)))
+svfloat32_t svbfdot_lane(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalb_n_f32)))
+svfloat32_t svbfmlalb(svfloat32_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalb_f32)))
+svfloat32_t svbfmlalb(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalb_lane_f32)))
+svfloat32_t svbfmlalb_lane(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalt_n_f32)))
+svfloat32_t svbfmlalt(svfloat32_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalt_f32)))
+svfloat32_t svbfmlalt(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalt_lane_f32)))
+svfloat32_t svbfmlalt_lane(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_bf16)))
+bfloat16_t svclasta(svbool_t, bfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_bf16)))
+svbfloat16_t svclasta(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_bf16)))
+bfloat16_t svclastb(svbool_t, bfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_bf16)))
+svbfloat16_t svclastb(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_bf16_m)))
+svuint16_t svcnt_m(svuint16_t, svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_bf16_x)))
+svuint16_t svcnt_x(svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_bf16_z)))
+svuint16_t svcnt_z(svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_bf16)))
+svbfloat16x2_t svcreate2(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_bf16)))
+svbfloat16x3_t svcreate3(svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_bf16)))
+svbfloat16x4_t svcreate4(svbfloat16_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_m)))
+svbfloat16_t svcvt_bf16_m(svbfloat16_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_x)))
+svbfloat16_t svcvt_bf16_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_z)))
+svbfloat16_t svcvt_bf16_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtnt_bf16_f32_m)))
+svbfloat16_t svcvtnt_bf16_m(svbfloat16_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16)))
+svbfloat16_t svdup_bf16(bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16_m)))
+svbfloat16_t svdup_bf16_m(svbfloat16_t, svbool_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16_x)))
+svbfloat16_t svdup_bf16_x(svbool_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16_z)))
+svbfloat16_t svdup_bf16_z(svbool_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_bf16)))
+svbfloat16_t svdup_lane(svbfloat16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_bf16)))
+svbfloat16_t svdupq_bf16(bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_bf16)))
+svbfloat16_t svdupq_lane(svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_bf16)))
+svbfloat16_t svext(svbfloat16_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_bf16)))
+svbfloat16_t svget2(svbfloat16x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_bf16)))
+svbfloat16_t svget3(svbfloat16x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_bf16)))
+svbfloat16_t svget4(svbfloat16x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_bf16)))
+svbfloat16_t svinsr(svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_bf16)))
+bfloat16_t svlasta(svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_bf16)))
+bfloat16_t svlastb(svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_bf16)))
+svbfloat16_t svld1(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_bf16)))
+svbfloat16_t svld1_vnum(svbool_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_bf16)))
+svbfloat16_t svld1rq(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_bf16)))
+svbfloat16x2_t svld2(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_bf16)))
+svbfloat16x2_t svld2_vnum(svbool_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_bf16)))
+svbfloat16x3_t svld3(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_bf16)))
+svbfloat16x3_t svld3_vnum(svbool_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_bf16)))
+svbfloat16x4_t svld4(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_bf16)))
+svbfloat16x4_t svld4_vnum(svbool_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_bf16)))
+svbfloat16_t svldnt1(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_bf16)))
+svbfloat16_t svldnt1_vnum(svbool_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_bf16)))
+uint64_t svlen(svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_bf16)))
+svbfloat16_t svrev(svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_bf16)))
+svbfloat16_t svsel(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_bf16)))
+svbfloat16x2_t svset2(svbfloat16x2_t, uint64_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_bf16)))
+svbfloat16x3_t svset3(svbfloat16x3_t, uint64_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_bf16)))
+svbfloat16x4_t svset4(svbfloat16x4_t, uint64_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_bf16)))
+svbfloat16_t svsplice(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_bf16)))
+void svst1(svbool_t, bfloat16_t *, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_bf16)))
+void svst1_vnum(svbool_t, bfloat16_t *, int64_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_bf16)))
+void svst2(svbool_t, bfloat16_t *, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_bf16)))
+void svst2_vnum(svbool_t, bfloat16_t *, int64_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_bf16)))
+void svst3(svbool_t, bfloat16_t *, svbfloat16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_bf16)))
+void svst3_vnum(svbool_t, bfloat16_t *, int64_t, svbfloat16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_bf16)))
+void svst4(svbool_t, bfloat16_t *, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_bf16)))
+void svst4_vnum(svbool_t, bfloat16_t *, int64_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_bf16)))
+void svstnt1(svbool_t, bfloat16_t *, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_bf16)))
+void svstnt1_vnum(svbool_t, bfloat16_t *, int64_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_bf16)))
+svbfloat16_t svtbl(svbfloat16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_bf16)))
+svbfloat16_t svtrn1(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_bf16)))
+svbfloat16_t svtrn2(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_bf16)))
+svbfloat16_t svuzp1(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_bf16)))
+svbfloat16_t svuzp2(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_bf16)))
+svbfloat16_t svzip1(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_bf16)))
+svbfloat16_t svzip2(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_f32)))
+svfloat32_t svmmla_f32(svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_f32)))
+svfloat32_t svmmla(svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u8)))
+svuint8_t svld1ro_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u32)))
+svuint32_t svld1ro_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u64)))
+svuint64_t svld1ro_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u16)))
+svuint16_t svld1ro_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s8)))
+svint8_t svld1ro_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_f64)))
+svfloat64_t svld1ro_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_f32)))
+svfloat32_t svld1ro_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_f16)))
+svfloat16_t svld1ro_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s32)))
+svint32_t svld1ro_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s64)))
+svint64_t svld1ro_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s16)))
+svint16_t svld1ro_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_f64)))
+svfloat64_t svmmla_f64(svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u8)))
+svuint8_t svtrn1q_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u32)))
+svuint32_t svtrn1q_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u64)))
+svuint64_t svtrn1q_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u16)))
+svuint16_t svtrn1q_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s8)))
+svint8_t svtrn1q_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_f64)))
+svfloat64_t svtrn1q_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_f32)))
+svfloat32_t svtrn1q_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_f16)))
+svfloat16_t svtrn1q_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s32)))
+svint32_t svtrn1q_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s64)))
+svint64_t svtrn1q_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s16)))
+svint16_t svtrn1q_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u8)))
+svuint8_t svtrn2q_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u32)))
+svuint32_t svtrn2q_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u64)))
+svuint64_t svtrn2q_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u16)))
+svuint16_t svtrn2q_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s8)))
+svint8_t svtrn2q_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_f64)))
+svfloat64_t svtrn2q_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_f32)))
+svfloat32_t svtrn2q_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_f16)))
+svfloat16_t svtrn2q_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s32)))
+svint32_t svtrn2q_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s64)))
+svint64_t svtrn2q_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s16)))
+svint16_t svtrn2q_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u8)))
+svuint8_t svuzp1q_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u32)))
+svuint32_t svuzp1q_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u64)))
+svuint64_t svuzp1q_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u16)))
+svuint16_t svuzp1q_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s8)))
+svint8_t svuzp1q_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_f64)))
+svfloat64_t svuzp1q_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_f32)))
+svfloat32_t svuzp1q_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_f16)))
+svfloat16_t svuzp1q_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s32)))
+svint32_t svuzp1q_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s64)))
+svint64_t svuzp1q_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s16)))
+svint16_t svuzp1q_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u8)))
+svuint8_t svuzp2q_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u32)))
+svuint32_t svuzp2q_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u64)))
+svuint64_t svuzp2q_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u16)))
+svuint16_t svuzp2q_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s8)))
+svint8_t svuzp2q_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_f64)))
+svfloat64_t svuzp2q_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_f32)))
+svfloat32_t svuzp2q_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_f16)))
+svfloat16_t svuzp2q_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s32)))
+svint32_t svuzp2q_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s64)))
+svint64_t svuzp2q_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s16)))
+svint16_t svuzp2q_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u8)))
+svuint8_t svzip1q_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u32)))
+svuint32_t svzip1q_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u64)))
+svuint64_t svzip1q_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u16)))
+svuint16_t svzip1q_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s8)))
+svint8_t svzip1q_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_f64)))
+svfloat64_t svzip1q_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_f32)))
+svfloat32_t svzip1q_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_f16)))
+svfloat16_t svzip1q_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s32)))
+svint32_t svzip1q_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s64)))
+svint64_t svzip1q_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s16)))
+svint16_t svzip1q_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u8)))
+svuint8_t svzip2q_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u32)))
+svuint32_t svzip2q_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u64)))
+svuint64_t svzip2q_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u16)))
+svuint16_t svzip2q_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s8)))
+svint8_t svzip2q_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_f64)))
+svfloat64_t svzip2q_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_f32)))
+svfloat32_t svzip2q_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_f16)))
+svfloat16_t svzip2q_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s32)))
+svint32_t svzip2q_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s64)))
+svint64_t svzip2q_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s16)))
+svint16_t svzip2q_s16(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u8)))
+svuint8_t svld1ro(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u32)))
+svuint32_t svld1ro(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u64)))
+svuint64_t svld1ro(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u16)))
+svuint16_t svld1ro(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s8)))
+svint8_t svld1ro(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_f64)))
+svfloat64_t svld1ro(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_f32)))
+svfloat32_t svld1ro(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_f16)))
+svfloat16_t svld1ro(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s32)))
+svint32_t svld1ro(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s64)))
+svint64_t svld1ro(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s16)))
+svint16_t svld1ro(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_f64)))
+svfloat64_t svmmla(svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u8)))
+svuint8_t svtrn1q(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u32)))
+svuint32_t svtrn1q(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u64)))
+svuint64_t svtrn1q(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u16)))
+svuint16_t svtrn1q(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s8)))
+svint8_t svtrn1q(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_f64)))
+svfloat64_t svtrn1q(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_f32)))
+svfloat32_t svtrn1q(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_f16)))
+svfloat16_t svtrn1q(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s32)))
+svint32_t svtrn1q(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s64)))
+svint64_t svtrn1q(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s16)))
+svint16_t svtrn1q(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u8)))
+svuint8_t svtrn2q(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u32)))
+svuint32_t svtrn2q(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u64)))
+svuint64_t svtrn2q(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u16)))
+svuint16_t svtrn2q(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s8)))
+svint8_t svtrn2q(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_f64)))
+svfloat64_t svtrn2q(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_f32)))
+svfloat32_t svtrn2q(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_f16)))
+svfloat16_t svtrn2q(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s32)))
+svint32_t svtrn2q(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s64)))
+svint64_t svtrn2q(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s16)))
+svint16_t svtrn2q(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u8)))
+svuint8_t svuzp1q(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u32)))
+svuint32_t svuzp1q(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u64)))
+svuint64_t svuzp1q(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u16)))
+svuint16_t svuzp1q(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s8)))
+svint8_t svuzp1q(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_f64)))
+svfloat64_t svuzp1q(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_f32)))
+svfloat32_t svuzp1q(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_f16)))
+svfloat16_t svuzp1q(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s32)))
+svint32_t svuzp1q(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s64)))
+svint64_t svuzp1q(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s16)))
+svint16_t svuzp1q(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u8)))
+svuint8_t svuzp2q(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u32)))
+svuint32_t svuzp2q(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u64)))
+svuint64_t svuzp2q(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u16)))
+svuint16_t svuzp2q(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s8)))
+svint8_t svuzp2q(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_f64)))
+svfloat64_t svuzp2q(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_f32)))
+svfloat32_t svuzp2q(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_f16)))
+svfloat16_t svuzp2q(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s32)))
+svint32_t svuzp2q(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s64)))
+svint64_t svuzp2q(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s16)))
+svint16_t svuzp2q(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u8)))
+svuint8_t svzip1q(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u32)))
+svuint32_t svzip1q(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u64)))
+svuint64_t svzip1q(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u16)))
+svuint16_t svzip1q(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s8)))
+svint8_t svzip1q(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_f64)))
+svfloat64_t svzip1q(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_f32)))
+svfloat32_t svzip1q(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_f16)))
+svfloat16_t svzip1q(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s32)))
+svint32_t svzip1q(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s64)))
+svint64_t svzip1q(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s16)))
+svint16_t svzip1q(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u8)))
+svuint8_t svzip2q(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u32)))
+svuint32_t svzip2q(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u64)))
+svuint64_t svzip2q(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u16)))
+svuint16_t svzip2q(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s8)))
+svint8_t svzip2q(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_f64)))
+svfloat64_t svzip2q(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_f32)))
+svfloat32_t svzip2q(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_f16)))
+svfloat16_t svzip2q(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s32)))
+svint32_t svzip2q(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s64)))
+svint64_t svzip2q(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s16)))
+svint16_t svzip2q(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_bf16)))
+svbfloat16_t svld1ro_bf16(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_bf16)))
+svbfloat16_t svld1ro(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_s32)))
+svint32_t svmmla_s32(svint32_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_u32)))
+svuint32_t svmmla_u32(svuint32_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusmmla_s32)))
+svint32_t svusmmla_s32(svint32_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_s32)))
+svint32_t svmmla(svint32_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_u32)))
+svuint32_t svmmla(svuint32_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusmmla_s32)))
+svint32_t svusmmla(svint32_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsudot_n_s32)))
+svint32_t svsudot_n_s32(svint32_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsudot_s32)))
+svint32_t svsudot_s32(svint32_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsudot_lane_s32)))
+svint32_t svsudot_lane_s32(svint32_t, svint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusdot_n_s32)))
+svint32_t svusdot_n_s32(svint32_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusdot_s32)))
+svint32_t svusdot_s32(svint32_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusdot_lane_s32)))
+svint32_t svusdot_lane_s32(svint32_t, svuint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsudot_n_s32)))
+svint32_t svsudot(svint32_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsudot_s32)))
+svint32_t svsudot(svint32_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsudot_lane_s32)))
+svint32_t svsudot_lane(svint32_t, svint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusdot_n_s32)))
+svint32_t svusdot(svint32_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusdot_s32)))
+svint32_t svusdot(svint32_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusdot_lane_s32)))
+svint32_t svusdot_lane(svint32_t, svuint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_u32_z)))
+svuint32_t svhistcnt_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_u64_z)))
+svuint64_t svhistcnt_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_s32_z)))
+svuint32_t svhistcnt_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_s64_z)))
+svuint64_t svhistcnt_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistseg_u8)))
+svuint8_t svhistseg_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistseg_s8)))
+svuint8_t svhistseg_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_index_u32)))
+svuint32_t svldnt1_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_index_u64)))
+svuint64_t svldnt1_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_index_f64)))
+svfloat64_t svldnt1_gather_u64base_index_f64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_index_f32)))
+svfloat32_t svldnt1_gather_u32base_index_f32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_index_s32)))
+svint32_t svldnt1_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_index_s64)))
+svint64_t svldnt1_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_offset_u32)))
+svuint32_t svldnt1_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_offset_u64)))
+svuint64_t svldnt1_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_offset_f64)))
+svfloat64_t svldnt1_gather_u64base_offset_f64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_offset_f32)))
+svfloat32_t svldnt1_gather_u32base_offset_f32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_offset_s32)))
+svint32_t svldnt1_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_offset_s64)))
+svint64_t svldnt1_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_u32)))
+svuint32_t svldnt1_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_u64)))
+svuint64_t svldnt1_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_f64)))
+svfloat64_t svldnt1_gather_u64base_f64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_f32)))
+svfloat32_t svldnt1_gather_u32base_f32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_s32)))
+svint32_t svldnt1_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_s64)))
+svint64_t svldnt1_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64index_u64)))
+svuint64_t svldnt1_gather_s64index_u64(svbool_t, uint64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64index_f64)))
+svfloat64_t svldnt1_gather_s64index_f64(svbool_t, float64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64index_s64)))
+svint64_t svldnt1_gather_s64index_s64(svbool_t, int64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64index_u64)))
+svuint64_t svldnt1_gather_u64index_u64(svbool_t, uint64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64index_f64)))
+svfloat64_t svldnt1_gather_u64index_f64(svbool_t, float64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64index_s64)))
+svint64_t svldnt1_gather_u64index_s64(svbool_t, int64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32offset_u32)))
+svuint32_t svldnt1_gather_u32offset_u32(svbool_t, uint32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32offset_f32)))
+svfloat32_t svldnt1_gather_u32offset_f32(svbool_t, float32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32offset_s32)))
+svint32_t svldnt1_gather_u32offset_s32(svbool_t, int32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64offset_u64)))
+svuint64_t svldnt1_gather_s64offset_u64(svbool_t, uint64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64offset_f64)))
+svfloat64_t svldnt1_gather_s64offset_f64(svbool_t, float64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64offset_s64)))
+svint64_t svldnt1_gather_s64offset_s64(svbool_t, int64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64offset_u64)))
+svuint64_t svldnt1_gather_u64offset_u64(svbool_t, uint64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64offset_f64)))
+svfloat64_t svldnt1_gather_u64offset_f64(svbool_t, float64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64offset_s64)))
+svint64_t svldnt1_gather_u64offset_s64(svbool_t, int64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_offset_u32)))
+svuint32_t svldnt1sb_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_offset_u64)))
+svuint64_t svldnt1sb_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_offset_s32)))
+svint32_t svldnt1sb_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_offset_s64)))
+svint64_t svldnt1sb_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_u32)))
+svuint32_t svldnt1sb_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_u64)))
+svuint64_t svldnt1sb_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_s32)))
+svint32_t svldnt1sb_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_s64)))
+svint64_t svldnt1sb_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32offset_u32)))
+svuint32_t svldnt1sb_gather_u32offset_u32(svbool_t, int8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32offset_s32)))
+svint32_t svldnt1sb_gather_u32offset_s32(svbool_t, int8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_s64offset_u64)))
+svuint64_t svldnt1sb_gather_s64offset_u64(svbool_t, int8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_s64offset_s64)))
+svint64_t svldnt1sb_gather_s64offset_s64(svbool_t, int8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64offset_u64)))
+svuint64_t svldnt1sb_gather_u64offset_u64(svbool_t, int8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64offset_s64)))
+svint64_t svldnt1sb_gather_u64offset_s64(svbool_t, int8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_index_u32)))
+svuint32_t svldnt1sh_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_index_u64)))
+svuint64_t svldnt1sh_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_index_s32)))
+svint32_t svldnt1sh_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_index_s64)))
+svint64_t svldnt1sh_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_offset_u32)))
+svuint32_t svldnt1sh_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_offset_u64)))
+svuint64_t svldnt1sh_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_offset_s32)))
+svint32_t svldnt1sh_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_offset_s64)))
+svint64_t svldnt1sh_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_u32)))
+svuint32_t svldnt1sh_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_u64)))
+svuint64_t svldnt1sh_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_s32)))
+svint32_t svldnt1sh_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_s64)))
+svint64_t svldnt1sh_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64index_u64)))
+svuint64_t svldnt1sh_gather_s64index_u64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64index_s64)))
+svint64_t svldnt1sh_gather_s64index_s64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64index_u64)))
+svuint64_t svldnt1sh_gather_u64index_u64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64index_s64)))
+svint64_t svldnt1sh_gather_u64index_s64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32offset_u32)))
+svuint32_t svldnt1sh_gather_u32offset_u32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32offset_s32)))
+svint32_t svldnt1sh_gather_u32offset_s32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64offset_u64)))
+svuint64_t svldnt1sh_gather_s64offset_u64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64offset_s64)))
+svint64_t svldnt1sh_gather_s64offset_s64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64offset_u64)))
+svuint64_t svldnt1sh_gather_u64offset_u64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64offset_s64)))
+svint64_t svldnt1sh_gather_u64offset_s64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_index_u64)))
+svuint64_t svldnt1sw_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_index_s64)))
+svint64_t svldnt1sw_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_offset_u64)))
+svuint64_t svldnt1sw_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_offset_s64)))
+svint64_t svldnt1sw_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_u64)))
+svuint64_t svldnt1sw_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_s64)))
+svint64_t svldnt1sw_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64index_u64)))
+svuint64_t svldnt1sw_gather_s64index_u64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64index_s64)))
+svint64_t svldnt1sw_gather_s64index_s64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64index_u64)))
+svuint64_t svldnt1sw_gather_u64index_u64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64index_s64)))
+svint64_t svldnt1sw_gather_u64index_s64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64offset_u64)))
+svuint64_t svldnt1sw_gather_s64offset_u64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64offset_s64)))
+svint64_t svldnt1sw_gather_s64offset_s64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64offset_u64)))
+svuint64_t svldnt1sw_gather_u64offset_u64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64offset_s64)))
+svint64_t svldnt1sw_gather_u64offset_s64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_offset_u32)))
+svuint32_t svldnt1ub_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_offset_u64)))
+svuint64_t svldnt1ub_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_offset_s32)))
+svint32_t svldnt1ub_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_offset_s64)))
+svint64_t svldnt1ub_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_u32)))
+svuint32_t svldnt1ub_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_u64)))
+svuint64_t svldnt1ub_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_s32)))
+svint32_t svldnt1ub_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_s64)))
+svint64_t svldnt1ub_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32offset_u32)))
+svuint32_t svldnt1ub_gather_u32offset_u32(svbool_t, uint8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32offset_s32)))
+svint32_t svldnt1ub_gather_u32offset_s32(svbool_t, uint8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_s64offset_u64)))
+svuint64_t svldnt1ub_gather_s64offset_u64(svbool_t, uint8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_s64offset_s64)))
+svint64_t svldnt1ub_gather_s64offset_s64(svbool_t, uint8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64offset_u64)))
+svuint64_t svldnt1ub_gather_u64offset_u64(svbool_t, uint8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64offset_s64)))
+svint64_t svldnt1ub_gather_u64offset_s64(svbool_t, uint8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_index_u32)))
+svuint32_t svldnt1uh_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_index_u64)))
+svuint64_t svldnt1uh_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_index_s32)))
+svint32_t svldnt1uh_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_index_s64)))
+svint64_t svldnt1uh_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_offset_u32)))
+svuint32_t svldnt1uh_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_offset_u64)))
+svuint64_t svldnt1uh_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_offset_s32)))
+svint32_t svldnt1uh_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_offset_s64)))
+svint64_t svldnt1uh_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_u32)))
+svuint32_t svldnt1uh_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_u64)))
+svuint64_t svldnt1uh_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_s32)))
+svint32_t svldnt1uh_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_s64)))
+svint64_t svldnt1uh_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64index_u64)))
+svuint64_t svldnt1uh_gather_s64index_u64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64index_s64)))
+svint64_t svldnt1uh_gather_s64index_s64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64index_u64)))
+svuint64_t svldnt1uh_gather_u64index_u64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64index_s64)))
+svint64_t svldnt1uh_gather_u64index_s64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32offset_u32)))
+svuint32_t svldnt1uh_gather_u32offset_u32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32offset_s32)))
+svint32_t svldnt1uh_gather_u32offset_s32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64offset_u64)))
+svuint64_t svldnt1uh_gather_s64offset_u64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64offset_s64)))
+svint64_t svldnt1uh_gather_s64offset_s64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64offset_u64)))
+svuint64_t svldnt1uh_gather_u64offset_u64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64offset_s64)))
+svint64_t svldnt1uh_gather_u64offset_s64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_index_u64)))
+svuint64_t svldnt1uw_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_index_s64)))
+svint64_t svldnt1uw_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_offset_u64)))
+svuint64_t svldnt1uw_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_offset_s64)))
+svint64_t svldnt1uw_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_u64)))
+svuint64_t svldnt1uw_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_s64)))
+svint64_t svldnt1uw_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64index_u64)))
+svuint64_t svldnt1uw_gather_s64index_u64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64index_s64)))
+svint64_t svldnt1uw_gather_s64index_s64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64index_u64)))
+svuint64_t svldnt1uw_gather_u64index_u64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64index_s64)))
+svint64_t svldnt1uw_gather_u64index_s64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64offset_u64)))
+svuint64_t svldnt1uw_gather_s64offset_u64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64offset_s64)))
+svint64_t svldnt1uw_gather_s64offset_s64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64offset_u64)))
+svuint64_t svldnt1uw_gather_u64offset_u64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64offset_s64)))
+svint64_t svldnt1uw_gather_u64offset_s64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_u8)))
+svbool_t svmatch_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_u16)))
+svbool_t svmatch_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_s8)))
+svbool_t svmatch_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_s16)))
+svbool_t svmatch_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_u8)))
+svbool_t svnmatch_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_u16)))
+svbool_t svnmatch_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_s8)))
+svbool_t svnmatch_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_s16)))
+svbool_t svnmatch_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_index_u32)))
+void svstnt1_scatter_u32base_index_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_index_u64)))
+void svstnt1_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_index_f64)))
+void svstnt1_scatter_u64base_index_f64(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_index_f32)))
+void svstnt1_scatter_u32base_index_f32(svbool_t, svuint32_t, int64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_index_s32)))
+void svstnt1_scatter_u32base_index_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_index_s64)))
+void svstnt1_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_offset_u32)))
+void svstnt1_scatter_u32base_offset_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_offset_u64)))
+void svstnt1_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_offset_f64)))
+void svstnt1_scatter_u64base_offset_f64(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_offset_f32)))
+void svstnt1_scatter_u32base_offset_f32(svbool_t, svuint32_t, int64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_offset_s32)))
+void svstnt1_scatter_u32base_offset_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_offset_s64)))
+void svstnt1_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_u32)))
+void svstnt1_scatter_u32base_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_u64)))
+void svstnt1_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_f64)))
+void svstnt1_scatter_u64base_f64(svbool_t, svuint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_f32)))
+void svstnt1_scatter_u32base_f32(svbool_t, svuint32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_s32)))
+void svstnt1_scatter_u32base_s32(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_s64)))
+void svstnt1_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64index_u64)))
+void svstnt1_scatter_s64index_u64(svbool_t, uint64_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64index_f64)))
+void svstnt1_scatter_s64index_f64(svbool_t, float64_t *, svint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64index_s64)))
+void svstnt1_scatter_s64index_s64(svbool_t, int64_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64index_u64)))
+void svstnt1_scatter_u64index_u64(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64index_f64)))
+void svstnt1_scatter_u64index_f64(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64index_s64)))
+void svstnt1_scatter_u64index_s64(svbool_t, int64_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32offset_u32)))
+void svstnt1_scatter_u32offset_u32(svbool_t, uint32_t *, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32offset_f32)))
+void svstnt1_scatter_u32offset_f32(svbool_t, float32_t *, svuint32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32offset_s32)))
+void svstnt1_scatter_u32offset_s32(svbool_t, int32_t *, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64offset_u64)))
+void svstnt1_scatter_s64offset_u64(svbool_t, uint64_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64offset_f64)))
+void svstnt1_scatter_s64offset_f64(svbool_t, float64_t *, svint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64offset_s64)))
+void svstnt1_scatter_s64offset_s64(svbool_t, int64_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64offset_u64)))
+void svstnt1_scatter_u64offset_u64(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64offset_f64)))
+void svstnt1_scatter_u64offset_f64(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64offset_s64)))
+void svstnt1_scatter_u64offset_s64(svbool_t, int64_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_offset_u32)))
+void svstnt1b_scatter_u32base_offset_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_offset_u64)))
+void svstnt1b_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_offset_s32)))
+void svstnt1b_scatter_u32base_offset_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_offset_s64)))
+void svstnt1b_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_u32)))
+void svstnt1b_scatter_u32base_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_u64)))
+void svstnt1b_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_s32)))
+void svstnt1b_scatter_u32base_s32(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_s64)))
+void svstnt1b_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32offset_s32)))
+void svstnt1b_scatter_u32offset_s32(svbool_t, int8_t *, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32offset_u32)))
+void svstnt1b_scatter_u32offset_u32(svbool_t, uint8_t *, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_s64offset_s64)))
+void svstnt1b_scatter_s64offset_s64(svbool_t, int8_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_s64offset_u64)))
+void svstnt1b_scatter_s64offset_u64(svbool_t, uint8_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64offset_s64)))
+void svstnt1b_scatter_u64offset_s64(svbool_t, int8_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64offset_u64)))
+void svstnt1b_scatter_u64offset_u64(svbool_t, uint8_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_index_u32)))
+void svstnt1h_scatter_u32base_index_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_index_u64)))
+void svstnt1h_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_index_s32)))
+void svstnt1h_scatter_u32base_index_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_index_s64)))
+void svstnt1h_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_offset_u32)))
+void svstnt1h_scatter_u32base_offset_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_offset_u64)))
+void svstnt1h_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_offset_s32)))
+void svstnt1h_scatter_u32base_offset_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_offset_s64)))
+void svstnt1h_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_u32)))
+void svstnt1h_scatter_u32base_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_u64)))
+void svstnt1h_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_s32)))
+void svstnt1h_scatter_u32base_s32(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_s64)))
+void svstnt1h_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64index_s64)))
+void svstnt1h_scatter_s64index_s64(svbool_t, int16_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64index_u64)))
+void svstnt1h_scatter_s64index_u64(svbool_t, uint16_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64index_s64)))
+void svstnt1h_scatter_u64index_s64(svbool_t, int16_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64index_u64)))
+void svstnt1h_scatter_u64index_u64(svbool_t, uint16_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32offset_s32)))
+void svstnt1h_scatter_u32offset_s32(svbool_t, int16_t *, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32offset_u32)))
+void svstnt1h_scatter_u32offset_u32(svbool_t, uint16_t *, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64offset_s64)))
+void svstnt1h_scatter_s64offset_s64(svbool_t, int16_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64offset_u64)))
+void svstnt1h_scatter_s64offset_u64(svbool_t, uint16_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64offset_s64)))
+void svstnt1h_scatter_u64offset_s64(svbool_t, int16_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64offset_u64)))
+void svstnt1h_scatter_u64offset_u64(svbool_t, uint16_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_index_u64)))
+void svstnt1w_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_index_s64)))
+void svstnt1w_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_offset_u64)))
+void svstnt1w_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_offset_s64)))
+void svstnt1w_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_u64)))
+void svstnt1w_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_s64)))
+void svstnt1w_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64index_s64)))
+void svstnt1w_scatter_s64index_s64(svbool_t, int32_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64index_u64)))
+void svstnt1w_scatter_s64index_u64(svbool_t, uint32_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64index_s64)))
+void svstnt1w_scatter_u64index_s64(svbool_t, int32_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64index_u64)))
+void svstnt1w_scatter_u64index_u64(svbool_t, uint32_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64offset_s64)))
+void svstnt1w_scatter_s64offset_s64(svbool_t, int32_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64offset_u64)))
+void svstnt1w_scatter_s64offset_u64(svbool_t, uint32_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64offset_s64)))
+void svstnt1w_scatter_u64offset_s64(svbool_t, int32_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64offset_u64)))
+void svstnt1w_scatter_u64offset_u64(svbool_t, uint32_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_u32_z)))
+svuint32_t svhistcnt_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_u64_z)))
+svuint64_t svhistcnt_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_s32_z)))
+svuint32_t svhistcnt_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_s64_z)))
+svuint64_t svhistcnt_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistseg_u8)))
+svuint8_t svhistseg(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistseg_s8)))
+svuint8_t svhistseg(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_index_u32)))
+svuint32_t svldnt1_gather_index_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_index_u64)))
+svuint64_t svldnt1_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_index_f64)))
+svfloat64_t svldnt1_gather_index_f64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_index_f32)))
+svfloat32_t svldnt1_gather_index_f32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_index_s32)))
+svint32_t svldnt1_gather_index_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_index_s64)))
+svint64_t svldnt1_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_offset_u32)))
+svuint32_t svldnt1_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_offset_u64)))
+svuint64_t svldnt1_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_offset_f64)))
+svfloat64_t svldnt1_gather_offset_f64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_offset_f32)))
+svfloat32_t svldnt1_gather_offset_f32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_offset_s32)))
+svint32_t svldnt1_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_offset_s64)))
+svint64_t svldnt1_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_u32)))
+svuint32_t svldnt1_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_u64)))
+svuint64_t svldnt1_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_f64)))
+svfloat64_t svldnt1_gather_f64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_f32)))
+svfloat32_t svldnt1_gather_f32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_s32)))
+svint32_t svldnt1_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_s64)))
+svint64_t svldnt1_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64index_u64)))
+svuint64_t svldnt1_gather_index(svbool_t, uint64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64index_f64)))
+svfloat64_t svldnt1_gather_index(svbool_t, float64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64index_s64)))
+svint64_t svldnt1_gather_index(svbool_t, int64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64index_u64)))
+svuint64_t svldnt1_gather_index(svbool_t, uint64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64index_f64)))
+svfloat64_t svldnt1_gather_index(svbool_t, float64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64index_s64)))
+svint64_t svldnt1_gather_index(svbool_t, int64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32offset_u32)))
+svuint32_t svldnt1_gather_offset(svbool_t, uint32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32offset_f32)))
+svfloat32_t svldnt1_gather_offset(svbool_t, float32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32offset_s32)))
+svint32_t svldnt1_gather_offset(svbool_t, int32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64offset_u64)))
+svuint64_t svldnt1_gather_offset(svbool_t, uint64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64offset_f64)))
+svfloat64_t svldnt1_gather_offset(svbool_t, float64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64offset_s64)))
+svint64_t svldnt1_gather_offset(svbool_t, int64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64offset_u64)))
+svuint64_t svldnt1_gather_offset(svbool_t, uint64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64offset_f64)))
+svfloat64_t svldnt1_gather_offset(svbool_t, float64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64offset_s64)))
+svint64_t svldnt1_gather_offset(svbool_t, int64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_offset_u32)))
+svuint32_t svldnt1sb_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_offset_u64)))
+svuint64_t svldnt1sb_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_offset_s32)))
+svint32_t svldnt1sb_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_offset_s64)))
+svint64_t svldnt1sb_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_u32)))
+svuint32_t svldnt1sb_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_u64)))
+svuint64_t svldnt1sb_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_s32)))
+svint32_t svldnt1sb_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_s64)))
+svint64_t svldnt1sb_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32offset_u32)))
+svuint32_t svldnt1sb_gather_offset_u32(svbool_t, int8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32offset_s32)))
+svint32_t svldnt1sb_gather_offset_s32(svbool_t, int8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_s64offset_u64)))
+svuint64_t svldnt1sb_gather_offset_u64(svbool_t, int8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_s64offset_s64)))
+svint64_t svldnt1sb_gather_offset_s64(svbool_t, int8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64offset_u64)))
+svuint64_t svldnt1sb_gather_offset_u64(svbool_t, int8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64offset_s64)))
+svint64_t svldnt1sb_gather_offset_s64(svbool_t, int8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_index_u32)))
+svuint32_t svldnt1sh_gather_index_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_index_u64)))
+svuint64_t svldnt1sh_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_index_s32)))
+svint32_t svldnt1sh_gather_index_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_index_s64)))
+svint64_t svldnt1sh_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_offset_u32)))
+svuint32_t svldnt1sh_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_offset_u64)))
+svuint64_t svldnt1sh_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_offset_s32)))
+svint32_t svldnt1sh_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_offset_s64)))
+svint64_t svldnt1sh_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_u32)))
+svuint32_t svldnt1sh_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_u64)))
+svuint64_t svldnt1sh_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_s32)))
+svint32_t svldnt1sh_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_s64)))
+svint64_t svldnt1sh_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64index_u64)))
+svuint64_t svldnt1sh_gather_index_u64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64index_s64)))
+svint64_t svldnt1sh_gather_index_s64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64index_u64)))
+svuint64_t svldnt1sh_gather_index_u64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64index_s64)))
+svint64_t svldnt1sh_gather_index_s64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32offset_u32)))
+svuint32_t svldnt1sh_gather_offset_u32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32offset_s32)))
+svint32_t svldnt1sh_gather_offset_s32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64offset_u64)))
+svuint64_t svldnt1sh_gather_offset_u64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64offset_s64)))
+svint64_t svldnt1sh_gather_offset_s64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64offset_u64)))
+svuint64_t svldnt1sh_gather_offset_u64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64offset_s64)))
+svint64_t svldnt1sh_gather_offset_s64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_index_u64)))
+svuint64_t svldnt1sw_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_index_s64)))
+svint64_t svldnt1sw_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_offset_u64)))
+svuint64_t svldnt1sw_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_offset_s64)))
+svint64_t svldnt1sw_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_u64)))
+svuint64_t svldnt1sw_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_s64)))
+svint64_t svldnt1sw_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64index_u64)))
+svuint64_t svldnt1sw_gather_index_u64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64index_s64)))
+svint64_t svldnt1sw_gather_index_s64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64index_u64)))
+svuint64_t svldnt1sw_gather_index_u64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64index_s64)))
+svint64_t svldnt1sw_gather_index_s64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64offset_u64)))
+svuint64_t svldnt1sw_gather_offset_u64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64offset_s64)))
+svint64_t svldnt1sw_gather_offset_s64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64offset_u64)))
+svuint64_t svldnt1sw_gather_offset_u64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64offset_s64)))
+svint64_t svldnt1sw_gather_offset_s64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_offset_u32)))
+svuint32_t svldnt1ub_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_offset_u64)))
+svuint64_t svldnt1ub_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_offset_s32)))
+svint32_t svldnt1ub_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_offset_s64)))
+svint64_t svldnt1ub_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_u32)))
+svuint32_t svldnt1ub_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_u64)))
+svuint64_t svldnt1ub_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_s32)))
+svint32_t svldnt1ub_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_s64)))
+svint64_t svldnt1ub_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32offset_u32)))
+svuint32_t svldnt1ub_gather_offset_u32(svbool_t, uint8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32offset_s32)))
+svint32_t svldnt1ub_gather_offset_s32(svbool_t, uint8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_s64offset_u64)))
+svuint64_t svldnt1ub_gather_offset_u64(svbool_t, uint8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_s64offset_s64)))
+svint64_t svldnt1ub_gather_offset_s64(svbool_t, uint8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64offset_u64)))
+svuint64_t svldnt1ub_gather_offset_u64(svbool_t, uint8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64offset_s64)))
+svint64_t svldnt1ub_gather_offset_s64(svbool_t, uint8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_index_u32)))
+svuint32_t svldnt1uh_gather_index_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_index_u64)))
+svuint64_t svldnt1uh_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_index_s32)))
+svint32_t svldnt1uh_gather_index_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_index_s64)))
+svint64_t svldnt1uh_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_offset_u32)))
+svuint32_t svldnt1uh_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_offset_u64)))
+svuint64_t svldnt1uh_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_offset_s32)))
+svint32_t svldnt1uh_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_offset_s64)))
+svint64_t svldnt1uh_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_u32)))
+svuint32_t svldnt1uh_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_u64)))
+svuint64_t svldnt1uh_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_s32)))
+svint32_t svldnt1uh_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_s64)))
+svint64_t svldnt1uh_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64index_u64)))
+svuint64_t svldnt1uh_gather_index_u64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64index_s64)))
+svint64_t svldnt1uh_gather_index_s64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64index_u64)))
+svuint64_t svldnt1uh_gather_index_u64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64index_s64)))
+svint64_t svldnt1uh_gather_index_s64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32offset_u32)))
+svuint32_t svldnt1uh_gather_offset_u32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32offset_s32)))
+svint32_t svldnt1uh_gather_offset_s32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64offset_u64)))
+svuint64_t svldnt1uh_gather_offset_u64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64offset_s64)))
+svint64_t svldnt1uh_gather_offset_s64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64offset_u64)))
+svuint64_t svldnt1uh_gather_offset_u64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64offset_s64)))
+svint64_t svldnt1uh_gather_offset_s64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_index_u64)))
+svuint64_t svldnt1uw_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_index_s64)))
+svint64_t svldnt1uw_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_offset_u64)))
+svuint64_t svldnt1uw_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_offset_s64)))
+svint64_t svldnt1uw_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_u64)))
+svuint64_t svldnt1uw_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_s64)))
+svint64_t svldnt1uw_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64index_u64)))
+svuint64_t svldnt1uw_gather_index_u64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64index_s64)))
+svint64_t svldnt1uw_gather_index_s64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64index_u64)))
+svuint64_t svldnt1uw_gather_index_u64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64index_s64)))
+svint64_t svldnt1uw_gather_index_s64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64offset_u64)))
+svuint64_t svldnt1uw_gather_offset_u64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64offset_s64)))
+svint64_t svldnt1uw_gather_offset_s64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64offset_u64)))
+svuint64_t svldnt1uw_gather_offset_u64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64offset_s64)))
+svint64_t svldnt1uw_gather_offset_s64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_u8)))
+svbool_t svmatch(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_u16)))
+svbool_t svmatch(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_s8)))
+svbool_t svmatch(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_s16)))
+svbool_t svmatch(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_u8)))
+svbool_t svnmatch(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_u16)))
+svbool_t svnmatch(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_s8)))
+svbool_t svnmatch(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_s16)))
+svbool_t svnmatch(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_index_u32)))
+void svstnt1_scatter_index(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_index_u64)))
+void svstnt1_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_index_f64)))
+void svstnt1_scatter_index(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_index_f32)))
+void svstnt1_scatter_index(svbool_t, svuint32_t, int64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_index_s32)))
+void svstnt1_scatter_index(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_index_s64)))
+void svstnt1_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_offset_u32)))
+void svstnt1_scatter_offset(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_offset_u64)))
+void svstnt1_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_offset_f64)))
+void svstnt1_scatter_offset(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_offset_f32)))
+void svstnt1_scatter_offset(svbool_t, svuint32_t, int64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_offset_s32)))
+void svstnt1_scatter_offset(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_offset_s64)))
+void svstnt1_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_u32)))
+void svstnt1_scatter(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_u64)))
+void svstnt1_scatter(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_f64)))
+void svstnt1_scatter(svbool_t, svuint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_f32)))
+void svstnt1_scatter(svbool_t, svuint32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_s32)))
+void svstnt1_scatter(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_s64)))
+void svstnt1_scatter(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64index_u64)))
+void svstnt1_scatter_index(svbool_t, uint64_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64index_f64)))
+void svstnt1_scatter_index(svbool_t, float64_t *, svint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64index_s64)))
+void svstnt1_scatter_index(svbool_t, int64_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64index_u64)))
+void svstnt1_scatter_index(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64index_f64)))
+void svstnt1_scatter_index(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64index_s64)))
+void svstnt1_scatter_index(svbool_t, int64_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32offset_u32)))
+void svstnt1_scatter_offset(svbool_t, uint32_t *, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32offset_f32)))
+void svstnt1_scatter_offset(svbool_t, float32_t *, svuint32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32offset_s32)))
+void svstnt1_scatter_offset(svbool_t, int32_t *, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64offset_u64)))
+void svstnt1_scatter_offset(svbool_t, uint64_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64offset_f64)))
+void svstnt1_scatter_offset(svbool_t, float64_t *, svint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64offset_s64)))
+void svstnt1_scatter_offset(svbool_t, int64_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64offset_u64)))
+void svstnt1_scatter_offset(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64offset_f64)))
+void svstnt1_scatter_offset(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64offset_s64)))
+void svstnt1_scatter_offset(svbool_t, int64_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_offset_u32)))
+void svstnt1b_scatter_offset(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_offset_u64)))
+void svstnt1b_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_offset_s32)))
+void svstnt1b_scatter_offset(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_offset_s64)))
+void svstnt1b_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_u32)))
+void svstnt1b_scatter(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_u64)))
+void svstnt1b_scatter(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_s32)))
+void svstnt1b_scatter(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_s64)))
+void svstnt1b_scatter(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32offset_s32)))
+void svstnt1b_scatter_offset(svbool_t, int8_t *, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32offset_u32)))
+void svstnt1b_scatter_offset(svbool_t, uint8_t *, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_s64offset_s64)))
+void svstnt1b_scatter_offset(svbool_t, int8_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_s64offset_u64)))
+void svstnt1b_scatter_offset(svbool_t, uint8_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64offset_s64)))
+void svstnt1b_scatter_offset(svbool_t, int8_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64offset_u64)))
+void svstnt1b_scatter_offset(svbool_t, uint8_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_index_u32)))
+void svstnt1h_scatter_index(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_index_u64)))
+void svstnt1h_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_index_s32)))
+void svstnt1h_scatter_index(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_index_s64)))
+void svstnt1h_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_offset_u32)))
+void svstnt1h_scatter_offset(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_offset_u64)))
+void svstnt1h_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_offset_s32)))
+void svstnt1h_scatter_offset(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_offset_s64)))
+void svstnt1h_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_u32)))
+void svstnt1h_scatter(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_u64)))
+void svstnt1h_scatter(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_s32)))
+void svstnt1h_scatter(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_s64)))
+void svstnt1h_scatter(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64index_s64)))
+void svstnt1h_scatter_index(svbool_t, int16_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64index_u64)))
+void svstnt1h_scatter_index(svbool_t, uint16_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64index_s64)))
+void svstnt1h_scatter_index(svbool_t, int16_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64index_u64)))
+void svstnt1h_scatter_index(svbool_t, uint16_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32offset_s32)))
+void svstnt1h_scatter_offset(svbool_t, int16_t *, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32offset_u32)))
+void svstnt1h_scatter_offset(svbool_t, uint16_t *, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64offset_s64)))
+void svstnt1h_scatter_offset(svbool_t, int16_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64offset_u64)))
+void svstnt1h_scatter_offset(svbool_t, uint16_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64offset_s64)))
+void svstnt1h_scatter_offset(svbool_t, int16_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64offset_u64)))
+void svstnt1h_scatter_offset(svbool_t, uint16_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_index_u64)))
+void svstnt1w_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_index_s64)))
+void svstnt1w_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_offset_u64)))
+void svstnt1w_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_offset_s64)))
+void svstnt1w_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_u64)))
+void svstnt1w_scatter(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_s64)))
+void svstnt1w_scatter(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64index_s64)))
+void svstnt1w_scatter_index(svbool_t, int32_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64index_u64)))
+void svstnt1w_scatter_index(svbool_t, uint32_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64index_s64)))
+void svstnt1w_scatter_index(svbool_t, int32_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64index_u64)))
+void svstnt1w_scatter_index(svbool_t, uint32_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64offset_s64)))
+void svstnt1w_scatter_offset(svbool_t, int32_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64offset_u64)))
+void svstnt1w_scatter_offset(svbool_t, uint32_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64offset_s64)))
+void svstnt1w_scatter_offset(svbool_t, int32_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64offset_u64)))
+void svstnt1w_scatter_offset(svbool_t, uint32_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_bf16_m)))
+svbfloat16_t svadd_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_bf16_x)))
+svbfloat16_t svadd_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_bf16_z)))
+svbfloat16_t svadd_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_bf16_m)))
+svbfloat16_t svadd_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_bf16_x)))
+svbfloat16_t svadd_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_bf16_z)))
+svbfloat16_t svadd_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_bf16)))
+svbfloat16_t svclamp_bf16(svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_bf16_m)))
+svbfloat16_t svmax_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_bf16_x)))
+svbfloat16_t svmax_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_bf16_z)))
+svbfloat16_t svmax_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_m)))
+svbfloat16_t svmax_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_x)))
+svbfloat16_t svmax_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_z)))
+svbfloat16_t svmax_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_bf16_m)))
+svbfloat16_t svmaxnm_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_bf16_x)))
+svbfloat16_t svmaxnm_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_bf16_z)))
+svbfloat16_t svmaxnm_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_m)))
+svbfloat16_t svmaxnm_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_x)))
+svbfloat16_t svmaxnm_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_z)))
+svbfloat16_t svmaxnm_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_bf16_m)))
+svbfloat16_t svmin_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_bf16_x)))
+svbfloat16_t svmin_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_bf16_z)))
+svbfloat16_t svmin_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_m)))
+svbfloat16_t svmin_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_x)))
+svbfloat16_t svmin_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_z)))
+svbfloat16_t svmin_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_bf16_m)))
+svbfloat16_t svminnm_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_bf16_x)))
+svbfloat16_t svminnm_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_bf16_z)))
+svbfloat16_t svminnm_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_m)))
+svbfloat16_t svminnm_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_x)))
+svbfloat16_t svminnm_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_z)))
+svbfloat16_t svminnm_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_bf16_m)))
+svbfloat16_t svmla_n_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_bf16_x)))
+svbfloat16_t svmla_n_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_bf16_z)))
+svbfloat16_t svmla_n_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_bf16_m)))
+svbfloat16_t svmla_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_bf16_x)))
+svbfloat16_t svmla_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_bf16_z)))
+svbfloat16_t svmla_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_bf16)))
+svbfloat16_t svmla_lane_bf16(svbfloat16_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_bf16_m)))
+svbfloat16_t svmls_n_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_bf16_x)))
+svbfloat16_t svmls_n_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_bf16_z)))
+svbfloat16_t svmls_n_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_bf16_m)))
+svbfloat16_t svmls_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_bf16_x)))
+svbfloat16_t svmls_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_bf16_z)))
+svbfloat16_t svmls_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_bf16)))
+svbfloat16_t svmls_lane_bf16(svbfloat16_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_bf16_m)))
+svbfloat16_t svmul_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_bf16_x)))
+svbfloat16_t svmul_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_bf16_z)))
+svbfloat16_t svmul_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_bf16_m)))
+svbfloat16_t svmul_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_bf16_x)))
+svbfloat16_t svmul_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_bf16_z)))
+svbfloat16_t svmul_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_bf16)))
+svbfloat16_t svmul_lane_bf16(svbfloat16_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_bf16_m)))
+svbfloat16_t svsub_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_bf16_x)))
+svbfloat16_t svsub_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_bf16_z)))
+svbfloat16_t svsub_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_bf16_m)))
+svbfloat16_t svsub_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_bf16_x)))
+svbfloat16_t svsub_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_bf16_z)))
+svbfloat16_t svsub_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_bf16_m)))
+svbfloat16_t svadd_m(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_bf16_x)))
+svbfloat16_t svadd_x(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_bf16_z)))
+svbfloat16_t svadd_z(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_bf16_m)))
+svbfloat16_t svadd_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_bf16_x)))
+svbfloat16_t svadd_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_bf16_z)))
+svbfloat16_t svadd_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_bf16)))
+svbfloat16_t svclamp(svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_bf16_m)))
+svbfloat16_t svmax_m(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_bf16_x)))
+svbfloat16_t svmax_x(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_bf16_z)))
+svbfloat16_t svmax_z(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_m)))
+svbfloat16_t svmax_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_x)))
+svbfloat16_t svmax_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_z)))
+svbfloat16_t svmax_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_bf16_m)))
+svbfloat16_t svmaxnm_m(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_bf16_x)))
+svbfloat16_t svmaxnm_x(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_bf16_z)))
+svbfloat16_t svmaxnm_z(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_m)))
+svbfloat16_t svmaxnm_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_x)))
+svbfloat16_t svmaxnm_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_z)))
+svbfloat16_t svmaxnm_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_bf16_m)))
+svbfloat16_t svmin_m(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_bf16_x)))
+svbfloat16_t svmin_x(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_bf16_z)))
+svbfloat16_t svmin_z(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_m)))
+svbfloat16_t svmin_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_x)))
+svbfloat16_t svmin_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_z)))
+svbfloat16_t svmin_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_bf16_m)))
+svbfloat16_t svminnm_m(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_bf16_x)))
+svbfloat16_t svminnm_x(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_bf16_z)))
+svbfloat16_t svminnm_z(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_m)))
+svbfloat16_t svminnm_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_x)))
+svbfloat16_t svminnm_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_z)))
+svbfloat16_t svminnm_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_bf16_m)))
+svbfloat16_t svmla_m(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_bf16_x)))
+svbfloat16_t svmla_x(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_bf16_z)))
+svbfloat16_t svmla_z(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_bf16_m)))
+svbfloat16_t svmla_m(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_bf16_x)))
+svbfloat16_t svmla_x(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_bf16_z)))
+svbfloat16_t svmla_z(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_bf16)))
+svbfloat16_t svmla_lane(svbfloat16_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_bf16_m)))
+svbfloat16_t svmls_m(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_bf16_x)))
+svbfloat16_t svmls_x(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_bf16_z)))
+svbfloat16_t svmls_z(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_bf16_m)))
+svbfloat16_t svmls_m(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_bf16_x)))
+svbfloat16_t svmls_x(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_bf16_z)))
+svbfloat16_t svmls_z(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_bf16)))
+svbfloat16_t svmls_lane(svbfloat16_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_bf16_m)))
+svbfloat16_t svmul_m(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_bf16_x)))
+svbfloat16_t svmul_x(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_bf16_z)))
+svbfloat16_t svmul_z(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_bf16_m)))
+svbfloat16_t svmul_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_bf16_x)))
+svbfloat16_t svmul_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_bf16_z)))
+svbfloat16_t svmul_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_bf16)))
+svbfloat16_t svmul_lane(svbfloat16_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_bf16_m)))
+svbfloat16_t svsub_m(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_bf16_x)))
+svbfloat16_t svsub_x(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_bf16_z)))
+svbfloat16_t svsub_z(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_bf16_m)))
+svbfloat16_t svsub_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_bf16_x)))
+svbfloat16_t svsub_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_bf16_z)))
+svbfloat16_t svsub_z(svbool_t, svbfloat16_t, svbfloat16_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_bf16)))
svbfloat16_t svtbl2_bf16(svbfloat16x2_t, svuint16_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_bf16)))
@@ -27820,18 +8350,18 @@ __ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_u16)))
uint16x8_t svaddqv_u16(svbool_t, svuint16_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_s8)))
int8x16_t svaddqv_s8(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_f64)))
-float64x2_t svaddqv_f64(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_f32)))
-float32x4_t svaddqv_f32(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_f16)))
-float16x8_t svaddqv_f16(svbool_t, svfloat16_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_s32)))
int32x4_t svaddqv_s32(svbool_t, svint32_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_s64)))
int64x2_t svaddqv_s64(svbool_t, svint64_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_s16)))
int16x8_t svaddqv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_f64)))
+float64x2_t svaddqv_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_f32)))
+float32x4_t svaddqv_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_f16)))
+float16x8_t svaddqv_f16(svbool_t, svfloat16_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_u8)))
uint8x16_t svandqv_u8(svbool_t, svuint8_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_u32)))
@@ -28734,18 +9264,18 @@ __aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_u16)))
uint16x8_t svaddqv(svbool_t, svuint16_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_s8)))
int8x16_t svaddqv(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_f64)))
-float64x2_t svaddqv(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_f32)))
-float32x4_t svaddqv(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_f16)))
-float16x8_t svaddqv(svbool_t, svfloat16_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_s32)))
int32x4_t svaddqv(svbool_t, svint32_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_s64)))
int64x2_t svaddqv(svbool_t, svint64_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_s16)))
int16x8_t svaddqv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_f64)))
+float64x2_t svaddqv(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_f32)))
+float32x4_t svaddqv(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_f16)))
+float16x8_t svaddqv(svbool_t, svfloat16_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_u8)))
uint8x16_t svandqv(svbool_t, svuint8_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_u32)))
@@ -29622,6 +10152,26 @@ __aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_s64)))
svint64_t svzipq2(svint64_t, svint64_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_s16)))
svint16_t svzipq2(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_bf16)))
+svbfloat16_t svdup_laneq_bf16(svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_bf16)))
+svbfloat16_t svdup_laneq(svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s8)))
+svint8_t svclamp_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s32)))
+svint32_t svclamp_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s64)))
+svint64_t svclamp_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s16)))
+svint16_t svclamp_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u8)))
+svuint8_t svclamp_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u32)))
+svuint32_t svclamp_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u64)))
+svuint64_t svclamp_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u16)))
+svuint16_t svclamp_u16(svuint16_t, svuint16_t, svuint16_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpsel_lane_b16)))
svbool_t svpsel_lane_b16(svbool_t, svbool_t, uint32_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpsel_lane_b32)))
@@ -29630,6 +10180,166 @@ __ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpsel_lane_b64)))
svbool_t svpsel_lane_b64(svbool_t, svbool_t, uint32_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpsel_lane_b8)))
svbool_t svpsel_lane_b8(svbool_t, svbool_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u8_m)))
+svuint8_t svrevd_u8_m(svuint8_t, svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u32_m)))
+svuint32_t svrevd_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u64_m)))
+svuint64_t svrevd_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u16_m)))
+svuint16_t svrevd_u16_m(svuint16_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_bf16_m)))
+svbfloat16_t svrevd_bf16_m(svbfloat16_t, svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s8_m)))
+svint8_t svrevd_s8_m(svint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f64_m)))
+svfloat64_t svrevd_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f32_m)))
+svfloat32_t svrevd_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f16_m)))
+svfloat16_t svrevd_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s32_m)))
+svint32_t svrevd_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s64_m)))
+svint64_t svrevd_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s16_m)))
+svint16_t svrevd_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u8_x)))
+svuint8_t svrevd_u8_x(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u32_x)))
+svuint32_t svrevd_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u64_x)))
+svuint64_t svrevd_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u16_x)))
+svuint16_t svrevd_u16_x(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_bf16_x)))
+svbfloat16_t svrevd_bf16_x(svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s8_x)))
+svint8_t svrevd_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f64_x)))
+svfloat64_t svrevd_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f32_x)))
+svfloat32_t svrevd_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f16_x)))
+svfloat16_t svrevd_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s32_x)))
+svint32_t svrevd_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s64_x)))
+svint64_t svrevd_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s16_x)))
+svint16_t svrevd_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u8_z)))
+svuint8_t svrevd_u8_z(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u32_z)))
+svuint32_t svrevd_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u64_z)))
+svuint64_t svrevd_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u16_z)))
+svuint16_t svrevd_u16_z(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_bf16_z)))
+svbfloat16_t svrevd_bf16_z(svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s8_z)))
+svint8_t svrevd_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f64_z)))
+svfloat64_t svrevd_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f32_z)))
+svfloat32_t svrevd_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f16_z)))
+svfloat16_t svrevd_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s32_z)))
+svint32_t svrevd_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s64_z)))
+svint64_t svrevd_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s16_z)))
+svint16_t svrevd_s16_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s8)))
+svint8_t svclamp(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s32)))
+svint32_t svclamp(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s64)))
+svint64_t svclamp(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s16)))
+svint16_t svclamp(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u8)))
+svuint8_t svclamp(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u32)))
+svuint32_t svclamp(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u64)))
+svuint64_t svclamp(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u16)))
+svuint16_t svclamp(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u8_m)))
+svuint8_t svrevd_m(svuint8_t, svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u32_m)))
+svuint32_t svrevd_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u64_m)))
+svuint64_t svrevd_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u16_m)))
+svuint16_t svrevd_m(svuint16_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_bf16_m)))
+svbfloat16_t svrevd_m(svbfloat16_t, svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s8_m)))
+svint8_t svrevd_m(svint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f64_m)))
+svfloat64_t svrevd_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f32_m)))
+svfloat32_t svrevd_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f16_m)))
+svfloat16_t svrevd_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s32_m)))
+svint32_t svrevd_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s64_m)))
+svint64_t svrevd_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s16_m)))
+svint16_t svrevd_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u8_x)))
+svuint8_t svrevd_x(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u32_x)))
+svuint32_t svrevd_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u64_x)))
+svuint64_t svrevd_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u16_x)))
+svuint16_t svrevd_x(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_bf16_x)))
+svbfloat16_t svrevd_x(svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s8_x)))
+svint8_t svrevd_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f64_x)))
+svfloat64_t svrevd_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f32_x)))
+svfloat32_t svrevd_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f16_x)))
+svfloat16_t svrevd_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s32_x)))
+svint32_t svrevd_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s64_x)))
+svint64_t svrevd_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s16_x)))
+svint16_t svrevd_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u8_z)))
+svuint8_t svrevd_z(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u32_z)))
+svuint32_t svrevd_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u64_z)))
+svuint64_t svrevd_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u16_z)))
+svuint16_t svrevd_z(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_bf16_z)))
+svbfloat16_t svrevd_z(svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s8_z)))
+svint8_t svrevd_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f64_z)))
+svfloat64_t svrevd_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f32_z)))
+svfloat32_t svrevd_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f16_z)))
+svfloat16_t svrevd_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s32_z)))
+svint32_t svrevd_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s64_z)))
+svint64_t svrevd_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s16_z)))
+svint16_t svrevd_z(svbool_t, svint16_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlslb_f32)))
svfloat32_t svbfmlslb_f32(svfloat32_t, svbfloat16_t, svbfloat16_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlslb_lane_f32)))
@@ -29644,22 +10354,6 @@ __ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_f32)))
svfloat32_t svclamp_f32(svfloat32_t, svfloat32_t, svfloat32_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_f16)))
svfloat16_t svclamp_f16(svfloat16_t, svfloat16_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s8)))
-svint8_t svclamp_s8(svint8_t, svint8_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s32)))
-svint32_t svclamp_s32(svint32_t, svint32_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s64)))
-svint64_t svclamp_s64(svint64_t, svint64_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s16)))
-svint16_t svclamp_s16(svint16_t, svint16_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u8)))
-svuint8_t svclamp_u8(svuint8_t, svuint8_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u32)))
-svuint32_t svclamp_u32(svuint32_t, svuint32_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u64)))
-svuint64_t svclamp_u64(svuint64_t, svuint64_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u16)))
-svuint16_t svclamp_u16(svuint16_t, svuint16_t, svuint16_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntp_c8)))
uint64_t svcntp_c8(svcount_t, uint64_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntp_c32)))
@@ -29914,84 +10608,22 @@ __ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_c64)))
svcount_t svptrue_c64(void);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_c16)))
svcount_t svptrue_c16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_s16_s32_x2)))
+svint16_t svqcvtn_s16_s32_x2(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_s32_x2)))
+svuint16_t svqcvtn_u16_s32_x2(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_u32_x2)))
+svuint16_t svqcvtn_u16_u32_x2(svuint32x2_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_s16_s32_x2)))
svint16_t svqrshrn_n_s16_s32_x2(svint32x2_t, uint64_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_u16_u32_x2)))
svuint16_t svqrshrn_n_u16_u32_x2(svuint32x2_t, uint64_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrun_n_u16_s32_x2)))
svuint16_t svqrshrun_n_u16_s32_x2(svint32x2_t, uint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u8_m)))
-svuint8_t svrevd_u8_m(svuint8_t, svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u32_m)))
-svuint32_t svrevd_u32_m(svuint32_t, svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u64_m)))
-svuint64_t svrevd_u64_m(svuint64_t, svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u16_m)))
-svuint16_t svrevd_u16_m(svuint16_t, svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_bf16_m)))
-svbfloat16_t svrevd_bf16_m(svbfloat16_t, svbool_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s8_m)))
-svint8_t svrevd_s8_m(svint8_t, svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f64_m)))
-svfloat64_t svrevd_f64_m(svfloat64_t, svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f32_m)))
-svfloat32_t svrevd_f32_m(svfloat32_t, svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f16_m)))
-svfloat16_t svrevd_f16_m(svfloat16_t, svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s32_m)))
-svint32_t svrevd_s32_m(svint32_t, svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s64_m)))
-svint64_t svrevd_s64_m(svint64_t, svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s16_m)))
-svint16_t svrevd_s16_m(svint16_t, svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u8_x)))
-svuint8_t svrevd_u8_x(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u32_x)))
-svuint32_t svrevd_u32_x(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u64_x)))
-svuint64_t svrevd_u64_x(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u16_x)))
-svuint16_t svrevd_u16_x(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_bf16_x)))
-svbfloat16_t svrevd_bf16_x(svbool_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s8_x)))
-svint8_t svrevd_s8_x(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f64_x)))
-svfloat64_t svrevd_f64_x(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f32_x)))
-svfloat32_t svrevd_f32_x(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f16_x)))
-svfloat16_t svrevd_f16_x(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s32_x)))
-svint32_t svrevd_s32_x(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s64_x)))
-svint64_t svrevd_s64_x(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s16_x)))
-svint16_t svrevd_s16_x(svbool_t, svint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u8_z)))
-svuint8_t svrevd_u8_z(svbool_t, svuint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u32_z)))
-svuint32_t svrevd_u32_z(svbool_t, svuint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u64_z)))
-svuint64_t svrevd_u64_z(svbool_t, svuint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u16_z)))
-svuint16_t svrevd_u16_z(svbool_t, svuint16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_bf16_z)))
-svbfloat16_t svrevd_bf16_z(svbool_t, svbfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s8_z)))
-svint8_t svrevd_s8_z(svbool_t, svint8_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f64_z)))
-svfloat64_t svrevd_f64_z(svbool_t, svfloat64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f32_z)))
-svfloat32_t svrevd_f32_z(svbool_t, svfloat32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f16_z)))
-svfloat16_t svrevd_f16_z(svbool_t, svfloat16_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s32_z)))
-svint32_t svrevd_s32_z(svbool_t, svint32_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s64_z)))
-svint64_t svrevd_s64_z(svbool_t, svint64_t);
-__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s16_z)))
-svint16_t svrevd_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svreinterpret_b)))
+svbool_t svreinterpret_b(svcount_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svreinterpret_c)))
+svcount_t svreinterpret_c(svbool_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_b)))
svboolx2_t svset2_b(svboolx2_t, uint64_t, svbool_t);
__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_b)))
@@ -30334,22 +10966,6 @@ __aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_f32)))
svfloat32_t svclamp(svfloat32_t, svfloat32_t, svfloat32_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_f16)))
svfloat16_t svclamp(svfloat16_t, svfloat16_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s8)))
-svint8_t svclamp(svint8_t, svint8_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s32)))
-svint32_t svclamp(svint32_t, svint32_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s64)))
-svint64_t svclamp(svint64_t, svint64_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s16)))
-svint16_t svclamp(svint16_t, svint16_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u8)))
-svuint8_t svclamp(svuint8_t, svuint8_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u32)))
-svuint32_t svclamp(svuint32_t, svuint32_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u64)))
-svuint64_t svclamp(svuint64_t, svuint64_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u16)))
-svuint16_t svclamp(svuint16_t, svuint16_t, svuint16_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_b)))
svboolx2_t svcreate2(svbool_t, svbool_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_b)))
@@ -30562,84 +11178,22 @@ __aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f32_x4
svfloat32x4_t svldnt1_vnum_x4(svcount_t, float32_t const *, int64_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s32_x4)))
svint32x4_t svldnt1_vnum_x4(svcount_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_s16_s32_x2)))
+svint16_t svqcvtn_s16(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_s32_x2)))
+svuint16_t svqcvtn_u16(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_u32_x2)))
+svuint16_t svqcvtn_u16(svuint32x2_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_s16_s32_x2)))
svint16_t svqrshrn_s16(svint32x2_t, uint64_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_u16_u32_x2)))
svuint16_t svqrshrn_u16(svuint32x2_t, uint64_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrun_n_u16_s32_x2)))
svuint16_t svqrshrun_u16(svint32x2_t, uint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u8_m)))
-svuint8_t svrevd_m(svuint8_t, svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u32_m)))
-svuint32_t svrevd_m(svuint32_t, svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u64_m)))
-svuint64_t svrevd_m(svuint64_t, svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u16_m)))
-svuint16_t svrevd_m(svuint16_t, svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_bf16_m)))
-svbfloat16_t svrevd_m(svbfloat16_t, svbool_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s8_m)))
-svint8_t svrevd_m(svint8_t, svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f64_m)))
-svfloat64_t svrevd_m(svfloat64_t, svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f32_m)))
-svfloat32_t svrevd_m(svfloat32_t, svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f16_m)))
-svfloat16_t svrevd_m(svfloat16_t, svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s32_m)))
-svint32_t svrevd_m(svint32_t, svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s64_m)))
-svint64_t svrevd_m(svint64_t, svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s16_m)))
-svint16_t svrevd_m(svint16_t, svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u8_x)))
-svuint8_t svrevd_x(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u32_x)))
-svuint32_t svrevd_x(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u64_x)))
-svuint64_t svrevd_x(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u16_x)))
-svuint16_t svrevd_x(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_bf16_x)))
-svbfloat16_t svrevd_x(svbool_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s8_x)))
-svint8_t svrevd_x(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f64_x)))
-svfloat64_t svrevd_x(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f32_x)))
-svfloat32_t svrevd_x(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f16_x)))
-svfloat16_t svrevd_x(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s32_x)))
-svint32_t svrevd_x(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s64_x)))
-svint64_t svrevd_x(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s16_x)))
-svint16_t svrevd_x(svbool_t, svint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u8_z)))
-svuint8_t svrevd_z(svbool_t, svuint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u32_z)))
-svuint32_t svrevd_z(svbool_t, svuint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u64_z)))
-svuint64_t svrevd_z(svbool_t, svuint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u16_z)))
-svuint16_t svrevd_z(svbool_t, svuint16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_bf16_z)))
-svbfloat16_t svrevd_z(svbool_t, svbfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s8_z)))
-svint8_t svrevd_z(svbool_t, svint8_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f64_z)))
-svfloat64_t svrevd_z(svbool_t, svfloat64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f32_z)))
-svfloat32_t svrevd_z(svbool_t, svfloat32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f16_z)))
-svfloat16_t svrevd_z(svbool_t, svfloat16_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s32_z)))
-svint32_t svrevd_z(svbool_t, svint32_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s64_z)))
-svint64_t svrevd_z(svbool_t, svint64_t);
-__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s16_z)))
-svint16_t svrevd_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svreinterpret_b)))
+svbool_t svreinterpret(svcount_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svreinterpret_c)))
+svcount_t svreinterpret(svbool_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_b)))
svboolx2_t svset2(svboolx2_t, uint64_t, svbool_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_b)))
@@ -30964,6 +11518,19004 @@ __aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_s64_x
svboolx2_t svwhilelt_b64_x2(int64_t, int64_t);
__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_s64_x2)))
svboolx2_t svwhilelt_b16_x2(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_u8)))
+svuint8_t svdup_laneq_u8(svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_s8)))
+svint8_t svdup_laneq_s8(svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_u64)))
+svuint64_t svdup_laneq_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_f64)))
+svfloat64_t svdup_laneq_f64(svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_s64)))
+svint64_t svdup_laneq_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_u16)))
+svuint16_t svdup_laneq_u16(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_f16)))
+svfloat16_t svdup_laneq_f16(svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_s16)))
+svint16_t svdup_laneq_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_u32)))
+svuint32_t svdup_laneq_u32(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_f32)))
+svfloat32_t svdup_laneq_f32(svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_s32)))
+svint32_t svdup_laneq_s32(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_u8)))
+svuint8_t svdup_laneq(svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_s8)))
+svint8_t svdup_laneq(svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_u64)))
+svuint64_t svdup_laneq(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_f64)))
+svfloat64_t svdup_laneq(svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_s64)))
+svint64_t svdup_laneq(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_u16)))
+svuint16_t svdup_laneq(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_f16)))
+svfloat16_t svdup_laneq(svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_s16)))
+svint16_t svdup_laneq(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_u32)))
+svuint32_t svdup_laneq(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_f32)))
+svfloat32_t svdup_laneq(svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_s32)))
+svint32_t svdup_laneq(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s8)))
+svint8_t svaba_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s32)))
+svint32_t svaba_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s64)))
+svint64_t svaba_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s16)))
+svint16_t svaba_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u8)))
+svuint8_t svaba_n_u8(svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u32)))
+svuint32_t svaba_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u64)))
+svuint64_t svaba_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u16)))
+svuint16_t svaba_n_u16(svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s8)))
+svint8_t svaba_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s32)))
+svint32_t svaba_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s64)))
+svint64_t svaba_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s16)))
+svint16_t svaba_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u8)))
+svuint8_t svaba_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u32)))
+svuint32_t svaba_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u64)))
+svuint64_t svaba_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u16)))
+svuint16_t svaba_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_s32)))
+svint32_t svabalb_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_s64)))
+svint64_t svabalb_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_s16)))
+svint16_t svabalb_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_u32)))
+svuint32_t svabalb_n_u32(svuint32_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_u64)))
+svuint64_t svabalb_n_u64(svuint64_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_u16)))
+svuint16_t svabalb_n_u16(svuint16_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_s32)))
+svint32_t svabalb_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_s64)))
+svint64_t svabalb_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_s16)))
+svint16_t svabalb_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_u32)))
+svuint32_t svabalb_u32(svuint32_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_u64)))
+svuint64_t svabalb_u64(svuint64_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_u16)))
+svuint16_t svabalb_u16(svuint16_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_s32)))
+svint32_t svabalt_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_s64)))
+svint64_t svabalt_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_s16)))
+svint16_t svabalt_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_u32)))
+svuint32_t svabalt_n_u32(svuint32_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_u64)))
+svuint64_t svabalt_n_u64(svuint64_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_u16)))
+svuint16_t svabalt_n_u16(svuint16_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_s32)))
+svint32_t svabalt_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_s64)))
+svint64_t svabalt_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_s16)))
+svint16_t svabalt_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_u32)))
+svuint32_t svabalt_u32(svuint32_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_u64)))
+svuint64_t svabalt_u64(svuint64_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_u16)))
+svuint16_t svabalt_u16(svuint16_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_s32)))
+svint32_t svabdlb_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_s64)))
+svint64_t svabdlb_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_s16)))
+svint16_t svabdlb_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_u32)))
+svuint32_t svabdlb_n_u32(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_u64)))
+svuint64_t svabdlb_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_u16)))
+svuint16_t svabdlb_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_s32)))
+svint32_t svabdlb_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_s64)))
+svint64_t svabdlb_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_s16)))
+svint16_t svabdlb_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_u32)))
+svuint32_t svabdlb_u32(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_u64)))
+svuint64_t svabdlb_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_u16)))
+svuint16_t svabdlb_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_s32)))
+svint32_t svabdlt_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_s64)))
+svint64_t svabdlt_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_s16)))
+svint16_t svabdlt_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_u32)))
+svuint32_t svabdlt_n_u32(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_u64)))
+svuint64_t svabdlt_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_u16)))
+svuint16_t svabdlt_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_s32)))
+svint32_t svabdlt_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_s64)))
+svint64_t svabdlt_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_s16)))
+svint16_t svabdlt_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_u32)))
+svuint32_t svabdlt_u32(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_u64)))
+svuint64_t svabdlt_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_u16)))
+svuint16_t svabdlt_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s32_m)))
+svint32_t svadalp_s32_m(svbool_t, svint32_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s64_m)))
+svint64_t svadalp_s64_m(svbool_t, svint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s16_m)))
+svint16_t svadalp_s16_m(svbool_t, svint16_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s32_x)))
+svint32_t svadalp_s32_x(svbool_t, svint32_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s64_x)))
+svint64_t svadalp_s64_x(svbool_t, svint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s16_x)))
+svint16_t svadalp_s16_x(svbool_t, svint16_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s32_z)))
+svint32_t svadalp_s32_z(svbool_t, svint32_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s64_z)))
+svint64_t svadalp_s64_z(svbool_t, svint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s16_z)))
+svint16_t svadalp_s16_z(svbool_t, svint16_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u32_m)))
+svuint32_t svadalp_u32_m(svbool_t, svuint32_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u64_m)))
+svuint64_t svadalp_u64_m(svbool_t, svuint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u16_m)))
+svuint16_t svadalp_u16_m(svbool_t, svuint16_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u32_x)))
+svuint32_t svadalp_u32_x(svbool_t, svuint32_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u64_x)))
+svuint64_t svadalp_u64_x(svbool_t, svuint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u16_x)))
+svuint16_t svadalp_u16_x(svbool_t, svuint16_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u32_z)))
+svuint32_t svadalp_u32_z(svbool_t, svuint32_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u64_z)))
+svuint64_t svadalp_u64_z(svbool_t, svuint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u16_z)))
+svuint16_t svadalp_u16_z(svbool_t, svuint16_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_n_u32)))
+svuint32_t svadclb_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_n_u64)))
+svuint64_t svadclb_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_u32)))
+svuint32_t svadclb_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_u64)))
+svuint64_t svadclb_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_n_u32)))
+svuint32_t svadclt_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_n_u64)))
+svuint64_t svadclt_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_u32)))
+svuint32_t svadclt_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_u64)))
+svuint64_t svadclt_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_u32)))
+svuint16_t svaddhnb_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_u64)))
+svuint32_t svaddhnb_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_u16)))
+svuint8_t svaddhnb_n_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_s32)))
+svint16_t svaddhnb_n_s32(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_s64)))
+svint32_t svaddhnb_n_s64(svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_s16)))
+svint8_t svaddhnb_n_s16(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_u32)))
+svuint16_t svaddhnb_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_u64)))
+svuint32_t svaddhnb_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_u16)))
+svuint8_t svaddhnb_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_s32)))
+svint16_t svaddhnb_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_s64)))
+svint32_t svaddhnb_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_s16)))
+svint8_t svaddhnb_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_u32)))
+svuint16_t svaddhnt_n_u32(svuint16_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_u64)))
+svuint32_t svaddhnt_n_u64(svuint32_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_u16)))
+svuint8_t svaddhnt_n_u16(svuint8_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_s32)))
+svint16_t svaddhnt_n_s32(svint16_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_s64)))
+svint32_t svaddhnt_n_s64(svint32_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_s16)))
+svint8_t svaddhnt_n_s16(svint8_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_u32)))
+svuint16_t svaddhnt_u32(svuint16_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_u64)))
+svuint32_t svaddhnt_u64(svuint32_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_u16)))
+svuint8_t svaddhnt_u16(svuint8_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_s32)))
+svint16_t svaddhnt_s32(svint16_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_s64)))
+svint32_t svaddhnt_s64(svint32_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_s16)))
+svint8_t svaddhnt_s16(svint8_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_s32)))
+svint32_t svaddlb_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_s64)))
+svint64_t svaddlb_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_s16)))
+svint16_t svaddlb_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_u32)))
+svuint32_t svaddlb_n_u32(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_u64)))
+svuint64_t svaddlb_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_u16)))
+svuint16_t svaddlb_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_s32)))
+svint32_t svaddlb_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_s64)))
+svint64_t svaddlb_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_s16)))
+svint16_t svaddlb_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_u32)))
+svuint32_t svaddlb_u32(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_u64)))
+svuint64_t svaddlb_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_u16)))
+svuint16_t svaddlb_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_n_s32)))
+svint32_t svaddlbt_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_n_s64)))
+svint64_t svaddlbt_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_n_s16)))
+svint16_t svaddlbt_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_s32)))
+svint32_t svaddlbt_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_s64)))
+svint64_t svaddlbt_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_s16)))
+svint16_t svaddlbt_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_s32)))
+svint32_t svaddlt_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_s64)))
+svint64_t svaddlt_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_s16)))
+svint16_t svaddlt_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_u32)))
+svuint32_t svaddlt_n_u32(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_u64)))
+svuint64_t svaddlt_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_u16)))
+svuint16_t svaddlt_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_s32)))
+svint32_t svaddlt_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_s64)))
+svint64_t svaddlt_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_s16)))
+svint16_t svaddlt_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_u32)))
+svuint32_t svaddlt_u32(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_u64)))
+svuint64_t svaddlt_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_u16)))
+svuint16_t svaddlt_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f64_m)))
+svfloat64_t svaddp_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f32_m)))
+svfloat32_t svaddp_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f16_m)))
+svfloat16_t svaddp_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f64_x)))
+svfloat64_t svaddp_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f32_x)))
+svfloat32_t svaddp_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f16_x)))
+svfloat16_t svaddp_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u8_m)))
+svuint8_t svaddp_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u32_m)))
+svuint32_t svaddp_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u64_m)))
+svuint64_t svaddp_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u16_m)))
+svuint16_t svaddp_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s8_m)))
+svint8_t svaddp_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s32_m)))
+svint32_t svaddp_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s64_m)))
+svint64_t svaddp_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s16_m)))
+svint16_t svaddp_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u8_x)))
+svuint8_t svaddp_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u32_x)))
+svuint32_t svaddp_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u64_x)))
+svuint64_t svaddp_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u16_x)))
+svuint16_t svaddp_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s8_x)))
+svint8_t svaddp_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s32_x)))
+svint32_t svaddp_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s64_x)))
+svint64_t svaddp_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s16_x)))
+svint16_t svaddp_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_s32)))
+svint32_t svaddwb_n_s32(svint32_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_s64)))
+svint64_t svaddwb_n_s64(svint64_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_s16)))
+svint16_t svaddwb_n_s16(svint16_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_u32)))
+svuint32_t svaddwb_n_u32(svuint32_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_u64)))
+svuint64_t svaddwb_n_u64(svuint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_u16)))
+svuint16_t svaddwb_n_u16(svuint16_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_s32)))
+svint32_t svaddwb_s32(svint32_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_s64)))
+svint64_t svaddwb_s64(svint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_s16)))
+svint16_t svaddwb_s16(svint16_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_u32)))
+svuint32_t svaddwb_u32(svuint32_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_u64)))
+svuint64_t svaddwb_u64(svuint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_u16)))
+svuint16_t svaddwb_u16(svuint16_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_s32)))
+svint32_t svaddwt_n_s32(svint32_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_s64)))
+svint64_t svaddwt_n_s64(svint64_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_s16)))
+svint16_t svaddwt_n_s16(svint16_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_u32)))
+svuint32_t svaddwt_n_u32(svuint32_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_u64)))
+svuint64_t svaddwt_n_u64(svuint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_u16)))
+svuint16_t svaddwt_n_u16(svuint16_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_s32)))
+svint32_t svaddwt_s32(svint32_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_s64)))
+svint64_t svaddwt_s64(svint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_s16)))
+svint16_t svaddwt_s16(svint16_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_u32)))
+svuint32_t svaddwt_u32(svuint32_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_u64)))
+svuint64_t svaddwt_u64(svuint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_u16)))
+svuint16_t svaddwt_u16(svuint16_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u8)))
+svuint8_t svbcax_n_u8(svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u32)))
+svuint32_t svbcax_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u64)))
+svuint64_t svbcax_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u16)))
+svuint16_t svbcax_n_u16(svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s8)))
+svint8_t svbcax_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s32)))
+svint32_t svbcax_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s64)))
+svint64_t svbcax_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s16)))
+svint16_t svbcax_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u8)))
+svuint8_t svbcax_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u32)))
+svuint32_t svbcax_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u64)))
+svuint64_t svbcax_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u16)))
+svuint16_t svbcax_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s8)))
+svint8_t svbcax_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s32)))
+svint32_t svbcax_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s64)))
+svint64_t svbcax_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s16)))
+svint16_t svbcax_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u8)))
+svuint8_t svbsl1n_n_u8(svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u32)))
+svuint32_t svbsl1n_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u64)))
+svuint64_t svbsl1n_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u16)))
+svuint16_t svbsl1n_n_u16(svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s8)))
+svint8_t svbsl1n_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s32)))
+svint32_t svbsl1n_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s64)))
+svint64_t svbsl1n_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s16)))
+svint16_t svbsl1n_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u8)))
+svuint8_t svbsl1n_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u32)))
+svuint32_t svbsl1n_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u64)))
+svuint64_t svbsl1n_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u16)))
+svuint16_t svbsl1n_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s8)))
+svint8_t svbsl1n_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s32)))
+svint32_t svbsl1n_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s64)))
+svint64_t svbsl1n_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s16)))
+svint16_t svbsl1n_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u8)))
+svuint8_t svbsl2n_n_u8(svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u32)))
+svuint32_t svbsl2n_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u64)))
+svuint64_t svbsl2n_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u16)))
+svuint16_t svbsl2n_n_u16(svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s8)))
+svint8_t svbsl2n_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s32)))
+svint32_t svbsl2n_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s64)))
+svint64_t svbsl2n_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s16)))
+svint16_t svbsl2n_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u8)))
+svuint8_t svbsl2n_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u32)))
+svuint32_t svbsl2n_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u64)))
+svuint64_t svbsl2n_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u16)))
+svuint16_t svbsl2n_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s8)))
+svint8_t svbsl2n_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s32)))
+svint32_t svbsl2n_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s64)))
+svint64_t svbsl2n_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s16)))
+svint16_t svbsl2n_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u8)))
+svuint8_t svbsl_n_u8(svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u32)))
+svuint32_t svbsl_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u64)))
+svuint64_t svbsl_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u16)))
+svuint16_t svbsl_n_u16(svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s8)))
+svint8_t svbsl_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s32)))
+svint32_t svbsl_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s64)))
+svint64_t svbsl_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s16)))
+svint16_t svbsl_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u8)))
+svuint8_t svbsl_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u32)))
+svuint32_t svbsl_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u64)))
+svuint64_t svbsl_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u16)))
+svuint16_t svbsl_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s8)))
+svint8_t svbsl_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s32)))
+svint32_t svbsl_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s64)))
+svint64_t svbsl_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s16)))
+svint16_t svbsl_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u8)))
+svuint8_t svcadd_u8(svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u32)))
+svuint32_t svcadd_u32(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u64)))
+svuint64_t svcadd_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u16)))
+svuint16_t svcadd_u16(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s8)))
+svint8_t svcadd_s8(svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s32)))
+svint32_t svcadd_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s64)))
+svint64_t svcadd_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s16)))
+svint16_t svcadd_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_s32)))
+svint32_t svcdot_s32(svint32_t, svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_s64)))
+svint64_t svcdot_s64(svint64_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_lane_s32)))
+svint32_t svcdot_lane_s32(svint32_t, svint8_t, svint8_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_lane_s64)))
+svint64_t svcdot_lane_s64(svint64_t, svint16_t, svint16_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u8)))
+svuint8_t svcmla_u8(svuint8_t, svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u32)))
+svuint32_t svcmla_u32(svuint32_t, svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u64)))
+svuint64_t svcmla_u64(svuint64_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u16)))
+svuint16_t svcmla_u16(svuint16_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s8)))
+svint8_t svcmla_s8(svint8_t, svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s32)))
+svint32_t svcmla_s32(svint32_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s64)))
+svint64_t svcmla_s64(svint64_t, svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s16)))
+svint16_t svcmla_s16(svint16_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_u32)))
+svuint32_t svcmla_lane_u32(svuint32_t, svuint32_t, svuint32_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_u16)))
+svuint16_t svcmla_lane_u16(svuint16_t, svuint16_t, svuint16_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_s32)))
+svint32_t svcmla_lane_s32(svint32_t, svint32_t, svint32_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_s16)))
+svint16_t svcmla_lane_s16(svint16_t, svint16_t, svint16_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f32_f16_m)))
+svfloat32_t svcvtlt_f32_f16_m(svfloat32_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f32_f16_x)))
+svfloat32_t svcvtlt_f32_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f64_f32_m)))
+svfloat64_t svcvtlt_f64_f32_m(svfloat64_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f64_f32_x)))
+svfloat64_t svcvtlt_f64_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtnt_f16_f32_m)))
+svfloat16_t svcvtnt_f16_f32_m(svfloat16_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtnt_f32_f64_m)))
+svfloat32_t svcvtnt_f32_f64_m(svfloat32_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtx_f32_f64_m)))
+svfloat32_t svcvtx_f32_f64_m(svfloat32_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtx_f32_f64_x)))
+svfloat32_t svcvtx_f32_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtx_f32_f64_z)))
+svfloat32_t svcvtx_f32_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtxnt_f32_f64_m)))
+svfloat32_t svcvtxnt_f32_f64_m(svfloat32_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u8)))
+svuint8_t sveor3_n_u8(svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u32)))
+svuint32_t sveor3_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u64)))
+svuint64_t sveor3_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u16)))
+svuint16_t sveor3_n_u16(svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s8)))
+svint8_t sveor3_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s32)))
+svint32_t sveor3_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s64)))
+svint64_t sveor3_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s16)))
+svint16_t sveor3_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u8)))
+svuint8_t sveor3_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u32)))
+svuint32_t sveor3_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u64)))
+svuint64_t sveor3_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u16)))
+svuint16_t sveor3_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s8)))
+svint8_t sveor3_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s32)))
+svint32_t sveor3_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s64)))
+svint64_t sveor3_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s16)))
+svint16_t sveor3_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u8)))
+svuint8_t sveorbt_n_u8(svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u32)))
+svuint32_t sveorbt_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u64)))
+svuint64_t sveorbt_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u16)))
+svuint16_t sveorbt_n_u16(svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s8)))
+svint8_t sveorbt_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s32)))
+svint32_t sveorbt_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s64)))
+svint64_t sveorbt_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s16)))
+svint16_t sveorbt_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u8)))
+svuint8_t sveorbt_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u32)))
+svuint32_t sveorbt_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u64)))
+svuint64_t sveorbt_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u16)))
+svuint16_t sveorbt_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s8)))
+svint8_t sveorbt_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s32)))
+svint32_t sveorbt_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s64)))
+svint64_t sveorbt_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s16)))
+svint16_t sveorbt_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u8)))
+svuint8_t sveortb_n_u8(svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u32)))
+svuint32_t sveortb_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u64)))
+svuint64_t sveortb_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u16)))
+svuint16_t sveortb_n_u16(svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s8)))
+svint8_t sveortb_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s32)))
+svint32_t sveortb_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s64)))
+svint64_t sveortb_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s16)))
+svint16_t sveortb_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u8)))
+svuint8_t sveortb_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u32)))
+svuint32_t sveortb_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u64)))
+svuint64_t sveortb_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u16)))
+svuint16_t sveortb_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s8)))
+svint8_t sveortb_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s32)))
+svint32_t sveortb_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s64)))
+svint64_t sveortb_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s16)))
+svint16_t sveortb_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s8_m)))
+svint8_t svhadd_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s32_m)))
+svint32_t svhadd_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s64_m)))
+svint64_t svhadd_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s16_m)))
+svint16_t svhadd_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s8_x)))
+svint8_t svhadd_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s32_x)))
+svint32_t svhadd_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s64_x)))
+svint64_t svhadd_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s16_x)))
+svint16_t svhadd_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s8_z)))
+svint8_t svhadd_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s32_z)))
+svint32_t svhadd_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s64_z)))
+svint64_t svhadd_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s16_z)))
+svint16_t svhadd_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u8_m)))
+svuint8_t svhadd_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u32_m)))
+svuint32_t svhadd_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u64_m)))
+svuint64_t svhadd_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u16_m)))
+svuint16_t svhadd_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u8_x)))
+svuint8_t svhadd_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u32_x)))
+svuint32_t svhadd_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u64_x)))
+svuint64_t svhadd_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u16_x)))
+svuint16_t svhadd_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u8_z)))
+svuint8_t svhadd_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u32_z)))
+svuint32_t svhadd_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u64_z)))
+svuint64_t svhadd_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u16_z)))
+svuint16_t svhadd_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s8_m)))
+svint8_t svhadd_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s32_m)))
+svint32_t svhadd_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s64_m)))
+svint64_t svhadd_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s16_m)))
+svint16_t svhadd_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s8_x)))
+svint8_t svhadd_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s32_x)))
+svint32_t svhadd_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s64_x)))
+svint64_t svhadd_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s16_x)))
+svint16_t svhadd_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s8_z)))
+svint8_t svhadd_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s32_z)))
+svint32_t svhadd_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s64_z)))
+svint64_t svhadd_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s16_z)))
+svint16_t svhadd_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u8_m)))
+svuint8_t svhadd_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u32_m)))
+svuint32_t svhadd_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u64_m)))
+svuint64_t svhadd_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u16_m)))
+svuint16_t svhadd_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u8_x)))
+svuint8_t svhadd_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u32_x)))
+svuint32_t svhadd_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u64_x)))
+svuint64_t svhadd_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u16_x)))
+svuint16_t svhadd_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u8_z)))
+svuint8_t svhadd_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u32_z)))
+svuint32_t svhadd_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u64_z)))
+svuint64_t svhadd_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u16_z)))
+svuint16_t svhadd_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s8_m)))
+svint8_t svhsub_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s32_m)))
+svint32_t svhsub_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s64_m)))
+svint64_t svhsub_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s16_m)))
+svint16_t svhsub_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s8_x)))
+svint8_t svhsub_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s32_x)))
+svint32_t svhsub_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s64_x)))
+svint64_t svhsub_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s16_x)))
+svint16_t svhsub_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s8_z)))
+svint8_t svhsub_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s32_z)))
+svint32_t svhsub_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s64_z)))
+svint64_t svhsub_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s16_z)))
+svint16_t svhsub_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u8_m)))
+svuint8_t svhsub_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u32_m)))
+svuint32_t svhsub_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u64_m)))
+svuint64_t svhsub_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u16_m)))
+svuint16_t svhsub_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u8_x)))
+svuint8_t svhsub_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u32_x)))
+svuint32_t svhsub_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u64_x)))
+svuint64_t svhsub_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u16_x)))
+svuint16_t svhsub_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u8_z)))
+svuint8_t svhsub_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u32_z)))
+svuint32_t svhsub_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u64_z)))
+svuint64_t svhsub_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u16_z)))
+svuint16_t svhsub_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s8_m)))
+svint8_t svhsub_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s32_m)))
+svint32_t svhsub_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s64_m)))
+svint64_t svhsub_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s16_m)))
+svint16_t svhsub_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s8_x)))
+svint8_t svhsub_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s32_x)))
+svint32_t svhsub_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s64_x)))
+svint64_t svhsub_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s16_x)))
+svint16_t svhsub_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s8_z)))
+svint8_t svhsub_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s32_z)))
+svint32_t svhsub_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s64_z)))
+svint64_t svhsub_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s16_z)))
+svint16_t svhsub_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u8_m)))
+svuint8_t svhsub_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u32_m)))
+svuint32_t svhsub_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u64_m)))
+svuint64_t svhsub_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u16_m)))
+svuint16_t svhsub_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u8_x)))
+svuint8_t svhsub_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u32_x)))
+svuint32_t svhsub_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u64_x)))
+svuint64_t svhsub_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u16_x)))
+svuint16_t svhsub_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u8_z)))
+svuint8_t svhsub_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u32_z)))
+svuint32_t svhsub_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u64_z)))
+svuint64_t svhsub_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u16_z)))
+svuint16_t svhsub_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s8_m)))
+svint8_t svhsubr_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s32_m)))
+svint32_t svhsubr_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s64_m)))
+svint64_t svhsubr_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s16_m)))
+svint16_t svhsubr_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s8_x)))
+svint8_t svhsubr_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s32_x)))
+svint32_t svhsubr_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s64_x)))
+svint64_t svhsubr_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s16_x)))
+svint16_t svhsubr_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s8_z)))
+svint8_t svhsubr_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s32_z)))
+svint32_t svhsubr_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s64_z)))
+svint64_t svhsubr_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s16_z)))
+svint16_t svhsubr_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u8_m)))
+svuint8_t svhsubr_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u32_m)))
+svuint32_t svhsubr_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u64_m)))
+svuint64_t svhsubr_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u16_m)))
+svuint16_t svhsubr_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u8_x)))
+svuint8_t svhsubr_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u32_x)))
+svuint32_t svhsubr_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u64_x)))
+svuint64_t svhsubr_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u16_x)))
+svuint16_t svhsubr_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u8_z)))
+svuint8_t svhsubr_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u32_z)))
+svuint32_t svhsubr_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u64_z)))
+svuint64_t svhsubr_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u16_z)))
+svuint16_t svhsubr_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s8_m)))
+svint8_t svhsubr_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s32_m)))
+svint32_t svhsubr_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s64_m)))
+svint64_t svhsubr_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s16_m)))
+svint16_t svhsubr_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s8_x)))
+svint8_t svhsubr_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s32_x)))
+svint32_t svhsubr_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s64_x)))
+svint64_t svhsubr_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s16_x)))
+svint16_t svhsubr_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s8_z)))
+svint8_t svhsubr_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s32_z)))
+svint32_t svhsubr_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s64_z)))
+svint64_t svhsubr_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s16_z)))
+svint16_t svhsubr_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u8_m)))
+svuint8_t svhsubr_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u32_m)))
+svuint32_t svhsubr_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u64_m)))
+svuint64_t svhsubr_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u16_m)))
+svuint16_t svhsubr_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u8_x)))
+svuint8_t svhsubr_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u32_x)))
+svuint32_t svhsubr_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u64_x)))
+svuint64_t svhsubr_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u16_x)))
+svuint16_t svhsubr_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u8_z)))
+svuint8_t svhsubr_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u32_z)))
+svuint32_t svhsubr_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u64_z)))
+svuint64_t svhsubr_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u16_z)))
+svuint16_t svhsubr_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f64_m)))
+svint64_t svlogb_f64_m(svint64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f32_m)))
+svint32_t svlogb_f32_m(svint32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f16_m)))
+svint16_t svlogb_f16_m(svint16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f64_x)))
+svint64_t svlogb_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f32_x)))
+svint32_t svlogb_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f16_x)))
+svint16_t svlogb_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f64_z)))
+svint64_t svlogb_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f32_z)))
+svint32_t svlogb_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f16_z)))
+svint16_t svlogb_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f64_m)))
+svfloat64_t svmaxnmp_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f32_m)))
+svfloat32_t svmaxnmp_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f16_m)))
+svfloat16_t svmaxnmp_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f64_x)))
+svfloat64_t svmaxnmp_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f32_x)))
+svfloat32_t svmaxnmp_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f16_x)))
+svfloat16_t svmaxnmp_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f64_m)))
+svfloat64_t svmaxp_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f32_m)))
+svfloat32_t svmaxp_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f16_m)))
+svfloat16_t svmaxp_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f64_x)))
+svfloat64_t svmaxp_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f32_x)))
+svfloat32_t svmaxp_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f16_x)))
+svfloat16_t svmaxp_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s8_m)))
+svint8_t svmaxp_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s32_m)))
+svint32_t svmaxp_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s64_m)))
+svint64_t svmaxp_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s16_m)))
+svint16_t svmaxp_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s8_x)))
+svint8_t svmaxp_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s32_x)))
+svint32_t svmaxp_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s64_x)))
+svint64_t svmaxp_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s16_x)))
+svint16_t svmaxp_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u8_m)))
+svuint8_t svmaxp_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u32_m)))
+svuint32_t svmaxp_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u64_m)))
+svuint64_t svmaxp_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u16_m)))
+svuint16_t svmaxp_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u8_x)))
+svuint8_t svmaxp_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u32_x)))
+svuint32_t svmaxp_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u64_x)))
+svuint64_t svmaxp_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u16_x)))
+svuint16_t svmaxp_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f64_m)))
+svfloat64_t svminnmp_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f32_m)))
+svfloat32_t svminnmp_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f16_m)))
+svfloat16_t svminnmp_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f64_x)))
+svfloat64_t svminnmp_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f32_x)))
+svfloat32_t svminnmp_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f16_x)))
+svfloat16_t svminnmp_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f64_m)))
+svfloat64_t svminp_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f32_m)))
+svfloat32_t svminp_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f16_m)))
+svfloat16_t svminp_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f64_x)))
+svfloat64_t svminp_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f32_x)))
+svfloat32_t svminp_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f16_x)))
+svfloat16_t svminp_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s8_m)))
+svint8_t svminp_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s32_m)))
+svint32_t svminp_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s64_m)))
+svint64_t svminp_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s16_m)))
+svint16_t svminp_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s8_x)))
+svint8_t svminp_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s32_x)))
+svint32_t svminp_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s64_x)))
+svint64_t svminp_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s16_x)))
+svint16_t svminp_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u8_m)))
+svuint8_t svminp_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u32_m)))
+svuint32_t svminp_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u64_m)))
+svuint64_t svminp_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u16_m)))
+svuint16_t svminp_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u8_x)))
+svuint8_t svminp_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u32_x)))
+svuint32_t svminp_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u64_x)))
+svuint64_t svminp_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u16_x)))
+svuint16_t svminp_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_u32)))
+svuint32_t svmla_lane_u32(svuint32_t, svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_u64)))
+svuint64_t svmla_lane_u64(svuint64_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_u16)))
+svuint16_t svmla_lane_u16(svuint16_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_s32)))
+svint32_t svmla_lane_s32(svint32_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_s64)))
+svint64_t svmla_lane_s64(svint64_t, svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_s16)))
+svint16_t svmla_lane_s16(svint16_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_f32)))
+svfloat32_t svmlalb_n_f32(svfloat32_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_s32)))
+svint32_t svmlalb_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_s64)))
+svint64_t svmlalb_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_s16)))
+svint16_t svmlalb_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_u32)))
+svuint32_t svmlalb_n_u32(svuint32_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_u64)))
+svuint64_t svmlalb_n_u64(svuint64_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_u16)))
+svuint16_t svmlalb_n_u16(svuint16_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_f32)))
+svfloat32_t svmlalb_f32(svfloat32_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_s32)))
+svint32_t svmlalb_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_s64)))
+svint64_t svmlalb_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_s16)))
+svint16_t svmlalb_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_u32)))
+svuint32_t svmlalb_u32(svuint32_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_u64)))
+svuint64_t svmlalb_u64(svuint64_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_u16)))
+svuint16_t svmlalb_u16(svuint16_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_f32)))
+svfloat32_t svmlalb_lane_f32(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_s32)))
+svint32_t svmlalb_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_s64)))
+svint64_t svmlalb_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_u32)))
+svuint32_t svmlalb_lane_u32(svuint32_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_u64)))
+svuint64_t svmlalb_lane_u64(svuint64_t, svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_f32)))
+svfloat32_t svmlalt_n_f32(svfloat32_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_s32)))
+svint32_t svmlalt_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_s64)))
+svint64_t svmlalt_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_s16)))
+svint16_t svmlalt_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_u32)))
+svuint32_t svmlalt_n_u32(svuint32_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_u64)))
+svuint64_t svmlalt_n_u64(svuint64_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_u16)))
+svuint16_t svmlalt_n_u16(svuint16_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_f32)))
+svfloat32_t svmlalt_f32(svfloat32_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_s32)))
+svint32_t svmlalt_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_s64)))
+svint64_t svmlalt_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_s16)))
+svint16_t svmlalt_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_u32)))
+svuint32_t svmlalt_u32(svuint32_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_u64)))
+svuint64_t svmlalt_u64(svuint64_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_u16)))
+svuint16_t svmlalt_u16(svuint16_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_f32)))
+svfloat32_t svmlalt_lane_f32(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_s32)))
+svint32_t svmlalt_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_s64)))
+svint64_t svmlalt_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_u32)))
+svuint32_t svmlalt_lane_u32(svuint32_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_u64)))
+svuint64_t svmlalt_lane_u64(svuint64_t, svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_u32)))
+svuint32_t svmls_lane_u32(svuint32_t, svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_u64)))
+svuint64_t svmls_lane_u64(svuint64_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_u16)))
+svuint16_t svmls_lane_u16(svuint16_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_s32)))
+svint32_t svmls_lane_s32(svint32_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_s64)))
+svint64_t svmls_lane_s64(svint64_t, svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_s16)))
+svint16_t svmls_lane_s16(svint16_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_f32)))
+svfloat32_t svmlslb_n_f32(svfloat32_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_s32)))
+svint32_t svmlslb_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_s64)))
+svint64_t svmlslb_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_s16)))
+svint16_t svmlslb_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_u32)))
+svuint32_t svmlslb_n_u32(svuint32_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_u64)))
+svuint64_t svmlslb_n_u64(svuint64_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_u16)))
+svuint16_t svmlslb_n_u16(svuint16_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_f32)))
+svfloat32_t svmlslb_f32(svfloat32_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_s32)))
+svint32_t svmlslb_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_s64)))
+svint64_t svmlslb_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_s16)))
+svint16_t svmlslb_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_u32)))
+svuint32_t svmlslb_u32(svuint32_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_u64)))
+svuint64_t svmlslb_u64(svuint64_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_u16)))
+svuint16_t svmlslb_u16(svuint16_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_f32)))
+svfloat32_t svmlslb_lane_f32(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_s32)))
+svint32_t svmlslb_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_s64)))
+svint64_t svmlslb_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_u32)))
+svuint32_t svmlslb_lane_u32(svuint32_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_u64)))
+svuint64_t svmlslb_lane_u64(svuint64_t, svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_f32)))
+svfloat32_t svmlslt_n_f32(svfloat32_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_s32)))
+svint32_t svmlslt_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_s64)))
+svint64_t svmlslt_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_s16)))
+svint16_t svmlslt_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_u32)))
+svuint32_t svmlslt_n_u32(svuint32_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_u64)))
+svuint64_t svmlslt_n_u64(svuint64_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_u16)))
+svuint16_t svmlslt_n_u16(svuint16_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_f32)))
+svfloat32_t svmlslt_f32(svfloat32_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_s32)))
+svint32_t svmlslt_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_s64)))
+svint64_t svmlslt_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_s16)))
+svint16_t svmlslt_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_u32)))
+svuint32_t svmlslt_u32(svuint32_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_u64)))
+svuint64_t svmlslt_u64(svuint64_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_u16)))
+svuint16_t svmlslt_u16(svuint16_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_f32)))
+svfloat32_t svmlslt_lane_f32(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_s32)))
+svint32_t svmlslt_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_s64)))
+svint64_t svmlslt_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_u32)))
+svuint32_t svmlslt_lane_u32(svuint32_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_u64)))
+svuint64_t svmlslt_lane_u64(svuint64_t, svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_s32)))
+svint32_t svmovlb_s32(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_s64)))
+svint64_t svmovlb_s64(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_s16)))
+svint16_t svmovlb_s16(svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_u32)))
+svuint32_t svmovlb_u32(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_u64)))
+svuint64_t svmovlb_u64(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_u16)))
+svuint16_t svmovlb_u16(svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_s32)))
+svint32_t svmovlt_s32(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_s64)))
+svint64_t svmovlt_s64(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_s16)))
+svint16_t svmovlt_s16(svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_u32)))
+svuint32_t svmovlt_u32(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_u64)))
+svuint64_t svmovlt_u64(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_u16)))
+svuint16_t svmovlt_u16(svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_u32)))
+svuint32_t svmul_lane_u32(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_u64)))
+svuint64_t svmul_lane_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_u16)))
+svuint16_t svmul_lane_u16(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_s32)))
+svint32_t svmul_lane_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_s64)))
+svint64_t svmul_lane_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_s16)))
+svint16_t svmul_lane_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_s32)))
+svint32_t svmullb_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_s64)))
+svint64_t svmullb_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_s16)))
+svint16_t svmullb_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_u32)))
+svuint32_t svmullb_n_u32(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_u64)))
+svuint64_t svmullb_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_u16)))
+svuint16_t svmullb_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_s32)))
+svint32_t svmullb_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_s64)))
+svint64_t svmullb_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_s16)))
+svint16_t svmullb_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_u32)))
+svuint32_t svmullb_u32(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_u64)))
+svuint64_t svmullb_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_u16)))
+svuint16_t svmullb_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_s32)))
+svint32_t svmullb_lane_s32(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_s64)))
+svint64_t svmullb_lane_s64(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_u32)))
+svuint32_t svmullb_lane_u32(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_u64)))
+svuint64_t svmullb_lane_u64(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_s32)))
+svint32_t svmullt_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_s64)))
+svint64_t svmullt_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_s16)))
+svint16_t svmullt_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_u32)))
+svuint32_t svmullt_n_u32(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_u64)))
+svuint64_t svmullt_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_u16)))
+svuint16_t svmullt_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_s32)))
+svint32_t svmullt_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_s64)))
+svint64_t svmullt_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_s16)))
+svint16_t svmullt_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_u32)))
+svuint32_t svmullt_u32(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_u64)))
+svuint64_t svmullt_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_u16)))
+svuint16_t svmullt_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_s32)))
+svint32_t svmullt_lane_s32(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_s64)))
+svint64_t svmullt_lane_s64(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_u32)))
+svuint32_t svmullt_lane_u32(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_u64)))
+svuint64_t svmullt_lane_u64(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u8)))
+svuint8_t svnbsl_n_u8(svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u32)))
+svuint32_t svnbsl_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u64)))
+svuint64_t svnbsl_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u16)))
+svuint16_t svnbsl_n_u16(svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s8)))
+svint8_t svnbsl_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s32)))
+svint32_t svnbsl_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s64)))
+svint64_t svnbsl_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s16)))
+svint16_t svnbsl_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u8)))
+svuint8_t svnbsl_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u32)))
+svuint32_t svnbsl_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u64)))
+svuint64_t svnbsl_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u16)))
+svuint16_t svnbsl_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s8)))
+svint8_t svnbsl_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s32)))
+svint32_t svnbsl_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s64)))
+svint64_t svnbsl_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s16)))
+svint16_t svnbsl_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmul_n_u8)))
+svuint8_t svpmul_n_u8(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmul_u8)))
+svuint8_t svpmul_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_n_u64)))
+svuint64_t svpmullb_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_n_u16)))
+svuint16_t svpmullb_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_u64)))
+svuint64_t svpmullb_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_u16)))
+svuint16_t svpmullb_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_n_u8)))
+svuint8_t svpmullb_pair_n_u8(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_n_u32)))
+svuint32_t svpmullb_pair_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_u8)))
+svuint8_t svpmullb_pair_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_u32)))
+svuint32_t svpmullb_pair_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_n_u64)))
+svuint64_t svpmullt_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_n_u16)))
+svuint16_t svpmullt_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_u64)))
+svuint64_t svpmullt_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_u16)))
+svuint16_t svpmullt_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_n_u8)))
+svuint8_t svpmullt_pair_n_u8(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_n_u32)))
+svuint32_t svpmullt_pair_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_u8)))
+svuint8_t svpmullt_pair_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_u32)))
+svuint32_t svpmullt_pair_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s8_m)))
+svint8_t svqabs_s8_m(svint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s32_m)))
+svint32_t svqabs_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s64_m)))
+svint64_t svqabs_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s16_m)))
+svint16_t svqabs_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s8_x)))
+svint8_t svqabs_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s32_x)))
+svint32_t svqabs_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s64_x)))
+svint64_t svqabs_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s16_x)))
+svint16_t svqabs_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s8_z)))
+svint8_t svqabs_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s32_z)))
+svint32_t svqabs_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s64_z)))
+svint64_t svqabs_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s16_z)))
+svint16_t svqabs_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8_m)))
+svint8_t svqadd_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32_m)))
+svint32_t svqadd_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64_m)))
+svint64_t svqadd_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16_m)))
+svint16_t svqadd_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8_x)))
+svint8_t svqadd_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32_x)))
+svint32_t svqadd_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64_x)))
+svint64_t svqadd_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16_x)))
+svint16_t svqadd_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8_z)))
+svint8_t svqadd_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32_z)))
+svint32_t svqadd_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64_z)))
+svint64_t svqadd_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16_z)))
+svint16_t svqadd_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8_m)))
+svuint8_t svqadd_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32_m)))
+svuint32_t svqadd_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64_m)))
+svuint64_t svqadd_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16_m)))
+svuint16_t svqadd_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8_x)))
+svuint8_t svqadd_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32_x)))
+svuint32_t svqadd_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64_x)))
+svuint64_t svqadd_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16_x)))
+svuint16_t svqadd_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8_z)))
+svuint8_t svqadd_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32_z)))
+svuint32_t svqadd_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64_z)))
+svuint64_t svqadd_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16_z)))
+svuint16_t svqadd_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8_m)))
+svint8_t svqadd_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32_m)))
+svint32_t svqadd_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64_m)))
+svint64_t svqadd_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16_m)))
+svint16_t svqadd_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8_x)))
+svint8_t svqadd_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32_x)))
+svint32_t svqadd_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64_x)))
+svint64_t svqadd_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16_x)))
+svint16_t svqadd_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8_z)))
+svint8_t svqadd_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32_z)))
+svint32_t svqadd_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64_z)))
+svint64_t svqadd_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16_z)))
+svint16_t svqadd_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8_m)))
+svuint8_t svqadd_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32_m)))
+svuint32_t svqadd_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64_m)))
+svuint64_t svqadd_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16_m)))
+svuint16_t svqadd_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8_x)))
+svuint8_t svqadd_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32_x)))
+svuint32_t svqadd_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64_x)))
+svuint64_t svqadd_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16_x)))
+svuint16_t svqadd_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8_z)))
+svuint8_t svqadd_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32_z)))
+svuint32_t svqadd_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64_z)))
+svuint64_t svqadd_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16_z)))
+svuint16_t svqadd_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s8)))
+svint8_t svqcadd_s8(svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s32)))
+svint32_t svqcadd_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s64)))
+svint64_t svqcadd_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s16)))
+svint16_t svqcadd_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_n_s32)))
+svint32_t svqdmlalb_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_n_s64)))
+svint64_t svqdmlalb_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_n_s16)))
+svint16_t svqdmlalb_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_s32)))
+svint32_t svqdmlalb_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_s64)))
+svint64_t svqdmlalb_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_s16)))
+svint16_t svqdmlalb_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_lane_s32)))
+svint32_t svqdmlalb_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_lane_s64)))
+svint64_t svqdmlalb_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_n_s32)))
+svint32_t svqdmlalbt_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_n_s64)))
+svint64_t svqdmlalbt_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_n_s16)))
+svint16_t svqdmlalbt_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_s32)))
+svint32_t svqdmlalbt_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_s64)))
+svint64_t svqdmlalbt_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_s16)))
+svint16_t svqdmlalbt_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_n_s32)))
+svint32_t svqdmlalt_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_n_s64)))
+svint64_t svqdmlalt_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_n_s16)))
+svint16_t svqdmlalt_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_s32)))
+svint32_t svqdmlalt_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_s64)))
+svint64_t svqdmlalt_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_s16)))
+svint16_t svqdmlalt_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_lane_s32)))
+svint32_t svqdmlalt_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_lane_s64)))
+svint64_t svqdmlalt_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_n_s32)))
+svint32_t svqdmlslb_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_n_s64)))
+svint64_t svqdmlslb_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_n_s16)))
+svint16_t svqdmlslb_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_s32)))
+svint32_t svqdmlslb_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_s64)))
+svint64_t svqdmlslb_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_s16)))
+svint16_t svqdmlslb_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_lane_s32)))
+svint32_t svqdmlslb_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_lane_s64)))
+svint64_t svqdmlslb_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_n_s32)))
+svint32_t svqdmlslbt_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_n_s64)))
+svint64_t svqdmlslbt_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_n_s16)))
+svint16_t svqdmlslbt_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_s32)))
+svint32_t svqdmlslbt_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_s64)))
+svint64_t svqdmlslbt_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_s16)))
+svint16_t svqdmlslbt_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_n_s32)))
+svint32_t svqdmlslt_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_n_s64)))
+svint64_t svqdmlslt_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_n_s16)))
+svint16_t svqdmlslt_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_s32)))
+svint32_t svqdmlslt_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_s64)))
+svint64_t svqdmlslt_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_s16)))
+svint16_t svqdmlslt_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_lane_s32)))
+svint32_t svqdmlslt_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_lane_s64)))
+svint64_t svqdmlslt_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s8)))
+svint8_t svqdmulh_n_s8(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s32)))
+svint32_t svqdmulh_n_s32(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s64)))
+svint64_t svqdmulh_n_s64(svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s16)))
+svint16_t svqdmulh_n_s16(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s8)))
+svint8_t svqdmulh_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s32)))
+svint32_t svqdmulh_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s64)))
+svint64_t svqdmulh_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s16)))
+svint16_t svqdmulh_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_lane_s32)))
+svint32_t svqdmulh_lane_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_lane_s64)))
+svint64_t svqdmulh_lane_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_lane_s16)))
+svint16_t svqdmulh_lane_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_n_s32)))
+svint32_t svqdmullb_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_n_s64)))
+svint64_t svqdmullb_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_n_s16)))
+svint16_t svqdmullb_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_s32)))
+svint32_t svqdmullb_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_s64)))
+svint64_t svqdmullb_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_s16)))
+svint16_t svqdmullb_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_lane_s32)))
+svint32_t svqdmullb_lane_s32(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_lane_s64)))
+svint64_t svqdmullb_lane_s64(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_n_s32)))
+svint32_t svqdmullt_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_n_s64)))
+svint64_t svqdmullt_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_n_s16)))
+svint16_t svqdmullt_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_s32)))
+svint32_t svqdmullt_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_s64)))
+svint64_t svqdmullt_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_s16)))
+svint16_t svqdmullt_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_lane_s32)))
+svint32_t svqdmullt_lane_s32(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_lane_s64)))
+svint64_t svqdmullt_lane_s64(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s8_m)))
+svint8_t svqneg_s8_m(svint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s32_m)))
+svint32_t svqneg_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s64_m)))
+svint64_t svqneg_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s16_m)))
+svint16_t svqneg_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s8_x)))
+svint8_t svqneg_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s32_x)))
+svint32_t svqneg_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s64_x)))
+svint64_t svqneg_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s16_x)))
+svint16_t svqneg_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s8_z)))
+svint8_t svqneg_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s32_z)))
+svint32_t svqneg_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s64_z)))
+svint64_t svqneg_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s16_z)))
+svint16_t svqneg_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s8)))
+svint8_t svqrdcmlah_s8(svint8_t, svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s32)))
+svint32_t svqrdcmlah_s32(svint32_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s64)))
+svint64_t svqrdcmlah_s64(svint64_t, svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s16)))
+svint16_t svqrdcmlah_s16(svint16_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_lane_s32)))
+svint32_t svqrdcmlah_lane_s32(svint32_t, svint32_t, svint32_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_lane_s16)))
+svint16_t svqrdcmlah_lane_s16(svint16_t, svint16_t, svint16_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s8)))
+svint8_t svqrdmlah_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s32)))
+svint32_t svqrdmlah_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s64)))
+svint64_t svqrdmlah_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s16)))
+svint16_t svqrdmlah_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s8)))
+svint8_t svqrdmlah_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s32)))
+svint32_t svqrdmlah_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s64)))
+svint64_t svqrdmlah_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s16)))
+svint16_t svqrdmlah_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_lane_s32)))
+svint32_t svqrdmlah_lane_s32(svint32_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_lane_s64)))
+svint64_t svqrdmlah_lane_s64(svint64_t, svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_lane_s16)))
+svint16_t svqrdmlah_lane_s16(svint16_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s8)))
+svint8_t svqrdmlsh_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s32)))
+svint32_t svqrdmlsh_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s64)))
+svint64_t svqrdmlsh_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s16)))
+svint16_t svqrdmlsh_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s8)))
+svint8_t svqrdmlsh_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s32)))
+svint32_t svqrdmlsh_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s64)))
+svint64_t svqrdmlsh_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s16)))
+svint16_t svqrdmlsh_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_lane_s32)))
+svint32_t svqrdmlsh_lane_s32(svint32_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_lane_s64)))
+svint64_t svqrdmlsh_lane_s64(svint64_t, svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_lane_s16)))
+svint16_t svqrdmlsh_lane_s16(svint16_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s8)))
+svint8_t svqrdmulh_n_s8(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s32)))
+svint32_t svqrdmulh_n_s32(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s64)))
+svint64_t svqrdmulh_n_s64(svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s16)))
+svint16_t svqrdmulh_n_s16(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s8)))
+svint8_t svqrdmulh_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s32)))
+svint32_t svqrdmulh_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s64)))
+svint64_t svqrdmulh_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s16)))
+svint16_t svqrdmulh_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_lane_s32)))
+svint32_t svqrdmulh_lane_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_lane_s64)))
+svint64_t svqrdmulh_lane_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_lane_s16)))
+svint16_t svqrdmulh_lane_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s8_m)))
+svint8_t svqrshl_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s32_m)))
+svint32_t svqrshl_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s64_m)))
+svint64_t svqrshl_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s16_m)))
+svint16_t svqrshl_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s8_x)))
+svint8_t svqrshl_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s32_x)))
+svint32_t svqrshl_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s64_x)))
+svint64_t svqrshl_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s16_x)))
+svint16_t svqrshl_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s8_z)))
+svint8_t svqrshl_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s32_z)))
+svint32_t svqrshl_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s64_z)))
+svint64_t svqrshl_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s16_z)))
+svint16_t svqrshl_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u8_m)))
+svuint8_t svqrshl_n_u8_m(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u32_m)))
+svuint32_t svqrshl_n_u32_m(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u64_m)))
+svuint64_t svqrshl_n_u64_m(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u16_m)))
+svuint16_t svqrshl_n_u16_m(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u8_x)))
+svuint8_t svqrshl_n_u8_x(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u32_x)))
+svuint32_t svqrshl_n_u32_x(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u64_x)))
+svuint64_t svqrshl_n_u64_x(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u16_x)))
+svuint16_t svqrshl_n_u16_x(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u8_z)))
+svuint8_t svqrshl_n_u8_z(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u32_z)))
+svuint32_t svqrshl_n_u32_z(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u64_z)))
+svuint64_t svqrshl_n_u64_z(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u16_z)))
+svuint16_t svqrshl_n_u16_z(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s8_m)))
+svint8_t svqrshl_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s32_m)))
+svint32_t svqrshl_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s64_m)))
+svint64_t svqrshl_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s16_m)))
+svint16_t svqrshl_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s8_x)))
+svint8_t svqrshl_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s32_x)))
+svint32_t svqrshl_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s64_x)))
+svint64_t svqrshl_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s16_x)))
+svint16_t svqrshl_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s8_z)))
+svint8_t svqrshl_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s32_z)))
+svint32_t svqrshl_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s64_z)))
+svint64_t svqrshl_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s16_z)))
+svint16_t svqrshl_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u8_m)))
+svuint8_t svqrshl_u8_m(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u32_m)))
+svuint32_t svqrshl_u32_m(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u64_m)))
+svuint64_t svqrshl_u64_m(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u16_m)))
+svuint16_t svqrshl_u16_m(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u8_x)))
+svuint8_t svqrshl_u8_x(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u32_x)))
+svuint32_t svqrshl_u32_x(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u64_x)))
+svuint64_t svqrshl_u64_x(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u16_x)))
+svuint16_t svqrshl_u16_x(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u8_z)))
+svuint8_t svqrshl_u8_z(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u32_z)))
+svuint32_t svqrshl_u32_z(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u64_z)))
+svuint64_t svqrshl_u64_z(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u16_z)))
+svuint16_t svqrshl_u16_z(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_s32)))
+svint16_t svqrshrnb_n_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_s64)))
+svint32_t svqrshrnb_n_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_s16)))
+svint8_t svqrshrnb_n_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_u32)))
+svuint16_t svqrshrnb_n_u32(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_u64)))
+svuint32_t svqrshrnb_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_u16)))
+svuint8_t svqrshrnb_n_u16(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_s32)))
+svint16_t svqrshrnt_n_s32(svint16_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_s64)))
+svint32_t svqrshrnt_n_s64(svint32_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_s16)))
+svint8_t svqrshrnt_n_s16(svint8_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_u32)))
+svuint16_t svqrshrnt_n_u32(svuint16_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_u64)))
+svuint32_t svqrshrnt_n_u64(svuint32_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_u16)))
+svuint8_t svqrshrnt_n_u16(svuint8_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunb_n_s32)))
+svuint16_t svqrshrunb_n_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunb_n_s64)))
+svuint32_t svqrshrunb_n_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunb_n_s16)))
+svuint8_t svqrshrunb_n_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunt_n_s32)))
+svuint16_t svqrshrunt_n_s32(svuint16_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunt_n_s64)))
+svuint32_t svqrshrunt_n_s64(svuint32_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunt_n_s16)))
+svuint8_t svqrshrunt_n_s16(svuint8_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s8_m)))
+svint8_t svqshl_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s32_m)))
+svint32_t svqshl_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s64_m)))
+svint64_t svqshl_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s16_m)))
+svint16_t svqshl_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s8_x)))
+svint8_t svqshl_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s32_x)))
+svint32_t svqshl_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s64_x)))
+svint64_t svqshl_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s16_x)))
+svint16_t svqshl_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s8_z)))
+svint8_t svqshl_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s32_z)))
+svint32_t svqshl_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s64_z)))
+svint64_t svqshl_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s16_z)))
+svint16_t svqshl_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u8_m)))
+svuint8_t svqshl_n_u8_m(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u32_m)))
+svuint32_t svqshl_n_u32_m(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u64_m)))
+svuint64_t svqshl_n_u64_m(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u16_m)))
+svuint16_t svqshl_n_u16_m(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u8_x)))
+svuint8_t svqshl_n_u8_x(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u32_x)))
+svuint32_t svqshl_n_u32_x(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u64_x)))
+svuint64_t svqshl_n_u64_x(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u16_x)))
+svuint16_t svqshl_n_u16_x(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u8_z)))
+svuint8_t svqshl_n_u8_z(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u32_z)))
+svuint32_t svqshl_n_u32_z(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u64_z)))
+svuint64_t svqshl_n_u64_z(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u16_z)))
+svuint16_t svqshl_n_u16_z(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s8_m)))
+svint8_t svqshl_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s32_m)))
+svint32_t svqshl_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s64_m)))
+svint64_t svqshl_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s16_m)))
+svint16_t svqshl_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s8_x)))
+svint8_t svqshl_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s32_x)))
+svint32_t svqshl_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s64_x)))
+svint64_t svqshl_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s16_x)))
+svint16_t svqshl_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s8_z)))
+svint8_t svqshl_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s32_z)))
+svint32_t svqshl_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s64_z)))
+svint64_t svqshl_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s16_z)))
+svint16_t svqshl_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u8_m)))
+svuint8_t svqshl_u8_m(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u32_m)))
+svuint32_t svqshl_u32_m(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u64_m)))
+svuint64_t svqshl_u64_m(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u16_m)))
+svuint16_t svqshl_u16_m(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u8_x)))
+svuint8_t svqshl_u8_x(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u32_x)))
+svuint32_t svqshl_u32_x(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u64_x)))
+svuint64_t svqshl_u64_x(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u16_x)))
+svuint16_t svqshl_u16_x(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u8_z)))
+svuint8_t svqshl_u8_z(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u32_z)))
+svuint32_t svqshl_u32_z(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u64_z)))
+svuint64_t svqshl_u64_z(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u16_z)))
+svuint16_t svqshl_u16_z(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s8_m)))
+svuint8_t svqshlu_n_s8_m(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s32_m)))
+svuint32_t svqshlu_n_s32_m(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s64_m)))
+svuint64_t svqshlu_n_s64_m(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s16_m)))
+svuint16_t svqshlu_n_s16_m(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s8_x)))
+svuint8_t svqshlu_n_s8_x(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s32_x)))
+svuint32_t svqshlu_n_s32_x(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s64_x)))
+svuint64_t svqshlu_n_s64_x(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s16_x)))
+svuint16_t svqshlu_n_s16_x(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s8_z)))
+svuint8_t svqshlu_n_s8_z(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s32_z)))
+svuint32_t svqshlu_n_s32_z(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s64_z)))
+svuint64_t svqshlu_n_s64_z(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s16_z)))
+svuint16_t svqshlu_n_s16_z(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_s32)))
+svint16_t svqshrnb_n_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_s64)))
+svint32_t svqshrnb_n_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_s16)))
+svint8_t svqshrnb_n_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_u32)))
+svuint16_t svqshrnb_n_u32(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_u64)))
+svuint32_t svqshrnb_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_u16)))
+svuint8_t svqshrnb_n_u16(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_s32)))
+svint16_t svqshrnt_n_s32(svint16_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_s64)))
+svint32_t svqshrnt_n_s64(svint32_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_s16)))
+svint8_t svqshrnt_n_s16(svint8_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_u32)))
+svuint16_t svqshrnt_n_u32(svuint16_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_u64)))
+svuint32_t svqshrnt_n_u64(svuint32_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_u16)))
+svuint8_t svqshrnt_n_u16(svuint8_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunb_n_s32)))
+svuint16_t svqshrunb_n_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunb_n_s64)))
+svuint32_t svqshrunb_n_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunb_n_s16)))
+svuint8_t svqshrunb_n_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunt_n_s32)))
+svuint16_t svqshrunt_n_s32(svuint16_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunt_n_s64)))
+svuint32_t svqshrunt_n_s64(svuint32_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunt_n_s16)))
+svuint8_t svqshrunt_n_s16(svuint8_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8_m)))
+svint8_t svqsub_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32_m)))
+svint32_t svqsub_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64_m)))
+svint64_t svqsub_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16_m)))
+svint16_t svqsub_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8_x)))
+svint8_t svqsub_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32_x)))
+svint32_t svqsub_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64_x)))
+svint64_t svqsub_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16_x)))
+svint16_t svqsub_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8_z)))
+svint8_t svqsub_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32_z)))
+svint32_t svqsub_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64_z)))
+svint64_t svqsub_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16_z)))
+svint16_t svqsub_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8_m)))
+svuint8_t svqsub_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32_m)))
+svuint32_t svqsub_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64_m)))
+svuint64_t svqsub_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16_m)))
+svuint16_t svqsub_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8_x)))
+svuint8_t svqsub_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32_x)))
+svuint32_t svqsub_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64_x)))
+svuint64_t svqsub_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16_x)))
+svuint16_t svqsub_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8_z)))
+svuint8_t svqsub_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32_z)))
+svuint32_t svqsub_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64_z)))
+svuint64_t svqsub_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16_z)))
+svuint16_t svqsub_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8_m)))
+svint8_t svqsub_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32_m)))
+svint32_t svqsub_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64_m)))
+svint64_t svqsub_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16_m)))
+svint16_t svqsub_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8_x)))
+svint8_t svqsub_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32_x)))
+svint32_t svqsub_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64_x)))
+svint64_t svqsub_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16_x)))
+svint16_t svqsub_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8_z)))
+svint8_t svqsub_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32_z)))
+svint32_t svqsub_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64_z)))
+svint64_t svqsub_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16_z)))
+svint16_t svqsub_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8_m)))
+svuint8_t svqsub_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32_m)))
+svuint32_t svqsub_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64_m)))
+svuint64_t svqsub_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16_m)))
+svuint16_t svqsub_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8_x)))
+svuint8_t svqsub_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32_x)))
+svuint32_t svqsub_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64_x)))
+svuint64_t svqsub_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16_x)))
+svuint16_t svqsub_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8_z)))
+svuint8_t svqsub_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32_z)))
+svuint32_t svqsub_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64_z)))
+svuint64_t svqsub_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16_z)))
+svuint16_t svqsub_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s8_m)))
+svint8_t svqsubr_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s32_m)))
+svint32_t svqsubr_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s64_m)))
+svint64_t svqsubr_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s16_m)))
+svint16_t svqsubr_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s8_x)))
+svint8_t svqsubr_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s32_x)))
+svint32_t svqsubr_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s64_x)))
+svint64_t svqsubr_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s16_x)))
+svint16_t svqsubr_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s8_z)))
+svint8_t svqsubr_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s32_z)))
+svint32_t svqsubr_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s64_z)))
+svint64_t svqsubr_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s16_z)))
+svint16_t svqsubr_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u8_m)))
+svuint8_t svqsubr_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u32_m)))
+svuint32_t svqsubr_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u64_m)))
+svuint64_t svqsubr_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u16_m)))
+svuint16_t svqsubr_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u8_x)))
+svuint8_t svqsubr_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u32_x)))
+svuint32_t svqsubr_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u64_x)))
+svuint64_t svqsubr_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u16_x)))
+svuint16_t svqsubr_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u8_z)))
+svuint8_t svqsubr_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u32_z)))
+svuint32_t svqsubr_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u64_z)))
+svuint64_t svqsubr_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u16_z)))
+svuint16_t svqsubr_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s8_m)))
+svint8_t svqsubr_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s32_m)))
+svint32_t svqsubr_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s64_m)))
+svint64_t svqsubr_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s16_m)))
+svint16_t svqsubr_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s8_x)))
+svint8_t svqsubr_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s32_x)))
+svint32_t svqsubr_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s64_x)))
+svint64_t svqsubr_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s16_x)))
+svint16_t svqsubr_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s8_z)))
+svint8_t svqsubr_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s32_z)))
+svint32_t svqsubr_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s64_z)))
+svint64_t svqsubr_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s16_z)))
+svint16_t svqsubr_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u8_m)))
+svuint8_t svqsubr_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u32_m)))
+svuint32_t svqsubr_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u64_m)))
+svuint64_t svqsubr_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u16_m)))
+svuint16_t svqsubr_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u8_x)))
+svuint8_t svqsubr_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u32_x)))
+svuint32_t svqsubr_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u64_x)))
+svuint64_t svqsubr_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u16_x)))
+svuint16_t svqsubr_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u8_z)))
+svuint8_t svqsubr_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u32_z)))
+svuint32_t svqsubr_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u64_z)))
+svuint64_t svqsubr_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u16_z)))
+svuint16_t svqsubr_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_s32)))
+svint16_t svqxtnb_s32(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_s64)))
+svint32_t svqxtnb_s64(svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_s16)))
+svint8_t svqxtnb_s16(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_u32)))
+svuint16_t svqxtnb_u32(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_u64)))
+svuint32_t svqxtnb_u64(svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_u16)))
+svuint8_t svqxtnb_u16(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_s32)))
+svint16_t svqxtnt_s32(svint16_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_s64)))
+svint32_t svqxtnt_s64(svint32_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_s16)))
+svint8_t svqxtnt_s16(svint8_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_u32)))
+svuint16_t svqxtnt_u32(svuint16_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_u64)))
+svuint32_t svqxtnt_u64(svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_u16)))
+svuint8_t svqxtnt_u16(svuint8_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunb_s32)))
+svuint16_t svqxtunb_s32(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunb_s64)))
+svuint32_t svqxtunb_s64(svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunb_s16)))
+svuint8_t svqxtunb_s16(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunt_s32)))
+svuint16_t svqxtunt_s32(svuint16_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunt_s64)))
+svuint32_t svqxtunt_s64(svuint32_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunt_s16)))
+svuint8_t svqxtunt_s16(svuint8_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_u32)))
+svuint16_t svraddhnb_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_u64)))
+svuint32_t svraddhnb_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_u16)))
+svuint8_t svraddhnb_n_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_s32)))
+svint16_t svraddhnb_n_s32(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_s64)))
+svint32_t svraddhnb_n_s64(svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_s16)))
+svint8_t svraddhnb_n_s16(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_u32)))
+svuint16_t svraddhnb_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_u64)))
+svuint32_t svraddhnb_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_u16)))
+svuint8_t svraddhnb_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_s32)))
+svint16_t svraddhnb_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_s64)))
+svint32_t svraddhnb_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_s16)))
+svint8_t svraddhnb_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_u32)))
+svuint16_t svraddhnt_n_u32(svuint16_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_u64)))
+svuint32_t svraddhnt_n_u64(svuint32_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_u16)))
+svuint8_t svraddhnt_n_u16(svuint8_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_s32)))
+svint16_t svraddhnt_n_s32(svint16_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_s64)))
+svint32_t svraddhnt_n_s64(svint32_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_s16)))
+svint8_t svraddhnt_n_s16(svint8_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_u32)))
+svuint16_t svraddhnt_u32(svuint16_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_u64)))
+svuint32_t svraddhnt_u64(svuint32_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_u16)))
+svuint8_t svraddhnt_u16(svuint8_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_s32)))
+svint16_t svraddhnt_s32(svint16_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_s64)))
+svint32_t svraddhnt_s64(svint32_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_s16)))
+svint8_t svraddhnt_s16(svint8_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_u32_m)))
+svuint32_t svrecpe_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_u32_x)))
+svuint32_t svrecpe_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_u32_z)))
+svuint32_t svrecpe_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s8_m)))
+svint8_t svrhadd_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s32_m)))
+svint32_t svrhadd_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s64_m)))
+svint64_t svrhadd_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s16_m)))
+svint16_t svrhadd_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s8_x)))
+svint8_t svrhadd_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s32_x)))
+svint32_t svrhadd_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s64_x)))
+svint64_t svrhadd_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s16_x)))
+svint16_t svrhadd_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s8_z)))
+svint8_t svrhadd_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s32_z)))
+svint32_t svrhadd_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s64_z)))
+svint64_t svrhadd_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s16_z)))
+svint16_t svrhadd_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u8_m)))
+svuint8_t svrhadd_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u32_m)))
+svuint32_t svrhadd_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u64_m)))
+svuint64_t svrhadd_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u16_m)))
+svuint16_t svrhadd_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u8_x)))
+svuint8_t svrhadd_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u32_x)))
+svuint32_t svrhadd_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u64_x)))
+svuint64_t svrhadd_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u16_x)))
+svuint16_t svrhadd_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u8_z)))
+svuint8_t svrhadd_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u32_z)))
+svuint32_t svrhadd_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u64_z)))
+svuint64_t svrhadd_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u16_z)))
+svuint16_t svrhadd_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s8_m)))
+svint8_t svrhadd_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s32_m)))
+svint32_t svrhadd_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s64_m)))
+svint64_t svrhadd_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s16_m)))
+svint16_t svrhadd_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s8_x)))
+svint8_t svrhadd_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s32_x)))
+svint32_t svrhadd_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s64_x)))
+svint64_t svrhadd_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s16_x)))
+svint16_t svrhadd_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s8_z)))
+svint8_t svrhadd_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s32_z)))
+svint32_t svrhadd_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s64_z)))
+svint64_t svrhadd_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s16_z)))
+svint16_t svrhadd_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u8_m)))
+svuint8_t svrhadd_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u32_m)))
+svuint32_t svrhadd_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u64_m)))
+svuint64_t svrhadd_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u16_m)))
+svuint16_t svrhadd_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u8_x)))
+svuint8_t svrhadd_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u32_x)))
+svuint32_t svrhadd_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u64_x)))
+svuint64_t svrhadd_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u16_x)))
+svuint16_t svrhadd_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u8_z)))
+svuint8_t svrhadd_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u32_z)))
+svuint32_t svrhadd_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u64_z)))
+svuint64_t svrhadd_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u16_z)))
+svuint16_t svrhadd_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s8_m)))
+svint8_t svrshl_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s32_m)))
+svint32_t svrshl_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s64_m)))
+svint64_t svrshl_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s16_m)))
+svint16_t svrshl_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s8_x)))
+svint8_t svrshl_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s32_x)))
+svint32_t svrshl_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s64_x)))
+svint64_t svrshl_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s16_x)))
+svint16_t svrshl_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s8_z)))
+svint8_t svrshl_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s32_z)))
+svint32_t svrshl_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s64_z)))
+svint64_t svrshl_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s16_z)))
+svint16_t svrshl_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u8_m)))
+svuint8_t svrshl_n_u8_m(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u32_m)))
+svuint32_t svrshl_n_u32_m(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u64_m)))
+svuint64_t svrshl_n_u64_m(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u16_m)))
+svuint16_t svrshl_n_u16_m(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u8_x)))
+svuint8_t svrshl_n_u8_x(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u32_x)))
+svuint32_t svrshl_n_u32_x(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u64_x)))
+svuint64_t svrshl_n_u64_x(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u16_x)))
+svuint16_t svrshl_n_u16_x(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u8_z)))
+svuint8_t svrshl_n_u8_z(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u32_z)))
+svuint32_t svrshl_n_u32_z(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u64_z)))
+svuint64_t svrshl_n_u64_z(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u16_z)))
+svuint16_t svrshl_n_u16_z(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_m)))
+svint8_t svrshl_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_m)))
+svint32_t svrshl_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_m)))
+svint64_t svrshl_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_m)))
+svint16_t svrshl_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_x)))
+svint8_t svrshl_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_x)))
+svint32_t svrshl_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_x)))
+svint64_t svrshl_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_x)))
+svint16_t svrshl_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_z)))
+svint8_t svrshl_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_z)))
+svint32_t svrshl_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_z)))
+svint64_t svrshl_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_z)))
+svint16_t svrshl_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_m)))
+svuint8_t svrshl_u8_m(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_m)))
+svuint32_t svrshl_u32_m(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_m)))
+svuint64_t svrshl_u64_m(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_m)))
+svuint16_t svrshl_u16_m(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_x)))
+svuint8_t svrshl_u8_x(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_x)))
+svuint32_t svrshl_u32_x(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_x)))
+svuint64_t svrshl_u64_x(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_x)))
+svuint16_t svrshl_u16_x(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_z)))
+svuint8_t svrshl_u8_z(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_z)))
+svuint32_t svrshl_u32_z(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_z)))
+svuint64_t svrshl_u64_z(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_z)))
+svuint16_t svrshl_u16_z(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s8_m)))
+svint8_t svrshr_n_s8_m(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s32_m)))
+svint32_t svrshr_n_s32_m(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s64_m)))
+svint64_t svrshr_n_s64_m(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s16_m)))
+svint16_t svrshr_n_s16_m(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u8_m)))
+svuint8_t svrshr_n_u8_m(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u32_m)))
+svuint32_t svrshr_n_u32_m(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u64_m)))
+svuint64_t svrshr_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u16_m)))
+svuint16_t svrshr_n_u16_m(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s8_x)))
+svint8_t svrshr_n_s8_x(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s32_x)))
+svint32_t svrshr_n_s32_x(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s64_x)))
+svint64_t svrshr_n_s64_x(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s16_x)))
+svint16_t svrshr_n_s16_x(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u8_x)))
+svuint8_t svrshr_n_u8_x(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u32_x)))
+svuint32_t svrshr_n_u32_x(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u64_x)))
+svuint64_t svrshr_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u16_x)))
+svuint16_t svrshr_n_u16_x(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s8_z)))
+svint8_t svrshr_n_s8_z(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s32_z)))
+svint32_t svrshr_n_s32_z(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s64_z)))
+svint64_t svrshr_n_s64_z(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s16_z)))
+svint16_t svrshr_n_s16_z(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u8_z)))
+svuint8_t svrshr_n_u8_z(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u32_z)))
+svuint32_t svrshr_n_u32_z(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u64_z)))
+svuint64_t svrshr_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u16_z)))
+svuint16_t svrshr_n_u16_z(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_u32)))
+svuint16_t svrshrnb_n_u32(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_u64)))
+svuint32_t svrshrnb_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_u16)))
+svuint8_t svrshrnb_n_u16(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_s32)))
+svint16_t svrshrnb_n_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_s64)))
+svint32_t svrshrnb_n_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_s16)))
+svint8_t svrshrnb_n_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_u32)))
+svuint16_t svrshrnt_n_u32(svuint16_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_u64)))
+svuint32_t svrshrnt_n_u64(svuint32_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_u16)))
+svuint8_t svrshrnt_n_u16(svuint8_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_s32)))
+svint16_t svrshrnt_n_s32(svint16_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_s64)))
+svint32_t svrshrnt_n_s64(svint32_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_s16)))
+svint8_t svrshrnt_n_s16(svint8_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_u32_m)))
+svuint32_t svrsqrte_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_u32_x)))
+svuint32_t svrsqrte_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_u32_z)))
+svuint32_t svrsqrte_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s8)))
+svint8_t svrsra_n_s8(svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s32)))
+svint32_t svrsra_n_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s64)))
+svint64_t svrsra_n_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s16)))
+svint16_t svrsra_n_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u8)))
+svuint8_t svrsra_n_u8(svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u32)))
+svuint32_t svrsra_n_u32(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u64)))
+svuint64_t svrsra_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u16)))
+svuint16_t svrsra_n_u16(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_u32)))
+svuint16_t svrsubhnb_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_u64)))
+svuint32_t svrsubhnb_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_u16)))
+svuint8_t svrsubhnb_n_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_s32)))
+svint16_t svrsubhnb_n_s32(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_s64)))
+svint32_t svrsubhnb_n_s64(svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_s16)))
+svint8_t svrsubhnb_n_s16(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_u32)))
+svuint16_t svrsubhnb_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_u64)))
+svuint32_t svrsubhnb_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_u16)))
+svuint8_t svrsubhnb_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_s32)))
+svint16_t svrsubhnb_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_s64)))
+svint32_t svrsubhnb_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_s16)))
+svint8_t svrsubhnb_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_u32)))
+svuint16_t svrsubhnt_n_u32(svuint16_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_u64)))
+svuint32_t svrsubhnt_n_u64(svuint32_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_u16)))
+svuint8_t svrsubhnt_n_u16(svuint8_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_s32)))
+svint16_t svrsubhnt_n_s32(svint16_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_s64)))
+svint32_t svrsubhnt_n_s64(svint32_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_s16)))
+svint8_t svrsubhnt_n_s16(svint8_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_u32)))
+svuint16_t svrsubhnt_u32(svuint16_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_u64)))
+svuint32_t svrsubhnt_u64(svuint32_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_u16)))
+svuint8_t svrsubhnt_u16(svuint8_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_s32)))
+svint16_t svrsubhnt_s32(svint16_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_s64)))
+svint32_t svrsubhnt_s64(svint32_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_s16)))
+svint8_t svrsubhnt_s16(svint8_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_n_u32)))
+svuint32_t svsbclb_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_n_u64)))
+svuint64_t svsbclb_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_u32)))
+svuint32_t svsbclb_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_u64)))
+svuint64_t svsbclb_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_n_u32)))
+svuint32_t svsbclt_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_n_u64)))
+svuint64_t svsbclt_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_u32)))
+svuint32_t svsbclt_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_u64)))
+svuint64_t svsbclt_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_s32)))
+svint32_t svshllb_n_s32(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_s64)))
+svint64_t svshllb_n_s64(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_s16)))
+svint16_t svshllb_n_s16(svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_u32)))
+svuint32_t svshllb_n_u32(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_u64)))
+svuint64_t svshllb_n_u64(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_u16)))
+svuint16_t svshllb_n_u16(svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_s32)))
+svint32_t svshllt_n_s32(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_s64)))
+svint64_t svshllt_n_s64(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_s16)))
+svint16_t svshllt_n_s16(svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_u32)))
+svuint32_t svshllt_n_u32(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_u64)))
+svuint64_t svshllt_n_u64(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_u16)))
+svuint16_t svshllt_n_u16(svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_u32)))
+svuint16_t svshrnb_n_u32(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_u64)))
+svuint32_t svshrnb_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_u16)))
+svuint8_t svshrnb_n_u16(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_s32)))
+svint16_t svshrnb_n_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_s64)))
+svint32_t svshrnb_n_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_s16)))
+svint8_t svshrnb_n_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_u32)))
+svuint16_t svshrnt_n_u32(svuint16_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_u64)))
+svuint32_t svshrnt_n_u64(svuint32_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_u16)))
+svuint8_t svshrnt_n_u16(svuint8_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_s32)))
+svint16_t svshrnt_n_s32(svint16_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_s64)))
+svint32_t svshrnt_n_s64(svint32_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_s16)))
+svint8_t svshrnt_n_s16(svint8_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u8)))
+svuint8_t svsli_n_u8(svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u32)))
+svuint32_t svsli_n_u32(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u64)))
+svuint64_t svsli_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u16)))
+svuint16_t svsli_n_u16(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s8)))
+svint8_t svsli_n_s8(svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s32)))
+svint32_t svsli_n_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s64)))
+svint64_t svsli_n_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s16)))
+svint16_t svsli_n_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u8_m)))
+svuint8_t svsqadd_n_u8_m(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u32_m)))
+svuint32_t svsqadd_n_u32_m(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u64_m)))
+svuint64_t svsqadd_n_u64_m(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u16_m)))
+svuint16_t svsqadd_n_u16_m(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u8_x)))
+svuint8_t svsqadd_n_u8_x(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u32_x)))
+svuint32_t svsqadd_n_u32_x(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u64_x)))
+svuint64_t svsqadd_n_u64_x(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u16_x)))
+svuint16_t svsqadd_n_u16_x(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u8_z)))
+svuint8_t svsqadd_n_u8_z(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u32_z)))
+svuint32_t svsqadd_n_u32_z(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u64_z)))
+svuint64_t svsqadd_n_u64_z(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u16_z)))
+svuint16_t svsqadd_n_u16_z(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u8_m)))
+svuint8_t svsqadd_u8_m(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u32_m)))
+svuint32_t svsqadd_u32_m(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u64_m)))
+svuint64_t svsqadd_u64_m(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u16_m)))
+svuint16_t svsqadd_u16_m(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u8_x)))
+svuint8_t svsqadd_u8_x(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u32_x)))
+svuint32_t svsqadd_u32_x(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u64_x)))
+svuint64_t svsqadd_u64_x(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u16_x)))
+svuint16_t svsqadd_u16_x(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u8_z)))
+svuint8_t svsqadd_u8_z(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u32_z)))
+svuint32_t svsqadd_u32_z(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u64_z)))
+svuint64_t svsqadd_u64_z(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u16_z)))
+svuint16_t svsqadd_u16_z(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s8)))
+svint8_t svsra_n_s8(svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s32)))
+svint32_t svsra_n_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s64)))
+svint64_t svsra_n_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s16)))
+svint16_t svsra_n_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u8)))
+svuint8_t svsra_n_u8(svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u32)))
+svuint32_t svsra_n_u32(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u64)))
+svuint64_t svsra_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u16)))
+svuint16_t svsra_n_u16(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u8)))
+svuint8_t svsri_n_u8(svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u32)))
+svuint32_t svsri_n_u32(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u64)))
+svuint64_t svsri_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u16)))
+svuint16_t svsri_n_u16(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s8)))
+svint8_t svsri_n_s8(svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s32)))
+svint32_t svsri_n_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s64)))
+svint64_t svsri_n_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s16)))
+svint16_t svsri_n_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_u32)))
+svuint16_t svsubhnb_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_u64)))
+svuint32_t svsubhnb_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_u16)))
+svuint8_t svsubhnb_n_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_s32)))
+svint16_t svsubhnb_n_s32(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_s64)))
+svint32_t svsubhnb_n_s64(svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_s16)))
+svint8_t svsubhnb_n_s16(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_u32)))
+svuint16_t svsubhnb_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_u64)))
+svuint32_t svsubhnb_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_u16)))
+svuint8_t svsubhnb_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_s32)))
+svint16_t svsubhnb_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_s64)))
+svint32_t svsubhnb_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_s16)))
+svint8_t svsubhnb_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_u32)))
+svuint16_t svsubhnt_n_u32(svuint16_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_u64)))
+svuint32_t svsubhnt_n_u64(svuint32_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_u16)))
+svuint8_t svsubhnt_n_u16(svuint8_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_s32)))
+svint16_t svsubhnt_n_s32(svint16_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_s64)))
+svint32_t svsubhnt_n_s64(svint32_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_s16)))
+svint8_t svsubhnt_n_s16(svint8_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_u32)))
+svuint16_t svsubhnt_u32(svuint16_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_u64)))
+svuint32_t svsubhnt_u64(svuint32_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_u16)))
+svuint8_t svsubhnt_u16(svuint8_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_s32)))
+svint16_t svsubhnt_s32(svint16_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_s64)))
+svint32_t svsubhnt_s64(svint32_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_s16)))
+svint8_t svsubhnt_s16(svint8_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_s32)))
+svint32_t svsublb_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_s64)))
+svint64_t svsublb_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_s16)))
+svint16_t svsublb_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_u32)))
+svuint32_t svsublb_n_u32(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_u64)))
+svuint64_t svsublb_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_u16)))
+svuint16_t svsublb_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_s32)))
+svint32_t svsublb_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_s64)))
+svint64_t svsublb_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_s16)))
+svint16_t svsublb_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_u32)))
+svuint32_t svsublb_u32(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_u64)))
+svuint64_t svsublb_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_u16)))
+svuint16_t svsublb_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_n_s32)))
+svint32_t svsublbt_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_n_s64)))
+svint64_t svsublbt_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_n_s16)))
+svint16_t svsublbt_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_s32)))
+svint32_t svsublbt_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_s64)))
+svint64_t svsublbt_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_s16)))
+svint16_t svsublbt_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_s32)))
+svint32_t svsublt_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_s64)))
+svint64_t svsublt_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_s16)))
+svint16_t svsublt_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_u32)))
+svuint32_t svsublt_n_u32(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_u64)))
+svuint64_t svsublt_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_u16)))
+svuint16_t svsublt_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_s32)))
+svint32_t svsublt_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_s64)))
+svint64_t svsublt_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_s16)))
+svint16_t svsublt_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_u32)))
+svuint32_t svsublt_u32(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_u64)))
+svuint64_t svsublt_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_u16)))
+svuint16_t svsublt_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_n_s32)))
+svint32_t svsubltb_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_n_s64)))
+svint64_t svsubltb_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_n_s16)))
+svint16_t svsubltb_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_s32)))
+svint32_t svsubltb_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_s64)))
+svint64_t svsubltb_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_s16)))
+svint16_t svsubltb_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_s32)))
+svint32_t svsubwb_n_s32(svint32_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_s64)))
+svint64_t svsubwb_n_s64(svint64_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_s16)))
+svint16_t svsubwb_n_s16(svint16_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_u32)))
+svuint32_t svsubwb_n_u32(svuint32_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_u64)))
+svuint64_t svsubwb_n_u64(svuint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_u16)))
+svuint16_t svsubwb_n_u16(svuint16_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_s32)))
+svint32_t svsubwb_s32(svint32_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_s64)))
+svint64_t svsubwb_s64(svint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_s16)))
+svint16_t svsubwb_s16(svint16_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_u32)))
+svuint32_t svsubwb_u32(svuint32_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_u64)))
+svuint64_t svsubwb_u64(svuint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_u16)))
+svuint16_t svsubwb_u16(svuint16_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_s32)))
+svint32_t svsubwt_n_s32(svint32_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_s64)))
+svint64_t svsubwt_n_s64(svint64_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_s16)))
+svint16_t svsubwt_n_s16(svint16_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_u32)))
+svuint32_t svsubwt_n_u32(svuint32_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_u64)))
+svuint64_t svsubwt_n_u64(svuint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_u16)))
+svuint16_t svsubwt_n_u16(svuint16_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_s32)))
+svint32_t svsubwt_s32(svint32_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_s64)))
+svint64_t svsubwt_s64(svint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_s16)))
+svint16_t svsubwt_s16(svint16_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_u32)))
+svuint32_t svsubwt_u32(svuint32_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_u64)))
+svuint64_t svsubwt_u64(svuint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_u16)))
+svuint16_t svsubwt_u16(svuint16_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u8)))
+svuint8_t svtbl2_u8(svuint8x2_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u32)))
+svuint32_t svtbl2_u32(svuint32x2_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u64)))
+svuint64_t svtbl2_u64(svuint64x2_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u16)))
+svuint16_t svtbl2_u16(svuint16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s8)))
+svint8_t svtbl2_s8(svint8x2_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_f64)))
+svfloat64_t svtbl2_f64(svfloat64x2_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_f32)))
+svfloat32_t svtbl2_f32(svfloat32x2_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_f16)))
+svfloat16_t svtbl2_f16(svfloat16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s32)))
+svint32_t svtbl2_s32(svint32x2_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s64)))
+svint64_t svtbl2_s64(svint64x2_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s16)))
+svint16_t svtbl2_s16(svint16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u8)))
+svuint8_t svtbx_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u32)))
+svuint32_t svtbx_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u64)))
+svuint64_t svtbx_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u16)))
+svuint16_t svtbx_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s8)))
+svint8_t svtbx_s8(svint8_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_f64)))
+svfloat64_t svtbx_f64(svfloat64_t, svfloat64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_f32)))
+svfloat32_t svtbx_f32(svfloat32_t, svfloat32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_f16)))
+svfloat16_t svtbx_f16(svfloat16_t, svfloat16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s32)))
+svint32_t svtbx_s32(svint32_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s64)))
+svint64_t svtbx_s64(svint64_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s16)))
+svint16_t svtbx_s16(svint16_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s8_m)))
+svint8_t svuqadd_n_s8_m(svbool_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s32_m)))
+svint32_t svuqadd_n_s32_m(svbool_t, svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s64_m)))
+svint64_t svuqadd_n_s64_m(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s16_m)))
+svint16_t svuqadd_n_s16_m(svbool_t, svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s8_x)))
+svint8_t svuqadd_n_s8_x(svbool_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s32_x)))
+svint32_t svuqadd_n_s32_x(svbool_t, svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s64_x)))
+svint64_t svuqadd_n_s64_x(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s16_x)))
+svint16_t svuqadd_n_s16_x(svbool_t, svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s8_z)))
+svint8_t svuqadd_n_s8_z(svbool_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s32_z)))
+svint32_t svuqadd_n_s32_z(svbool_t, svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s64_z)))
+svint64_t svuqadd_n_s64_z(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s16_z)))
+svint16_t svuqadd_n_s16_z(svbool_t, svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s8_m)))
+svint8_t svuqadd_s8_m(svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s32_m)))
+svint32_t svuqadd_s32_m(svbool_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s64_m)))
+svint64_t svuqadd_s64_m(svbool_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s16_m)))
+svint16_t svuqadd_s16_m(svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s8_x)))
+svint8_t svuqadd_s8_x(svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s32_x)))
+svint32_t svuqadd_s32_x(svbool_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s64_x)))
+svint64_t svuqadd_s64_x(svbool_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s16_x)))
+svint16_t svuqadd_s16_x(svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s8_z)))
+svint8_t svuqadd_s8_z(svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s32_z)))
+svint32_t svuqadd_s32_z(svbool_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s64_z)))
+svint64_t svuqadd_s64_z(svbool_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s16_z)))
+svint16_t svuqadd_s16_z(svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_s32)))
+svbool_t svwhilege_b8_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_s32)))
+svbool_t svwhilege_b32_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_s32)))
+svbool_t svwhilege_b64_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_s32)))
+svbool_t svwhilege_b16_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_s64)))
+svbool_t svwhilege_b8_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_s64)))
+svbool_t svwhilege_b32_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_s64)))
+svbool_t svwhilege_b64_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_s64)))
+svbool_t svwhilege_b16_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_u32)))
+svbool_t svwhilege_b8_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_u32)))
+svbool_t svwhilege_b32_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_u32)))
+svbool_t svwhilege_b64_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_u32)))
+svbool_t svwhilege_b16_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_u64)))
+svbool_t svwhilege_b8_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_u64)))
+svbool_t svwhilege_b32_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_u64)))
+svbool_t svwhilege_b64_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_u64)))
+svbool_t svwhilege_b16_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_s32)))
+svbool_t svwhilegt_b8_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_s32)))
+svbool_t svwhilegt_b32_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_s32)))
+svbool_t svwhilegt_b64_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_s32)))
+svbool_t svwhilegt_b16_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_s64)))
+svbool_t svwhilegt_b8_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_s64)))
+svbool_t svwhilegt_b32_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_s64)))
+svbool_t svwhilegt_b64_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_s64)))
+svbool_t svwhilegt_b16_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_u32)))
+svbool_t svwhilegt_b8_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_u32)))
+svbool_t svwhilegt_b32_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_u32)))
+svbool_t svwhilegt_b64_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_u32)))
+svbool_t svwhilegt_b16_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_u64)))
+svbool_t svwhilegt_b8_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_u64)))
+svbool_t svwhilegt_b32_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_u64)))
+svbool_t svwhilegt_b64_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_u64)))
+svbool_t svwhilegt_b16_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u8)))
+svbool_t svwhilerw_u8(uint8_t const *, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s8)))
+svbool_t svwhilerw_s8(int8_t const *, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u64)))
+svbool_t svwhilerw_u64(uint64_t const *, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_f64)))
+svbool_t svwhilerw_f64(float64_t const *, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s64)))
+svbool_t svwhilerw_s64(int64_t const *, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u16)))
+svbool_t svwhilerw_u16(uint16_t const *, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_f16)))
+svbool_t svwhilerw_f16(float16_t const *, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s16)))
+svbool_t svwhilerw_s16(int16_t const *, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u32)))
+svbool_t svwhilerw_u32(uint32_t const *, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_f32)))
+svbool_t svwhilerw_f32(float32_t const *, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s32)))
+svbool_t svwhilerw_s32(int32_t const *, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u8)))
+svbool_t svwhilewr_u8(uint8_t const *, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s8)))
+svbool_t svwhilewr_s8(int8_t const *, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u64)))
+svbool_t svwhilewr_u64(uint64_t const *, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_f64)))
+svbool_t svwhilewr_f64(float64_t const *, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s64)))
+svbool_t svwhilewr_s64(int64_t const *, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u16)))
+svbool_t svwhilewr_u16(uint16_t const *, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_f16)))
+svbool_t svwhilewr_f16(float16_t const *, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s16)))
+svbool_t svwhilewr_s16(int16_t const *, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u32)))
+svbool_t svwhilewr_u32(uint32_t const *, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_f32)))
+svbool_t svwhilewr_f32(float32_t const *, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s32)))
+svbool_t svwhilewr_s32(int32_t const *, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u8)))
+svuint8_t svxar_n_u8(svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u32)))
+svuint32_t svxar_n_u32(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u64)))
+svuint64_t svxar_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u16)))
+svuint16_t svxar_n_u16(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s8)))
+svint8_t svxar_n_s8(svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s32)))
+svint32_t svxar_n_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s64)))
+svint64_t svxar_n_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s16)))
+svint16_t svxar_n_s16(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s8)))
+svint8_t svaba(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s32)))
+svint32_t svaba(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s64)))
+svint64_t svaba(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s16)))
+svint16_t svaba(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u8)))
+svuint8_t svaba(svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u32)))
+svuint32_t svaba(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u64)))
+svuint64_t svaba(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u16)))
+svuint16_t svaba(svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s8)))
+svint8_t svaba(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s32)))
+svint32_t svaba(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s64)))
+svint64_t svaba(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s16)))
+svint16_t svaba(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u8)))
+svuint8_t svaba(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u32)))
+svuint32_t svaba(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u64)))
+svuint64_t svaba(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u16)))
+svuint16_t svaba(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_s32)))
+svint32_t svabalb(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_s64)))
+svint64_t svabalb(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_s16)))
+svint16_t svabalb(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_u32)))
+svuint32_t svabalb(svuint32_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_u64)))
+svuint64_t svabalb(svuint64_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_u16)))
+svuint16_t svabalb(svuint16_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_s32)))
+svint32_t svabalb(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_s64)))
+svint64_t svabalb(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_s16)))
+svint16_t svabalb(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_u32)))
+svuint32_t svabalb(svuint32_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_u64)))
+svuint64_t svabalb(svuint64_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_u16)))
+svuint16_t svabalb(svuint16_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_s32)))
+svint32_t svabalt(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_s64)))
+svint64_t svabalt(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_s16)))
+svint16_t svabalt(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_u32)))
+svuint32_t svabalt(svuint32_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_u64)))
+svuint64_t svabalt(svuint64_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_u16)))
+svuint16_t svabalt(svuint16_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_s32)))
+svint32_t svabalt(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_s64)))
+svint64_t svabalt(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_s16)))
+svint16_t svabalt(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_u32)))
+svuint32_t svabalt(svuint32_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_u64)))
+svuint64_t svabalt(svuint64_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_u16)))
+svuint16_t svabalt(svuint16_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_s32)))
+svint32_t svabdlb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_s64)))
+svint64_t svabdlb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_s16)))
+svint16_t svabdlb(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_u32)))
+svuint32_t svabdlb(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_u64)))
+svuint64_t svabdlb(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_u16)))
+svuint16_t svabdlb(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_s32)))
+svint32_t svabdlb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_s64)))
+svint64_t svabdlb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_s16)))
+svint16_t svabdlb(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_u32)))
+svuint32_t svabdlb(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_u64)))
+svuint64_t svabdlb(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_u16)))
+svuint16_t svabdlb(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_s32)))
+svint32_t svabdlt(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_s64)))
+svint64_t svabdlt(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_s16)))
+svint16_t svabdlt(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_u32)))
+svuint32_t svabdlt(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_u64)))
+svuint64_t svabdlt(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_u16)))
+svuint16_t svabdlt(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_s32)))
+svint32_t svabdlt(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_s64)))
+svint64_t svabdlt(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_s16)))
+svint16_t svabdlt(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_u32)))
+svuint32_t svabdlt(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_u64)))
+svuint64_t svabdlt(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_u16)))
+svuint16_t svabdlt(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s32_m)))
+svint32_t svadalp_m(svbool_t, svint32_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s64_m)))
+svint64_t svadalp_m(svbool_t, svint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s16_m)))
+svint16_t svadalp_m(svbool_t, svint16_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s32_x)))
+svint32_t svadalp_x(svbool_t, svint32_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s64_x)))
+svint64_t svadalp_x(svbool_t, svint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s16_x)))
+svint16_t svadalp_x(svbool_t, svint16_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s32_z)))
+svint32_t svadalp_z(svbool_t, svint32_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s64_z)))
+svint64_t svadalp_z(svbool_t, svint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s16_z)))
+svint16_t svadalp_z(svbool_t, svint16_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u32_m)))
+svuint32_t svadalp_m(svbool_t, svuint32_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u64_m)))
+svuint64_t svadalp_m(svbool_t, svuint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u16_m)))
+svuint16_t svadalp_m(svbool_t, svuint16_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u32_x)))
+svuint32_t svadalp_x(svbool_t, svuint32_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u64_x)))
+svuint64_t svadalp_x(svbool_t, svuint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u16_x)))
+svuint16_t svadalp_x(svbool_t, svuint16_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u32_z)))
+svuint32_t svadalp_z(svbool_t, svuint32_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u64_z)))
+svuint64_t svadalp_z(svbool_t, svuint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u16_z)))
+svuint16_t svadalp_z(svbool_t, svuint16_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_n_u32)))
+svuint32_t svadclb(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_n_u64)))
+svuint64_t svadclb(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_u32)))
+svuint32_t svadclb(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_u64)))
+svuint64_t svadclb(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_n_u32)))
+svuint32_t svadclt(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_n_u64)))
+svuint64_t svadclt(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_u32)))
+svuint32_t svadclt(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_u64)))
+svuint64_t svadclt(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_u32)))
+svuint16_t svaddhnb(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_u64)))
+svuint32_t svaddhnb(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_u16)))
+svuint8_t svaddhnb(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_s32)))
+svint16_t svaddhnb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_s64)))
+svint32_t svaddhnb(svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_s16)))
+svint8_t svaddhnb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_u32)))
+svuint16_t svaddhnb(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_u64)))
+svuint32_t svaddhnb(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_u16)))
+svuint8_t svaddhnb(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_s32)))
+svint16_t svaddhnb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_s64)))
+svint32_t svaddhnb(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_s16)))
+svint8_t svaddhnb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_u32)))
+svuint16_t svaddhnt(svuint16_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_u64)))
+svuint32_t svaddhnt(svuint32_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_u16)))
+svuint8_t svaddhnt(svuint8_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_s32)))
+svint16_t svaddhnt(svint16_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_s64)))
+svint32_t svaddhnt(svint32_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_s16)))
+svint8_t svaddhnt(svint8_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_u32)))
+svuint16_t svaddhnt(svuint16_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_u64)))
+svuint32_t svaddhnt(svuint32_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_u16)))
+svuint8_t svaddhnt(svuint8_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_s32)))
+svint16_t svaddhnt(svint16_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_s64)))
+svint32_t svaddhnt(svint32_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_s16)))
+svint8_t svaddhnt(svint8_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_s32)))
+svint32_t svaddlb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_s64)))
+svint64_t svaddlb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_s16)))
+svint16_t svaddlb(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_u32)))
+svuint32_t svaddlb(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_u64)))
+svuint64_t svaddlb(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_u16)))
+svuint16_t svaddlb(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_s32)))
+svint32_t svaddlb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_s64)))
+svint64_t svaddlb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_s16)))
+svint16_t svaddlb(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_u32)))
+svuint32_t svaddlb(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_u64)))
+svuint64_t svaddlb(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_u16)))
+svuint16_t svaddlb(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_n_s32)))
+svint32_t svaddlbt(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_n_s64)))
+svint64_t svaddlbt(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_n_s16)))
+svint16_t svaddlbt(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_s32)))
+svint32_t svaddlbt(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_s64)))
+svint64_t svaddlbt(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_s16)))
+svint16_t svaddlbt(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_s32)))
+svint32_t svaddlt(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_s64)))
+svint64_t svaddlt(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_s16)))
+svint16_t svaddlt(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_u32)))
+svuint32_t svaddlt(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_u64)))
+svuint64_t svaddlt(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_u16)))
+svuint16_t svaddlt(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_s32)))
+svint32_t svaddlt(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_s64)))
+svint64_t svaddlt(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_s16)))
+svint16_t svaddlt(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_u32)))
+svuint32_t svaddlt(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_u64)))
+svuint64_t svaddlt(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_u16)))
+svuint16_t svaddlt(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f64_m)))
+svfloat64_t svaddp_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f32_m)))
+svfloat32_t svaddp_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f16_m)))
+svfloat16_t svaddp_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f64_x)))
+svfloat64_t svaddp_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f32_x)))
+svfloat32_t svaddp_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f16_x)))
+svfloat16_t svaddp_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u8_m)))
+svuint8_t svaddp_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u32_m)))
+svuint32_t svaddp_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u64_m)))
+svuint64_t svaddp_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u16_m)))
+svuint16_t svaddp_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s8_m)))
+svint8_t svaddp_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s32_m)))
+svint32_t svaddp_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s64_m)))
+svint64_t svaddp_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s16_m)))
+svint16_t svaddp_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u8_x)))
+svuint8_t svaddp_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u32_x)))
+svuint32_t svaddp_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u64_x)))
+svuint64_t svaddp_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u16_x)))
+svuint16_t svaddp_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s8_x)))
+svint8_t svaddp_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s32_x)))
+svint32_t svaddp_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s64_x)))
+svint64_t svaddp_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s16_x)))
+svint16_t svaddp_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_s32)))
+svint32_t svaddwb(svint32_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_s64)))
+svint64_t svaddwb(svint64_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_s16)))
+svint16_t svaddwb(svint16_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_u32)))
+svuint32_t svaddwb(svuint32_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_u64)))
+svuint64_t svaddwb(svuint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_u16)))
+svuint16_t svaddwb(svuint16_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_s32)))
+svint32_t svaddwb(svint32_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_s64)))
+svint64_t svaddwb(svint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_s16)))
+svint16_t svaddwb(svint16_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_u32)))
+svuint32_t svaddwb(svuint32_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_u64)))
+svuint64_t svaddwb(svuint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_u16)))
+svuint16_t svaddwb(svuint16_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_s32)))
+svint32_t svaddwt(svint32_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_s64)))
+svint64_t svaddwt(svint64_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_s16)))
+svint16_t svaddwt(svint16_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_u32)))
+svuint32_t svaddwt(svuint32_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_u64)))
+svuint64_t svaddwt(svuint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_u16)))
+svuint16_t svaddwt(svuint16_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_s32)))
+svint32_t svaddwt(svint32_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_s64)))
+svint64_t svaddwt(svint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_s16)))
+svint16_t svaddwt(svint16_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_u32)))
+svuint32_t svaddwt(svuint32_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_u64)))
+svuint64_t svaddwt(svuint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_u16)))
+svuint16_t svaddwt(svuint16_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u8)))
+svuint8_t svbcax(svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u32)))
+svuint32_t svbcax(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u64)))
+svuint64_t svbcax(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u16)))
+svuint16_t svbcax(svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s8)))
+svint8_t svbcax(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s32)))
+svint32_t svbcax(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s64)))
+svint64_t svbcax(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s16)))
+svint16_t svbcax(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u8)))
+svuint8_t svbcax(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u32)))
+svuint32_t svbcax(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u64)))
+svuint64_t svbcax(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u16)))
+svuint16_t svbcax(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s8)))
+svint8_t svbcax(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s32)))
+svint32_t svbcax(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s64)))
+svint64_t svbcax(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s16)))
+svint16_t svbcax(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u8)))
+svuint8_t svbsl1n(svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u32)))
+svuint32_t svbsl1n(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u64)))
+svuint64_t svbsl1n(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u16)))
+svuint16_t svbsl1n(svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s8)))
+svint8_t svbsl1n(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s32)))
+svint32_t svbsl1n(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s64)))
+svint64_t svbsl1n(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s16)))
+svint16_t svbsl1n(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u8)))
+svuint8_t svbsl1n(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u32)))
+svuint32_t svbsl1n(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u64)))
+svuint64_t svbsl1n(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u16)))
+svuint16_t svbsl1n(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s8)))
+svint8_t svbsl1n(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s32)))
+svint32_t svbsl1n(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s64)))
+svint64_t svbsl1n(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s16)))
+svint16_t svbsl1n(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u8)))
+svuint8_t svbsl2n(svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u32)))
+svuint32_t svbsl2n(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u64)))
+svuint64_t svbsl2n(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u16)))
+svuint16_t svbsl2n(svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s8)))
+svint8_t svbsl2n(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s32)))
+svint32_t svbsl2n(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s64)))
+svint64_t svbsl2n(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s16)))
+svint16_t svbsl2n(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u8)))
+svuint8_t svbsl2n(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u32)))
+svuint32_t svbsl2n(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u64)))
+svuint64_t svbsl2n(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u16)))
+svuint16_t svbsl2n(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s8)))
+svint8_t svbsl2n(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s32)))
+svint32_t svbsl2n(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s64)))
+svint64_t svbsl2n(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s16)))
+svint16_t svbsl2n(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u8)))
+svuint8_t svbsl(svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u32)))
+svuint32_t svbsl(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u64)))
+svuint64_t svbsl(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u16)))
+svuint16_t svbsl(svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s8)))
+svint8_t svbsl(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s32)))
+svint32_t svbsl(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s64)))
+svint64_t svbsl(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s16)))
+svint16_t svbsl(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u8)))
+svuint8_t svbsl(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u32)))
+svuint32_t svbsl(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u64)))
+svuint64_t svbsl(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u16)))
+svuint16_t svbsl(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s8)))
+svint8_t svbsl(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s32)))
+svint32_t svbsl(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s64)))
+svint64_t svbsl(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s16)))
+svint16_t svbsl(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u8)))
+svuint8_t svcadd(svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u32)))
+svuint32_t svcadd(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u64)))
+svuint64_t svcadd(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u16)))
+svuint16_t svcadd(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s8)))
+svint8_t svcadd(svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s32)))
+svint32_t svcadd(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s64)))
+svint64_t svcadd(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s16)))
+svint16_t svcadd(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_s32)))
+svint32_t svcdot(svint32_t, svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_s64)))
+svint64_t svcdot(svint64_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_lane_s32)))
+svint32_t svcdot_lane(svint32_t, svint8_t, svint8_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_lane_s64)))
+svint64_t svcdot_lane(svint64_t, svint16_t, svint16_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u8)))
+svuint8_t svcmla(svuint8_t, svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u32)))
+svuint32_t svcmla(svuint32_t, svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u64)))
+svuint64_t svcmla(svuint64_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u16)))
+svuint16_t svcmla(svuint16_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s8)))
+svint8_t svcmla(svint8_t, svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s32)))
+svint32_t svcmla(svint32_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s64)))
+svint64_t svcmla(svint64_t, svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s16)))
+svint16_t svcmla(svint16_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_u32)))
+svuint32_t svcmla_lane(svuint32_t, svuint32_t, svuint32_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_u16)))
+svuint16_t svcmla_lane(svuint16_t, svuint16_t, svuint16_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_s32)))
+svint32_t svcmla_lane(svint32_t, svint32_t, svint32_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_s16)))
+svint16_t svcmla_lane(svint16_t, svint16_t, svint16_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f32_f16_m)))
+svfloat32_t svcvtlt_f32_m(svfloat32_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f32_f16_x)))
+svfloat32_t svcvtlt_f32_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f64_f32_m)))
+svfloat64_t svcvtlt_f64_m(svfloat64_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f64_f32_x)))
+svfloat64_t svcvtlt_f64_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtnt_f16_f32_m)))
+svfloat16_t svcvtnt_f16_m(svfloat16_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtnt_f32_f64_m)))
+svfloat32_t svcvtnt_f32_m(svfloat32_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtx_f32_f64_m)))
+svfloat32_t svcvtx_f32_m(svfloat32_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtx_f32_f64_x)))
+svfloat32_t svcvtx_f32_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtx_f32_f64_z)))
+svfloat32_t svcvtx_f32_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtxnt_f32_f64_m)))
+svfloat32_t svcvtxnt_f32_m(svfloat32_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u8)))
+svuint8_t sveor3(svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u32)))
+svuint32_t sveor3(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u64)))
+svuint64_t sveor3(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u16)))
+svuint16_t sveor3(svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s8)))
+svint8_t sveor3(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s32)))
+svint32_t sveor3(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s64)))
+svint64_t sveor3(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s16)))
+svint16_t sveor3(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u8)))
+svuint8_t sveor3(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u32)))
+svuint32_t sveor3(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u64)))
+svuint64_t sveor3(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u16)))
+svuint16_t sveor3(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s8)))
+svint8_t sveor3(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s32)))
+svint32_t sveor3(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s64)))
+svint64_t sveor3(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s16)))
+svint16_t sveor3(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u8)))
+svuint8_t sveorbt(svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u32)))
+svuint32_t sveorbt(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u64)))
+svuint64_t sveorbt(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u16)))
+svuint16_t sveorbt(svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s8)))
+svint8_t sveorbt(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s32)))
+svint32_t sveorbt(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s64)))
+svint64_t sveorbt(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s16)))
+svint16_t sveorbt(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u8)))
+svuint8_t sveorbt(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u32)))
+svuint32_t sveorbt(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u64)))
+svuint64_t sveorbt(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u16)))
+svuint16_t sveorbt(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s8)))
+svint8_t sveorbt(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s32)))
+svint32_t sveorbt(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s64)))
+svint64_t sveorbt(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s16)))
+svint16_t sveorbt(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u8)))
+svuint8_t sveortb(svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u32)))
+svuint32_t sveortb(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u64)))
+svuint64_t sveortb(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u16)))
+svuint16_t sveortb(svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s8)))
+svint8_t sveortb(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s32)))
+svint32_t sveortb(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s64)))
+svint64_t sveortb(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s16)))
+svint16_t sveortb(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u8)))
+svuint8_t sveortb(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u32)))
+svuint32_t sveortb(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u64)))
+svuint64_t sveortb(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u16)))
+svuint16_t sveortb(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s8)))
+svint8_t sveortb(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s32)))
+svint32_t sveortb(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s64)))
+svint64_t sveortb(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s16)))
+svint16_t sveortb(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s8_m)))
+svint8_t svhadd_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s32_m)))
+svint32_t svhadd_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s64_m)))
+svint64_t svhadd_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s16_m)))
+svint16_t svhadd_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s8_x)))
+svint8_t svhadd_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s32_x)))
+svint32_t svhadd_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s64_x)))
+svint64_t svhadd_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s16_x)))
+svint16_t svhadd_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s8_z)))
+svint8_t svhadd_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s32_z)))
+svint32_t svhadd_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s64_z)))
+svint64_t svhadd_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s16_z)))
+svint16_t svhadd_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u8_m)))
+svuint8_t svhadd_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u32_m)))
+svuint32_t svhadd_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u64_m)))
+svuint64_t svhadd_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u16_m)))
+svuint16_t svhadd_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u8_x)))
+svuint8_t svhadd_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u32_x)))
+svuint32_t svhadd_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u64_x)))
+svuint64_t svhadd_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u16_x)))
+svuint16_t svhadd_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u8_z)))
+svuint8_t svhadd_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u32_z)))
+svuint32_t svhadd_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u64_z)))
+svuint64_t svhadd_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u16_z)))
+svuint16_t svhadd_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s8_m)))
+svint8_t svhadd_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s32_m)))
+svint32_t svhadd_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s64_m)))
+svint64_t svhadd_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s16_m)))
+svint16_t svhadd_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s8_x)))
+svint8_t svhadd_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s32_x)))
+svint32_t svhadd_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s64_x)))
+svint64_t svhadd_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s16_x)))
+svint16_t svhadd_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s8_z)))
+svint8_t svhadd_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s32_z)))
+svint32_t svhadd_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s64_z)))
+svint64_t svhadd_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s16_z)))
+svint16_t svhadd_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u8_m)))
+svuint8_t svhadd_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u32_m)))
+svuint32_t svhadd_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u64_m)))
+svuint64_t svhadd_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u16_m)))
+svuint16_t svhadd_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u8_x)))
+svuint8_t svhadd_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u32_x)))
+svuint32_t svhadd_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u64_x)))
+svuint64_t svhadd_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u16_x)))
+svuint16_t svhadd_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u8_z)))
+svuint8_t svhadd_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u32_z)))
+svuint32_t svhadd_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u64_z)))
+svuint64_t svhadd_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u16_z)))
+svuint16_t svhadd_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s8_m)))
+svint8_t svhsub_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s32_m)))
+svint32_t svhsub_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s64_m)))
+svint64_t svhsub_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s16_m)))
+svint16_t svhsub_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s8_x)))
+svint8_t svhsub_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s32_x)))
+svint32_t svhsub_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s64_x)))
+svint64_t svhsub_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s16_x)))
+svint16_t svhsub_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s8_z)))
+svint8_t svhsub_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s32_z)))
+svint32_t svhsub_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s64_z)))
+svint64_t svhsub_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s16_z)))
+svint16_t svhsub_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u8_m)))
+svuint8_t svhsub_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u32_m)))
+svuint32_t svhsub_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u64_m)))
+svuint64_t svhsub_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u16_m)))
+svuint16_t svhsub_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u8_x)))
+svuint8_t svhsub_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u32_x)))
+svuint32_t svhsub_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u64_x)))
+svuint64_t svhsub_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u16_x)))
+svuint16_t svhsub_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u8_z)))
+svuint8_t svhsub_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u32_z)))
+svuint32_t svhsub_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u64_z)))
+svuint64_t svhsub_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u16_z)))
+svuint16_t svhsub_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s8_m)))
+svint8_t svhsub_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s32_m)))
+svint32_t svhsub_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s64_m)))
+svint64_t svhsub_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s16_m)))
+svint16_t svhsub_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s8_x)))
+svint8_t svhsub_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s32_x)))
+svint32_t svhsub_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s64_x)))
+svint64_t svhsub_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s16_x)))
+svint16_t svhsub_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s8_z)))
+svint8_t svhsub_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s32_z)))
+svint32_t svhsub_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s64_z)))
+svint64_t svhsub_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s16_z)))
+svint16_t svhsub_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u8_m)))
+svuint8_t svhsub_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u32_m)))
+svuint32_t svhsub_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u64_m)))
+svuint64_t svhsub_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u16_m)))
+svuint16_t svhsub_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u8_x)))
+svuint8_t svhsub_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u32_x)))
+svuint32_t svhsub_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u64_x)))
+svuint64_t svhsub_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u16_x)))
+svuint16_t svhsub_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u8_z)))
+svuint8_t svhsub_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u32_z)))
+svuint32_t svhsub_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u64_z)))
+svuint64_t svhsub_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u16_z)))
+svuint16_t svhsub_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s8_m)))
+svint8_t svhsubr_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s32_m)))
+svint32_t svhsubr_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s64_m)))
+svint64_t svhsubr_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s16_m)))
+svint16_t svhsubr_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s8_x)))
+svint8_t svhsubr_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s32_x)))
+svint32_t svhsubr_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s64_x)))
+svint64_t svhsubr_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s16_x)))
+svint16_t svhsubr_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s8_z)))
+svint8_t svhsubr_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s32_z)))
+svint32_t svhsubr_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s64_z)))
+svint64_t svhsubr_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s16_z)))
+svint16_t svhsubr_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u8_m)))
+svuint8_t svhsubr_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u32_m)))
+svuint32_t svhsubr_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u64_m)))
+svuint64_t svhsubr_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u16_m)))
+svuint16_t svhsubr_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u8_x)))
+svuint8_t svhsubr_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u32_x)))
+svuint32_t svhsubr_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u64_x)))
+svuint64_t svhsubr_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u16_x)))
+svuint16_t svhsubr_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u8_z)))
+svuint8_t svhsubr_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u32_z)))
+svuint32_t svhsubr_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u64_z)))
+svuint64_t svhsubr_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u16_z)))
+svuint16_t svhsubr_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s8_m)))
+svint8_t svhsubr_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s32_m)))
+svint32_t svhsubr_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s64_m)))
+svint64_t svhsubr_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s16_m)))
+svint16_t svhsubr_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s8_x)))
+svint8_t svhsubr_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s32_x)))
+svint32_t svhsubr_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s64_x)))
+svint64_t svhsubr_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s16_x)))
+svint16_t svhsubr_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s8_z)))
+svint8_t svhsubr_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s32_z)))
+svint32_t svhsubr_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s64_z)))
+svint64_t svhsubr_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s16_z)))
+svint16_t svhsubr_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u8_m)))
+svuint8_t svhsubr_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u32_m)))
+svuint32_t svhsubr_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u64_m)))
+svuint64_t svhsubr_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u16_m)))
+svuint16_t svhsubr_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u8_x)))
+svuint8_t svhsubr_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u32_x)))
+svuint32_t svhsubr_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u64_x)))
+svuint64_t svhsubr_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u16_x)))
+svuint16_t svhsubr_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u8_z)))
+svuint8_t svhsubr_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u32_z)))
+svuint32_t svhsubr_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u64_z)))
+svuint64_t svhsubr_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u16_z)))
+svuint16_t svhsubr_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f64_m)))
+svint64_t svlogb_m(svint64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f32_m)))
+svint32_t svlogb_m(svint32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f16_m)))
+svint16_t svlogb_m(svint16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f64_x)))
+svint64_t svlogb_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f32_x)))
+svint32_t svlogb_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f16_x)))
+svint16_t svlogb_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f64_z)))
+svint64_t svlogb_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f32_z)))
+svint32_t svlogb_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f16_z)))
+svint16_t svlogb_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f64_m)))
+svfloat64_t svmaxnmp_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f32_m)))
+svfloat32_t svmaxnmp_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f16_m)))
+svfloat16_t svmaxnmp_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f64_x)))
+svfloat64_t svmaxnmp_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f32_x)))
+svfloat32_t svmaxnmp_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f16_x)))
+svfloat16_t svmaxnmp_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f64_m)))
+svfloat64_t svmaxp_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f32_m)))
+svfloat32_t svmaxp_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f16_m)))
+svfloat16_t svmaxp_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f64_x)))
+svfloat64_t svmaxp_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f32_x)))
+svfloat32_t svmaxp_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f16_x)))
+svfloat16_t svmaxp_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s8_m)))
+svint8_t svmaxp_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s32_m)))
+svint32_t svmaxp_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s64_m)))
+svint64_t svmaxp_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s16_m)))
+svint16_t svmaxp_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s8_x)))
+svint8_t svmaxp_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s32_x)))
+svint32_t svmaxp_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s64_x)))
+svint64_t svmaxp_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s16_x)))
+svint16_t svmaxp_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u8_m)))
+svuint8_t svmaxp_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u32_m)))
+svuint32_t svmaxp_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u64_m)))
+svuint64_t svmaxp_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u16_m)))
+svuint16_t svmaxp_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u8_x)))
+svuint8_t svmaxp_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u32_x)))
+svuint32_t svmaxp_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u64_x)))
+svuint64_t svmaxp_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u16_x)))
+svuint16_t svmaxp_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f64_m)))
+svfloat64_t svminnmp_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f32_m)))
+svfloat32_t svminnmp_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f16_m)))
+svfloat16_t svminnmp_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f64_x)))
+svfloat64_t svminnmp_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f32_x)))
+svfloat32_t svminnmp_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f16_x)))
+svfloat16_t svminnmp_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f64_m)))
+svfloat64_t svminp_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f32_m)))
+svfloat32_t svminp_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f16_m)))
+svfloat16_t svminp_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f64_x)))
+svfloat64_t svminp_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f32_x)))
+svfloat32_t svminp_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f16_x)))
+svfloat16_t svminp_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s8_m)))
+svint8_t svminp_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s32_m)))
+svint32_t svminp_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s64_m)))
+svint64_t svminp_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s16_m)))
+svint16_t svminp_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s8_x)))
+svint8_t svminp_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s32_x)))
+svint32_t svminp_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s64_x)))
+svint64_t svminp_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s16_x)))
+svint16_t svminp_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u8_m)))
+svuint8_t svminp_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u32_m)))
+svuint32_t svminp_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u64_m)))
+svuint64_t svminp_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u16_m)))
+svuint16_t svminp_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u8_x)))
+svuint8_t svminp_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u32_x)))
+svuint32_t svminp_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u64_x)))
+svuint64_t svminp_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u16_x)))
+svuint16_t svminp_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_u32)))
+svuint32_t svmla_lane(svuint32_t, svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_u64)))
+svuint64_t svmla_lane(svuint64_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_u16)))
+svuint16_t svmla_lane(svuint16_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_s32)))
+svint32_t svmla_lane(svint32_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_s64)))
+svint64_t svmla_lane(svint64_t, svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_s16)))
+svint16_t svmla_lane(svint16_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_f32)))
+svfloat32_t svmlalb(svfloat32_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_s32)))
+svint32_t svmlalb(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_s64)))
+svint64_t svmlalb(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_s16)))
+svint16_t svmlalb(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_u32)))
+svuint32_t svmlalb(svuint32_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_u64)))
+svuint64_t svmlalb(svuint64_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_u16)))
+svuint16_t svmlalb(svuint16_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_f32)))
+svfloat32_t svmlalb(svfloat32_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_s32)))
+svint32_t svmlalb(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_s64)))
+svint64_t svmlalb(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_s16)))
+svint16_t svmlalb(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_u32)))
+svuint32_t svmlalb(svuint32_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_u64)))
+svuint64_t svmlalb(svuint64_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_u16)))
+svuint16_t svmlalb(svuint16_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_f32)))
+svfloat32_t svmlalb_lane(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_s32)))
+svint32_t svmlalb_lane(svint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_s64)))
+svint64_t svmlalb_lane(svint64_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_u32)))
+svuint32_t svmlalb_lane(svuint32_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_u64)))
+svuint64_t svmlalb_lane(svuint64_t, svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_f32)))
+svfloat32_t svmlalt(svfloat32_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_s32)))
+svint32_t svmlalt(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_s64)))
+svint64_t svmlalt(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_s16)))
+svint16_t svmlalt(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_u32)))
+svuint32_t svmlalt(svuint32_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_u64)))
+svuint64_t svmlalt(svuint64_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_u16)))
+svuint16_t svmlalt(svuint16_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_f32)))
+svfloat32_t svmlalt(svfloat32_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_s32)))
+svint32_t svmlalt(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_s64)))
+svint64_t svmlalt(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_s16)))
+svint16_t svmlalt(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_u32)))
+svuint32_t svmlalt(svuint32_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_u64)))
+svuint64_t svmlalt(svuint64_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_u16)))
+svuint16_t svmlalt(svuint16_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_f32)))
+svfloat32_t svmlalt_lane(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_s32)))
+svint32_t svmlalt_lane(svint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_s64)))
+svint64_t svmlalt_lane(svint64_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_u32)))
+svuint32_t svmlalt_lane(svuint32_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_u64)))
+svuint64_t svmlalt_lane(svuint64_t, svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_u32)))
+svuint32_t svmls_lane(svuint32_t, svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_u64)))
+svuint64_t svmls_lane(svuint64_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_u16)))
+svuint16_t svmls_lane(svuint16_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_s32)))
+svint32_t svmls_lane(svint32_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_s64)))
+svint64_t svmls_lane(svint64_t, svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_s16)))
+svint16_t svmls_lane(svint16_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_f32)))
+svfloat32_t svmlslb(svfloat32_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_s32)))
+svint32_t svmlslb(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_s64)))
+svint64_t svmlslb(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_s16)))
+svint16_t svmlslb(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_u32)))
+svuint32_t svmlslb(svuint32_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_u64)))
+svuint64_t svmlslb(svuint64_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_u16)))
+svuint16_t svmlslb(svuint16_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_f32)))
+svfloat32_t svmlslb(svfloat32_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_s32)))
+svint32_t svmlslb(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_s64)))
+svint64_t svmlslb(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_s16)))
+svint16_t svmlslb(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_u32)))
+svuint32_t svmlslb(svuint32_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_u64)))
+svuint64_t svmlslb(svuint64_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_u16)))
+svuint16_t svmlslb(svuint16_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_f32)))
+svfloat32_t svmlslb_lane(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_s32)))
+svint32_t svmlslb_lane(svint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_s64)))
+svint64_t svmlslb_lane(svint64_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_u32)))
+svuint32_t svmlslb_lane(svuint32_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_u64)))
+svuint64_t svmlslb_lane(svuint64_t, svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_f32)))
+svfloat32_t svmlslt(svfloat32_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_s32)))
+svint32_t svmlslt(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_s64)))
+svint64_t svmlslt(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_s16)))
+svint16_t svmlslt(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_u32)))
+svuint32_t svmlslt(svuint32_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_u64)))
+svuint64_t svmlslt(svuint64_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_u16)))
+svuint16_t svmlslt(svuint16_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_f32)))
+svfloat32_t svmlslt(svfloat32_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_s32)))
+svint32_t svmlslt(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_s64)))
+svint64_t svmlslt(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_s16)))
+svint16_t svmlslt(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_u32)))
+svuint32_t svmlslt(svuint32_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_u64)))
+svuint64_t svmlslt(svuint64_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_u16)))
+svuint16_t svmlslt(svuint16_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_f32)))
+svfloat32_t svmlslt_lane(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_s32)))
+svint32_t svmlslt_lane(svint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_s64)))
+svint64_t svmlslt_lane(svint64_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_u32)))
+svuint32_t svmlslt_lane(svuint32_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_u64)))
+svuint64_t svmlslt_lane(svuint64_t, svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_s32)))
+svint32_t svmovlb(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_s64)))
+svint64_t svmovlb(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_s16)))
+svint16_t svmovlb(svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_u32)))
+svuint32_t svmovlb(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_u64)))
+svuint64_t svmovlb(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_u16)))
+svuint16_t svmovlb(svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_s32)))
+svint32_t svmovlt(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_s64)))
+svint64_t svmovlt(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_s16)))
+svint16_t svmovlt(svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_u32)))
+svuint32_t svmovlt(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_u64)))
+svuint64_t svmovlt(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_u16)))
+svuint16_t svmovlt(svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_u32)))
+svuint32_t svmul_lane(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_u64)))
+svuint64_t svmul_lane(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_u16)))
+svuint16_t svmul_lane(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_s32)))
+svint32_t svmul_lane(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_s64)))
+svint64_t svmul_lane(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_s16)))
+svint16_t svmul_lane(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_s32)))
+svint32_t svmullb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_s64)))
+svint64_t svmullb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_s16)))
+svint16_t svmullb(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_u32)))
+svuint32_t svmullb(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_u64)))
+svuint64_t svmullb(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_u16)))
+svuint16_t svmullb(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_s32)))
+svint32_t svmullb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_s64)))
+svint64_t svmullb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_s16)))
+svint16_t svmullb(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_u32)))
+svuint32_t svmullb(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_u64)))
+svuint64_t svmullb(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_u16)))
+svuint16_t svmullb(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_s32)))
+svint32_t svmullb_lane(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_s64)))
+svint64_t svmullb_lane(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_u32)))
+svuint32_t svmullb_lane(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_u64)))
+svuint64_t svmullb_lane(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_s32)))
+svint32_t svmullt(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_s64)))
+svint64_t svmullt(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_s16)))
+svint16_t svmullt(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_u32)))
+svuint32_t svmullt(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_u64)))
+svuint64_t svmullt(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_u16)))
+svuint16_t svmullt(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_s32)))
+svint32_t svmullt(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_s64)))
+svint64_t svmullt(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_s16)))
+svint16_t svmullt(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_u32)))
+svuint32_t svmullt(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_u64)))
+svuint64_t svmullt(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_u16)))
+svuint16_t svmullt(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_s32)))
+svint32_t svmullt_lane(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_s64)))
+svint64_t svmullt_lane(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_u32)))
+svuint32_t svmullt_lane(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_u64)))
+svuint64_t svmullt_lane(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u8)))
+svuint8_t svnbsl(svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u32)))
+svuint32_t svnbsl(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u64)))
+svuint64_t svnbsl(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u16)))
+svuint16_t svnbsl(svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s8)))
+svint8_t svnbsl(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s32)))
+svint32_t svnbsl(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s64)))
+svint64_t svnbsl(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s16)))
+svint16_t svnbsl(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u8)))
+svuint8_t svnbsl(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u32)))
+svuint32_t svnbsl(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u64)))
+svuint64_t svnbsl(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u16)))
+svuint16_t svnbsl(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s8)))
+svint8_t svnbsl(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s32)))
+svint32_t svnbsl(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s64)))
+svint64_t svnbsl(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s16)))
+svint16_t svnbsl(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmul_n_u8)))
+svuint8_t svpmul(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmul_u8)))
+svuint8_t svpmul(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_n_u64)))
+svuint64_t svpmullb(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_n_u16)))
+svuint16_t svpmullb(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_u64)))
+svuint64_t svpmullb(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_u16)))
+svuint16_t svpmullb(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_n_u8)))
+svuint8_t svpmullb_pair(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_n_u32)))
+svuint32_t svpmullb_pair(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_u8)))
+svuint8_t svpmullb_pair(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_u32)))
+svuint32_t svpmullb_pair(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_n_u64)))
+svuint64_t svpmullt(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_n_u16)))
+svuint16_t svpmullt(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_u64)))
+svuint64_t svpmullt(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_u16)))
+svuint16_t svpmullt(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_n_u8)))
+svuint8_t svpmullt_pair(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_n_u32)))
+svuint32_t svpmullt_pair(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_u8)))
+svuint8_t svpmullt_pair(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_u32)))
+svuint32_t svpmullt_pair(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s8_m)))
+svint8_t svqabs_m(svint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s32_m)))
+svint32_t svqabs_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s64_m)))
+svint64_t svqabs_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s16_m)))
+svint16_t svqabs_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s8_x)))
+svint8_t svqabs_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s32_x)))
+svint32_t svqabs_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s64_x)))
+svint64_t svqabs_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s16_x)))
+svint16_t svqabs_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s8_z)))
+svint8_t svqabs_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s32_z)))
+svint32_t svqabs_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s64_z)))
+svint64_t svqabs_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s16_z)))
+svint16_t svqabs_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8_m)))
+svint8_t svqadd_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32_m)))
+svint32_t svqadd_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64_m)))
+svint64_t svqadd_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16_m)))
+svint16_t svqadd_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8_x)))
+svint8_t svqadd_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32_x)))
+svint32_t svqadd_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64_x)))
+svint64_t svqadd_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16_x)))
+svint16_t svqadd_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8_z)))
+svint8_t svqadd_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32_z)))
+svint32_t svqadd_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64_z)))
+svint64_t svqadd_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16_z)))
+svint16_t svqadd_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8_m)))
+svuint8_t svqadd_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32_m)))
+svuint32_t svqadd_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64_m)))
+svuint64_t svqadd_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16_m)))
+svuint16_t svqadd_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8_x)))
+svuint8_t svqadd_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32_x)))
+svuint32_t svqadd_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64_x)))
+svuint64_t svqadd_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16_x)))
+svuint16_t svqadd_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8_z)))
+svuint8_t svqadd_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32_z)))
+svuint32_t svqadd_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64_z)))
+svuint64_t svqadd_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16_z)))
+svuint16_t svqadd_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8_m)))
+svint8_t svqadd_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32_m)))
+svint32_t svqadd_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64_m)))
+svint64_t svqadd_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16_m)))
+svint16_t svqadd_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8_x)))
+svint8_t svqadd_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32_x)))
+svint32_t svqadd_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64_x)))
+svint64_t svqadd_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16_x)))
+svint16_t svqadd_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8_z)))
+svint8_t svqadd_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32_z)))
+svint32_t svqadd_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64_z)))
+svint64_t svqadd_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16_z)))
+svint16_t svqadd_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8_m)))
+svuint8_t svqadd_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32_m)))
+svuint32_t svqadd_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64_m)))
+svuint64_t svqadd_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16_m)))
+svuint16_t svqadd_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8_x)))
+svuint8_t svqadd_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32_x)))
+svuint32_t svqadd_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64_x)))
+svuint64_t svqadd_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16_x)))
+svuint16_t svqadd_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8_z)))
+svuint8_t svqadd_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32_z)))
+svuint32_t svqadd_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64_z)))
+svuint64_t svqadd_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16_z)))
+svuint16_t svqadd_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s8)))
+svint8_t svqcadd(svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s32)))
+svint32_t svqcadd(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s64)))
+svint64_t svqcadd(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s16)))
+svint16_t svqcadd(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_n_s32)))
+svint32_t svqdmlalb(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_n_s64)))
+svint64_t svqdmlalb(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_n_s16)))
+svint16_t svqdmlalb(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_s32)))
+svint32_t svqdmlalb(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_s64)))
+svint64_t svqdmlalb(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_s16)))
+svint16_t svqdmlalb(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_lane_s32)))
+svint32_t svqdmlalb_lane(svint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_lane_s64)))
+svint64_t svqdmlalb_lane(svint64_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_n_s32)))
+svint32_t svqdmlalbt(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_n_s64)))
+svint64_t svqdmlalbt(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_n_s16)))
+svint16_t svqdmlalbt(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_s32)))
+svint32_t svqdmlalbt(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_s64)))
+svint64_t svqdmlalbt(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_s16)))
+svint16_t svqdmlalbt(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_n_s32)))
+svint32_t svqdmlalt(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_n_s64)))
+svint64_t svqdmlalt(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_n_s16)))
+svint16_t svqdmlalt(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_s32)))
+svint32_t svqdmlalt(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_s64)))
+svint64_t svqdmlalt(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_s16)))
+svint16_t svqdmlalt(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_lane_s32)))
+svint32_t svqdmlalt_lane(svint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_lane_s64)))
+svint64_t svqdmlalt_lane(svint64_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_n_s32)))
+svint32_t svqdmlslb(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_n_s64)))
+svint64_t svqdmlslb(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_n_s16)))
+svint16_t svqdmlslb(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_s32)))
+svint32_t svqdmlslb(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_s64)))
+svint64_t svqdmlslb(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_s16)))
+svint16_t svqdmlslb(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_lane_s32)))
+svint32_t svqdmlslb_lane(svint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_lane_s64)))
+svint64_t svqdmlslb_lane(svint64_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_n_s32)))
+svint32_t svqdmlslbt(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_n_s64)))
+svint64_t svqdmlslbt(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_n_s16)))
+svint16_t svqdmlslbt(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_s32)))
+svint32_t svqdmlslbt(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_s64)))
+svint64_t svqdmlslbt(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_s16)))
+svint16_t svqdmlslbt(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_n_s32)))
+svint32_t svqdmlslt(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_n_s64)))
+svint64_t svqdmlslt(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_n_s16)))
+svint16_t svqdmlslt(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_s32)))
+svint32_t svqdmlslt(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_s64)))
+svint64_t svqdmlslt(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_s16)))
+svint16_t svqdmlslt(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_lane_s32)))
+svint32_t svqdmlslt_lane(svint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_lane_s64)))
+svint64_t svqdmlslt_lane(svint64_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s8)))
+svint8_t svqdmulh(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s32)))
+svint32_t svqdmulh(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s64)))
+svint64_t svqdmulh(svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s16)))
+svint16_t svqdmulh(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s8)))
+svint8_t svqdmulh(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s32)))
+svint32_t svqdmulh(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s64)))
+svint64_t svqdmulh(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s16)))
+svint16_t svqdmulh(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_lane_s32)))
+svint32_t svqdmulh_lane(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_lane_s64)))
+svint64_t svqdmulh_lane(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_lane_s16)))
+svint16_t svqdmulh_lane(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_n_s32)))
+svint32_t svqdmullb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_n_s64)))
+svint64_t svqdmullb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_n_s16)))
+svint16_t svqdmullb(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_s32)))
+svint32_t svqdmullb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_s64)))
+svint64_t svqdmullb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_s16)))
+svint16_t svqdmullb(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_lane_s32)))
+svint32_t svqdmullb_lane(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_lane_s64)))
+svint64_t svqdmullb_lane(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_n_s32)))
+svint32_t svqdmullt(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_n_s64)))
+svint64_t svqdmullt(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_n_s16)))
+svint16_t svqdmullt(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_s32)))
+svint32_t svqdmullt(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_s64)))
+svint64_t svqdmullt(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_s16)))
+svint16_t svqdmullt(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_lane_s32)))
+svint32_t svqdmullt_lane(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_lane_s64)))
+svint64_t svqdmullt_lane(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s8_m)))
+svint8_t svqneg_m(svint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s32_m)))
+svint32_t svqneg_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s64_m)))
+svint64_t svqneg_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s16_m)))
+svint16_t svqneg_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s8_x)))
+svint8_t svqneg_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s32_x)))
+svint32_t svqneg_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s64_x)))
+svint64_t svqneg_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s16_x)))
+svint16_t svqneg_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s8_z)))
+svint8_t svqneg_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s32_z)))
+svint32_t svqneg_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s64_z)))
+svint64_t svqneg_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s16_z)))
+svint16_t svqneg_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s8)))
+svint8_t svqrdcmlah(svint8_t, svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s32)))
+svint32_t svqrdcmlah(svint32_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s64)))
+svint64_t svqrdcmlah(svint64_t, svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s16)))
+svint16_t svqrdcmlah(svint16_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_lane_s32)))
+svint32_t svqrdcmlah_lane(svint32_t, svint32_t, svint32_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_lane_s16)))
+svint16_t svqrdcmlah_lane(svint16_t, svint16_t, svint16_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s8)))
+svint8_t svqrdmlah(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s32)))
+svint32_t svqrdmlah(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s64)))
+svint64_t svqrdmlah(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s16)))
+svint16_t svqrdmlah(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s8)))
+svint8_t svqrdmlah(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s32)))
+svint32_t svqrdmlah(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s64)))
+svint64_t svqrdmlah(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s16)))
+svint16_t svqrdmlah(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_lane_s32)))
+svint32_t svqrdmlah_lane(svint32_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_lane_s64)))
+svint64_t svqrdmlah_lane(svint64_t, svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_lane_s16)))
+svint16_t svqrdmlah_lane(svint16_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s8)))
+svint8_t svqrdmlsh(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s32)))
+svint32_t svqrdmlsh(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s64)))
+svint64_t svqrdmlsh(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s16)))
+svint16_t svqrdmlsh(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s8)))
+svint8_t svqrdmlsh(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s32)))
+svint32_t svqrdmlsh(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s64)))
+svint64_t svqrdmlsh(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s16)))
+svint16_t svqrdmlsh(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_lane_s32)))
+svint32_t svqrdmlsh_lane(svint32_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_lane_s64)))
+svint64_t svqrdmlsh_lane(svint64_t, svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_lane_s16)))
+svint16_t svqrdmlsh_lane(svint16_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s8)))
+svint8_t svqrdmulh(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s32)))
+svint32_t svqrdmulh(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s64)))
+svint64_t svqrdmulh(svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s16)))
+svint16_t svqrdmulh(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s8)))
+svint8_t svqrdmulh(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s32)))
+svint32_t svqrdmulh(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s64)))
+svint64_t svqrdmulh(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s16)))
+svint16_t svqrdmulh(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_lane_s32)))
+svint32_t svqrdmulh_lane(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_lane_s64)))
+svint64_t svqrdmulh_lane(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_lane_s16)))
+svint16_t svqrdmulh_lane(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s8_m)))
+svint8_t svqrshl_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s32_m)))
+svint32_t svqrshl_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s64_m)))
+svint64_t svqrshl_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s16_m)))
+svint16_t svqrshl_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s8_x)))
+svint8_t svqrshl_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s32_x)))
+svint32_t svqrshl_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s64_x)))
+svint64_t svqrshl_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s16_x)))
+svint16_t svqrshl_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s8_z)))
+svint8_t svqrshl_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s32_z)))
+svint32_t svqrshl_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s64_z)))
+svint64_t svqrshl_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s16_z)))
+svint16_t svqrshl_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u8_m)))
+svuint8_t svqrshl_m(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u32_m)))
+svuint32_t svqrshl_m(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u64_m)))
+svuint64_t svqrshl_m(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u16_m)))
+svuint16_t svqrshl_m(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u8_x)))
+svuint8_t svqrshl_x(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u32_x)))
+svuint32_t svqrshl_x(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u64_x)))
+svuint64_t svqrshl_x(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u16_x)))
+svuint16_t svqrshl_x(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u8_z)))
+svuint8_t svqrshl_z(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u32_z)))
+svuint32_t svqrshl_z(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u64_z)))
+svuint64_t svqrshl_z(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u16_z)))
+svuint16_t svqrshl_z(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s8_m)))
+svint8_t svqrshl_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s32_m)))
+svint32_t svqrshl_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s64_m)))
+svint64_t svqrshl_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s16_m)))
+svint16_t svqrshl_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s8_x)))
+svint8_t svqrshl_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s32_x)))
+svint32_t svqrshl_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s64_x)))
+svint64_t svqrshl_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s16_x)))
+svint16_t svqrshl_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s8_z)))
+svint8_t svqrshl_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s32_z)))
+svint32_t svqrshl_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s64_z)))
+svint64_t svqrshl_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s16_z)))
+svint16_t svqrshl_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u8_m)))
+svuint8_t svqrshl_m(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u32_m)))
+svuint32_t svqrshl_m(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u64_m)))
+svuint64_t svqrshl_m(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u16_m)))
+svuint16_t svqrshl_m(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u8_x)))
+svuint8_t svqrshl_x(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u32_x)))
+svuint32_t svqrshl_x(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u64_x)))
+svuint64_t svqrshl_x(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u16_x)))
+svuint16_t svqrshl_x(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u8_z)))
+svuint8_t svqrshl_z(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u32_z)))
+svuint32_t svqrshl_z(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u64_z)))
+svuint64_t svqrshl_z(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u16_z)))
+svuint16_t svqrshl_z(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_s32)))
+svint16_t svqrshrnb(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_s64)))
+svint32_t svqrshrnb(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_s16)))
+svint8_t svqrshrnb(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_u32)))
+svuint16_t svqrshrnb(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_u64)))
+svuint32_t svqrshrnb(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_u16)))
+svuint8_t svqrshrnb(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_s32)))
+svint16_t svqrshrnt(svint16_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_s64)))
+svint32_t svqrshrnt(svint32_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_s16)))
+svint8_t svqrshrnt(svint8_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_u32)))
+svuint16_t svqrshrnt(svuint16_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_u64)))
+svuint32_t svqrshrnt(svuint32_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_u16)))
+svuint8_t svqrshrnt(svuint8_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunb_n_s32)))
+svuint16_t svqrshrunb(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunb_n_s64)))
+svuint32_t svqrshrunb(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunb_n_s16)))
+svuint8_t svqrshrunb(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunt_n_s32)))
+svuint16_t svqrshrunt(svuint16_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunt_n_s64)))
+svuint32_t svqrshrunt(svuint32_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunt_n_s16)))
+svuint8_t svqrshrunt(svuint8_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s8_m)))
+svint8_t svqshl_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s32_m)))
+svint32_t svqshl_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s64_m)))
+svint64_t svqshl_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s16_m)))
+svint16_t svqshl_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s8_x)))
+svint8_t svqshl_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s32_x)))
+svint32_t svqshl_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s64_x)))
+svint64_t svqshl_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s16_x)))
+svint16_t svqshl_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s8_z)))
+svint8_t svqshl_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s32_z)))
+svint32_t svqshl_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s64_z)))
+svint64_t svqshl_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s16_z)))
+svint16_t svqshl_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u8_m)))
+svuint8_t svqshl_m(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u32_m)))
+svuint32_t svqshl_m(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u64_m)))
+svuint64_t svqshl_m(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u16_m)))
+svuint16_t svqshl_m(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u8_x)))
+svuint8_t svqshl_x(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u32_x)))
+svuint32_t svqshl_x(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u64_x)))
+svuint64_t svqshl_x(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u16_x)))
+svuint16_t svqshl_x(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u8_z)))
+svuint8_t svqshl_z(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u32_z)))
+svuint32_t svqshl_z(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u64_z)))
+svuint64_t svqshl_z(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u16_z)))
+svuint16_t svqshl_z(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s8_m)))
+svint8_t svqshl_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s32_m)))
+svint32_t svqshl_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s64_m)))
+svint64_t svqshl_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s16_m)))
+svint16_t svqshl_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s8_x)))
+svint8_t svqshl_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s32_x)))
+svint32_t svqshl_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s64_x)))
+svint64_t svqshl_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s16_x)))
+svint16_t svqshl_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s8_z)))
+svint8_t svqshl_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s32_z)))
+svint32_t svqshl_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s64_z)))
+svint64_t svqshl_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s16_z)))
+svint16_t svqshl_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u8_m)))
+svuint8_t svqshl_m(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u32_m)))
+svuint32_t svqshl_m(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u64_m)))
+svuint64_t svqshl_m(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u16_m)))
+svuint16_t svqshl_m(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u8_x)))
+svuint8_t svqshl_x(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u32_x)))
+svuint32_t svqshl_x(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u64_x)))
+svuint64_t svqshl_x(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u16_x)))
+svuint16_t svqshl_x(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u8_z)))
+svuint8_t svqshl_z(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u32_z)))
+svuint32_t svqshl_z(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u64_z)))
+svuint64_t svqshl_z(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u16_z)))
+svuint16_t svqshl_z(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s8_m)))
+svuint8_t svqshlu_m(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s32_m)))
+svuint32_t svqshlu_m(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s64_m)))
+svuint64_t svqshlu_m(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s16_m)))
+svuint16_t svqshlu_m(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s8_x)))
+svuint8_t svqshlu_x(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s32_x)))
+svuint32_t svqshlu_x(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s64_x)))
+svuint64_t svqshlu_x(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s16_x)))
+svuint16_t svqshlu_x(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s8_z)))
+svuint8_t svqshlu_z(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s32_z)))
+svuint32_t svqshlu_z(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s64_z)))
+svuint64_t svqshlu_z(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s16_z)))
+svuint16_t svqshlu_z(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_s32)))
+svint16_t svqshrnb(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_s64)))
+svint32_t svqshrnb(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_s16)))
+svint8_t svqshrnb(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_u32)))
+svuint16_t svqshrnb(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_u64)))
+svuint32_t svqshrnb(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_u16)))
+svuint8_t svqshrnb(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_s32)))
+svint16_t svqshrnt(svint16_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_s64)))
+svint32_t svqshrnt(svint32_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_s16)))
+svint8_t svqshrnt(svint8_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_u32)))
+svuint16_t svqshrnt(svuint16_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_u64)))
+svuint32_t svqshrnt(svuint32_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_u16)))
+svuint8_t svqshrnt(svuint8_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunb_n_s32)))
+svuint16_t svqshrunb(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunb_n_s64)))
+svuint32_t svqshrunb(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunb_n_s16)))
+svuint8_t svqshrunb(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunt_n_s32)))
+svuint16_t svqshrunt(svuint16_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunt_n_s64)))
+svuint32_t svqshrunt(svuint32_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunt_n_s16)))
+svuint8_t svqshrunt(svuint8_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8_m)))
+svint8_t svqsub_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32_m)))
+svint32_t svqsub_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64_m)))
+svint64_t svqsub_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16_m)))
+svint16_t svqsub_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8_x)))
+svint8_t svqsub_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32_x)))
+svint32_t svqsub_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64_x)))
+svint64_t svqsub_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16_x)))
+svint16_t svqsub_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8_z)))
+svint8_t svqsub_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32_z)))
+svint32_t svqsub_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64_z)))
+svint64_t svqsub_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16_z)))
+svint16_t svqsub_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8_m)))
+svuint8_t svqsub_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32_m)))
+svuint32_t svqsub_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64_m)))
+svuint64_t svqsub_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16_m)))
+svuint16_t svqsub_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8_x)))
+svuint8_t svqsub_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32_x)))
+svuint32_t svqsub_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64_x)))
+svuint64_t svqsub_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16_x)))
+svuint16_t svqsub_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8_z)))
+svuint8_t svqsub_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32_z)))
+svuint32_t svqsub_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64_z)))
+svuint64_t svqsub_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16_z)))
+svuint16_t svqsub_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8_m)))
+svint8_t svqsub_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32_m)))
+svint32_t svqsub_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64_m)))
+svint64_t svqsub_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16_m)))
+svint16_t svqsub_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8_x)))
+svint8_t svqsub_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32_x)))
+svint32_t svqsub_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64_x)))
+svint64_t svqsub_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16_x)))
+svint16_t svqsub_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8_z)))
+svint8_t svqsub_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32_z)))
+svint32_t svqsub_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64_z)))
+svint64_t svqsub_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16_z)))
+svint16_t svqsub_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8_m)))
+svuint8_t svqsub_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32_m)))
+svuint32_t svqsub_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64_m)))
+svuint64_t svqsub_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16_m)))
+svuint16_t svqsub_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8_x)))
+svuint8_t svqsub_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32_x)))
+svuint32_t svqsub_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64_x)))
+svuint64_t svqsub_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16_x)))
+svuint16_t svqsub_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8_z)))
+svuint8_t svqsub_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32_z)))
+svuint32_t svqsub_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64_z)))
+svuint64_t svqsub_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16_z)))
+svuint16_t svqsub_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s8_m)))
+svint8_t svqsubr_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s32_m)))
+svint32_t svqsubr_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s64_m)))
+svint64_t svqsubr_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s16_m)))
+svint16_t svqsubr_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s8_x)))
+svint8_t svqsubr_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s32_x)))
+svint32_t svqsubr_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s64_x)))
+svint64_t svqsubr_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s16_x)))
+svint16_t svqsubr_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s8_z)))
+svint8_t svqsubr_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s32_z)))
+svint32_t svqsubr_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s64_z)))
+svint64_t svqsubr_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s16_z)))
+svint16_t svqsubr_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u8_m)))
+svuint8_t svqsubr_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u32_m)))
+svuint32_t svqsubr_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u64_m)))
+svuint64_t svqsubr_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u16_m)))
+svuint16_t svqsubr_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u8_x)))
+svuint8_t svqsubr_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u32_x)))
+svuint32_t svqsubr_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u64_x)))
+svuint64_t svqsubr_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u16_x)))
+svuint16_t svqsubr_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u8_z)))
+svuint8_t svqsubr_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u32_z)))
+svuint32_t svqsubr_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u64_z)))
+svuint64_t svqsubr_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u16_z)))
+svuint16_t svqsubr_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s8_m)))
+svint8_t svqsubr_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s32_m)))
+svint32_t svqsubr_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s64_m)))
+svint64_t svqsubr_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s16_m)))
+svint16_t svqsubr_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s8_x)))
+svint8_t svqsubr_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s32_x)))
+svint32_t svqsubr_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s64_x)))
+svint64_t svqsubr_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s16_x)))
+svint16_t svqsubr_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s8_z)))
+svint8_t svqsubr_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s32_z)))
+svint32_t svqsubr_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s64_z)))
+svint64_t svqsubr_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s16_z)))
+svint16_t svqsubr_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u8_m)))
+svuint8_t svqsubr_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u32_m)))
+svuint32_t svqsubr_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u64_m)))
+svuint64_t svqsubr_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u16_m)))
+svuint16_t svqsubr_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u8_x)))
+svuint8_t svqsubr_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u32_x)))
+svuint32_t svqsubr_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u64_x)))
+svuint64_t svqsubr_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u16_x)))
+svuint16_t svqsubr_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u8_z)))
+svuint8_t svqsubr_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u32_z)))
+svuint32_t svqsubr_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u64_z)))
+svuint64_t svqsubr_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u16_z)))
+svuint16_t svqsubr_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_s32)))
+svint16_t svqxtnb(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_s64)))
+svint32_t svqxtnb(svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_s16)))
+svint8_t svqxtnb(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_u32)))
+svuint16_t svqxtnb(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_u64)))
+svuint32_t svqxtnb(svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_u16)))
+svuint8_t svqxtnb(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_s32)))
+svint16_t svqxtnt(svint16_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_s64)))
+svint32_t svqxtnt(svint32_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_s16)))
+svint8_t svqxtnt(svint8_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_u32)))
+svuint16_t svqxtnt(svuint16_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_u64)))
+svuint32_t svqxtnt(svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_u16)))
+svuint8_t svqxtnt(svuint8_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunb_s32)))
+svuint16_t svqxtunb(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunb_s64)))
+svuint32_t svqxtunb(svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunb_s16)))
+svuint8_t svqxtunb(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunt_s32)))
+svuint16_t svqxtunt(svuint16_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunt_s64)))
+svuint32_t svqxtunt(svuint32_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunt_s16)))
+svuint8_t svqxtunt(svuint8_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_u32)))
+svuint16_t svraddhnb(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_u64)))
+svuint32_t svraddhnb(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_u16)))
+svuint8_t svraddhnb(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_s32)))
+svint16_t svraddhnb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_s64)))
+svint32_t svraddhnb(svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_s16)))
+svint8_t svraddhnb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_u32)))
+svuint16_t svraddhnb(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_u64)))
+svuint32_t svraddhnb(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_u16)))
+svuint8_t svraddhnb(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_s32)))
+svint16_t svraddhnb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_s64)))
+svint32_t svraddhnb(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_s16)))
+svint8_t svraddhnb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_u32)))
+svuint16_t svraddhnt(svuint16_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_u64)))
+svuint32_t svraddhnt(svuint32_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_u16)))
+svuint8_t svraddhnt(svuint8_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_s32)))
+svint16_t svraddhnt(svint16_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_s64)))
+svint32_t svraddhnt(svint32_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_s16)))
+svint8_t svraddhnt(svint8_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_u32)))
+svuint16_t svraddhnt(svuint16_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_u64)))
+svuint32_t svraddhnt(svuint32_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_u16)))
+svuint8_t svraddhnt(svuint8_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_s32)))
+svint16_t svraddhnt(svint16_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_s64)))
+svint32_t svraddhnt(svint32_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_s16)))
+svint8_t svraddhnt(svint8_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_u32_m)))
+svuint32_t svrecpe_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_u32_x)))
+svuint32_t svrecpe_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_u32_z)))
+svuint32_t svrecpe_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s8_m)))
+svint8_t svrhadd_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s32_m)))
+svint32_t svrhadd_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s64_m)))
+svint64_t svrhadd_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s16_m)))
+svint16_t svrhadd_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s8_x)))
+svint8_t svrhadd_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s32_x)))
+svint32_t svrhadd_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s64_x)))
+svint64_t svrhadd_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s16_x)))
+svint16_t svrhadd_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s8_z)))
+svint8_t svrhadd_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s32_z)))
+svint32_t svrhadd_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s64_z)))
+svint64_t svrhadd_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s16_z)))
+svint16_t svrhadd_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u8_m)))
+svuint8_t svrhadd_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u32_m)))
+svuint32_t svrhadd_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u64_m)))
+svuint64_t svrhadd_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u16_m)))
+svuint16_t svrhadd_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u8_x)))
+svuint8_t svrhadd_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u32_x)))
+svuint32_t svrhadd_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u64_x)))
+svuint64_t svrhadd_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u16_x)))
+svuint16_t svrhadd_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u8_z)))
+svuint8_t svrhadd_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u32_z)))
+svuint32_t svrhadd_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u64_z)))
+svuint64_t svrhadd_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u16_z)))
+svuint16_t svrhadd_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s8_m)))
+svint8_t svrhadd_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s32_m)))
+svint32_t svrhadd_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s64_m)))
+svint64_t svrhadd_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s16_m)))
+svint16_t svrhadd_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s8_x)))
+svint8_t svrhadd_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s32_x)))
+svint32_t svrhadd_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s64_x)))
+svint64_t svrhadd_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s16_x)))
+svint16_t svrhadd_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s8_z)))
+svint8_t svrhadd_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s32_z)))
+svint32_t svrhadd_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s64_z)))
+svint64_t svrhadd_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s16_z)))
+svint16_t svrhadd_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u8_m)))
+svuint8_t svrhadd_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u32_m)))
+svuint32_t svrhadd_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u64_m)))
+svuint64_t svrhadd_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u16_m)))
+svuint16_t svrhadd_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u8_x)))
+svuint8_t svrhadd_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u32_x)))
+svuint32_t svrhadd_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u64_x)))
+svuint64_t svrhadd_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u16_x)))
+svuint16_t svrhadd_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u8_z)))
+svuint8_t svrhadd_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u32_z)))
+svuint32_t svrhadd_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u64_z)))
+svuint64_t svrhadd_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u16_z)))
+svuint16_t svrhadd_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s8_m)))
+svint8_t svrshl_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s32_m)))
+svint32_t svrshl_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s64_m)))
+svint64_t svrshl_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s16_m)))
+svint16_t svrshl_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s8_x)))
+svint8_t svrshl_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s32_x)))
+svint32_t svrshl_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s64_x)))
+svint64_t svrshl_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s16_x)))
+svint16_t svrshl_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s8_z)))
+svint8_t svrshl_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s32_z)))
+svint32_t svrshl_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s64_z)))
+svint64_t svrshl_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s16_z)))
+svint16_t svrshl_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u8_m)))
+svuint8_t svrshl_m(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u32_m)))
+svuint32_t svrshl_m(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u64_m)))
+svuint64_t svrshl_m(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u16_m)))
+svuint16_t svrshl_m(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u8_x)))
+svuint8_t svrshl_x(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u32_x)))
+svuint32_t svrshl_x(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u64_x)))
+svuint64_t svrshl_x(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u16_x)))
+svuint16_t svrshl_x(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u8_z)))
+svuint8_t svrshl_z(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u32_z)))
+svuint32_t svrshl_z(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u64_z)))
+svuint64_t svrshl_z(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u16_z)))
+svuint16_t svrshl_z(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_m)))
+svint8_t svrshl_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_m)))
+svint32_t svrshl_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_m)))
+svint64_t svrshl_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_m)))
+svint16_t svrshl_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_x)))
+svint8_t svrshl_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_x)))
+svint32_t svrshl_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_x)))
+svint64_t svrshl_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_x)))
+svint16_t svrshl_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_z)))
+svint8_t svrshl_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_z)))
+svint32_t svrshl_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_z)))
+svint64_t svrshl_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_z)))
+svint16_t svrshl_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_m)))
+svuint8_t svrshl_m(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_m)))
+svuint32_t svrshl_m(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_m)))
+svuint64_t svrshl_m(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_m)))
+svuint16_t svrshl_m(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_x)))
+svuint8_t svrshl_x(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_x)))
+svuint32_t svrshl_x(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_x)))
+svuint64_t svrshl_x(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_x)))
+svuint16_t svrshl_x(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_z)))
+svuint8_t svrshl_z(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_z)))
+svuint32_t svrshl_z(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_z)))
+svuint64_t svrshl_z(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_z)))
+svuint16_t svrshl_z(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s8_m)))
+svint8_t svrshr_m(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s32_m)))
+svint32_t svrshr_m(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s64_m)))
+svint64_t svrshr_m(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s16_m)))
+svint16_t svrshr_m(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u8_m)))
+svuint8_t svrshr_m(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u32_m)))
+svuint32_t svrshr_m(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u64_m)))
+svuint64_t svrshr_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u16_m)))
+svuint16_t svrshr_m(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s8_x)))
+svint8_t svrshr_x(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s32_x)))
+svint32_t svrshr_x(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s64_x)))
+svint64_t svrshr_x(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s16_x)))
+svint16_t svrshr_x(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u8_x)))
+svuint8_t svrshr_x(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u32_x)))
+svuint32_t svrshr_x(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u64_x)))
+svuint64_t svrshr_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u16_x)))
+svuint16_t svrshr_x(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s8_z)))
+svint8_t svrshr_z(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s32_z)))
+svint32_t svrshr_z(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s64_z)))
+svint64_t svrshr_z(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s16_z)))
+svint16_t svrshr_z(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u8_z)))
+svuint8_t svrshr_z(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u32_z)))
+svuint32_t svrshr_z(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u64_z)))
+svuint64_t svrshr_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u16_z)))
+svuint16_t svrshr_z(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_u32)))
+svuint16_t svrshrnb(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_u64)))
+svuint32_t svrshrnb(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_u16)))
+svuint8_t svrshrnb(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_s32)))
+svint16_t svrshrnb(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_s64)))
+svint32_t svrshrnb(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_s16)))
+svint8_t svrshrnb(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_u32)))
+svuint16_t svrshrnt(svuint16_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_u64)))
+svuint32_t svrshrnt(svuint32_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_u16)))
+svuint8_t svrshrnt(svuint8_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_s32)))
+svint16_t svrshrnt(svint16_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_s64)))
+svint32_t svrshrnt(svint32_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_s16)))
+svint8_t svrshrnt(svint8_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_u32_m)))
+svuint32_t svrsqrte_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_u32_x)))
+svuint32_t svrsqrte_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_u32_z)))
+svuint32_t svrsqrte_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s8)))
+svint8_t svrsra(svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s32)))
+svint32_t svrsra(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s64)))
+svint64_t svrsra(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s16)))
+svint16_t svrsra(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u8)))
+svuint8_t svrsra(svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u32)))
+svuint32_t svrsra(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u64)))
+svuint64_t svrsra(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u16)))
+svuint16_t svrsra(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_u32)))
+svuint16_t svrsubhnb(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_u64)))
+svuint32_t svrsubhnb(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_u16)))
+svuint8_t svrsubhnb(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_s32)))
+svint16_t svrsubhnb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_s64)))
+svint32_t svrsubhnb(svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_s16)))
+svint8_t svrsubhnb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_u32)))
+svuint16_t svrsubhnb(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_u64)))
+svuint32_t svrsubhnb(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_u16)))
+svuint8_t svrsubhnb(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_s32)))
+svint16_t svrsubhnb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_s64)))
+svint32_t svrsubhnb(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_s16)))
+svint8_t svrsubhnb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_u32)))
+svuint16_t svrsubhnt(svuint16_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_u64)))
+svuint32_t svrsubhnt(svuint32_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_u16)))
+svuint8_t svrsubhnt(svuint8_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_s32)))
+svint16_t svrsubhnt(svint16_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_s64)))
+svint32_t svrsubhnt(svint32_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_s16)))
+svint8_t svrsubhnt(svint8_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_u32)))
+svuint16_t svrsubhnt(svuint16_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_u64)))
+svuint32_t svrsubhnt(svuint32_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_u16)))
+svuint8_t svrsubhnt(svuint8_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_s32)))
+svint16_t svrsubhnt(svint16_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_s64)))
+svint32_t svrsubhnt(svint32_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_s16)))
+svint8_t svrsubhnt(svint8_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_n_u32)))
+svuint32_t svsbclb(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_n_u64)))
+svuint64_t svsbclb(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_u32)))
+svuint32_t svsbclb(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_u64)))
+svuint64_t svsbclb(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_n_u32)))
+svuint32_t svsbclt(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_n_u64)))
+svuint64_t svsbclt(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_u32)))
+svuint32_t svsbclt(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_u64)))
+svuint64_t svsbclt(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_s32)))
+svint32_t svshllb(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_s64)))
+svint64_t svshllb(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_s16)))
+svint16_t svshllb(svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_u32)))
+svuint32_t svshllb(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_u64)))
+svuint64_t svshllb(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_u16)))
+svuint16_t svshllb(svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_s32)))
+svint32_t svshllt(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_s64)))
+svint64_t svshllt(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_s16)))
+svint16_t svshllt(svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_u32)))
+svuint32_t svshllt(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_u64)))
+svuint64_t svshllt(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_u16)))
+svuint16_t svshllt(svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_u32)))
+svuint16_t svshrnb(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_u64)))
+svuint32_t svshrnb(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_u16)))
+svuint8_t svshrnb(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_s32)))
+svint16_t svshrnb(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_s64)))
+svint32_t svshrnb(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_s16)))
+svint8_t svshrnb(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_u32)))
+svuint16_t svshrnt(svuint16_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_u64)))
+svuint32_t svshrnt(svuint32_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_u16)))
+svuint8_t svshrnt(svuint8_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_s32)))
+svint16_t svshrnt(svint16_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_s64)))
+svint32_t svshrnt(svint32_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_s16)))
+svint8_t svshrnt(svint8_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u8)))
+svuint8_t svsli(svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u32)))
+svuint32_t svsli(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u64)))
+svuint64_t svsli(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u16)))
+svuint16_t svsli(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s8)))
+svint8_t svsli(svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s32)))
+svint32_t svsli(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s64)))
+svint64_t svsli(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s16)))
+svint16_t svsli(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u8_m)))
+svuint8_t svsqadd_m(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u32_m)))
+svuint32_t svsqadd_m(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u64_m)))
+svuint64_t svsqadd_m(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u16_m)))
+svuint16_t svsqadd_m(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u8_x)))
+svuint8_t svsqadd_x(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u32_x)))
+svuint32_t svsqadd_x(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u64_x)))
+svuint64_t svsqadd_x(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u16_x)))
+svuint16_t svsqadd_x(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u8_z)))
+svuint8_t svsqadd_z(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u32_z)))
+svuint32_t svsqadd_z(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u64_z)))
+svuint64_t svsqadd_z(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u16_z)))
+svuint16_t svsqadd_z(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u8_m)))
+svuint8_t svsqadd_m(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u32_m)))
+svuint32_t svsqadd_m(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u64_m)))
+svuint64_t svsqadd_m(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u16_m)))
+svuint16_t svsqadd_m(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u8_x)))
+svuint8_t svsqadd_x(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u32_x)))
+svuint32_t svsqadd_x(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u64_x)))
+svuint64_t svsqadd_x(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u16_x)))
+svuint16_t svsqadd_x(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u8_z)))
+svuint8_t svsqadd_z(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u32_z)))
+svuint32_t svsqadd_z(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u64_z)))
+svuint64_t svsqadd_z(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u16_z)))
+svuint16_t svsqadd_z(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s8)))
+svint8_t svsra(svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s32)))
+svint32_t svsra(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s64)))
+svint64_t svsra(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s16)))
+svint16_t svsra(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u8)))
+svuint8_t svsra(svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u32)))
+svuint32_t svsra(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u64)))
+svuint64_t svsra(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u16)))
+svuint16_t svsra(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u8)))
+svuint8_t svsri(svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u32)))
+svuint32_t svsri(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u64)))
+svuint64_t svsri(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u16)))
+svuint16_t svsri(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s8)))
+svint8_t svsri(svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s32)))
+svint32_t svsri(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s64)))
+svint64_t svsri(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s16)))
+svint16_t svsri(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_u32)))
+svuint16_t svsubhnb(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_u64)))
+svuint32_t svsubhnb(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_u16)))
+svuint8_t svsubhnb(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_s32)))
+svint16_t svsubhnb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_s64)))
+svint32_t svsubhnb(svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_s16)))
+svint8_t svsubhnb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_u32)))
+svuint16_t svsubhnb(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_u64)))
+svuint32_t svsubhnb(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_u16)))
+svuint8_t svsubhnb(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_s32)))
+svint16_t svsubhnb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_s64)))
+svint32_t svsubhnb(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_s16)))
+svint8_t svsubhnb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_u32)))
+svuint16_t svsubhnt(svuint16_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_u64)))
+svuint32_t svsubhnt(svuint32_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_u16)))
+svuint8_t svsubhnt(svuint8_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_s32)))
+svint16_t svsubhnt(svint16_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_s64)))
+svint32_t svsubhnt(svint32_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_s16)))
+svint8_t svsubhnt(svint8_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_u32)))
+svuint16_t svsubhnt(svuint16_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_u64)))
+svuint32_t svsubhnt(svuint32_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_u16)))
+svuint8_t svsubhnt(svuint8_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_s32)))
+svint16_t svsubhnt(svint16_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_s64)))
+svint32_t svsubhnt(svint32_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_s16)))
+svint8_t svsubhnt(svint8_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_s32)))
+svint32_t svsublb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_s64)))
+svint64_t svsublb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_s16)))
+svint16_t svsublb(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_u32)))
+svuint32_t svsublb(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_u64)))
+svuint64_t svsublb(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_u16)))
+svuint16_t svsublb(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_s32)))
+svint32_t svsublb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_s64)))
+svint64_t svsublb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_s16)))
+svint16_t svsublb(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_u32)))
+svuint32_t svsublb(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_u64)))
+svuint64_t svsublb(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_u16)))
+svuint16_t svsublb(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_n_s32)))
+svint32_t svsublbt(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_n_s64)))
+svint64_t svsublbt(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_n_s16)))
+svint16_t svsublbt(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_s32)))
+svint32_t svsublbt(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_s64)))
+svint64_t svsublbt(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_s16)))
+svint16_t svsublbt(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_s32)))
+svint32_t svsublt(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_s64)))
+svint64_t svsublt(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_s16)))
+svint16_t svsublt(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_u32)))
+svuint32_t svsublt(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_u64)))
+svuint64_t svsublt(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_u16)))
+svuint16_t svsublt(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_s32)))
+svint32_t svsublt(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_s64)))
+svint64_t svsublt(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_s16)))
+svint16_t svsublt(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_u32)))
+svuint32_t svsublt(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_u64)))
+svuint64_t svsublt(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_u16)))
+svuint16_t svsublt(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_n_s32)))
+svint32_t svsubltb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_n_s64)))
+svint64_t svsubltb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_n_s16)))
+svint16_t svsubltb(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_s32)))
+svint32_t svsubltb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_s64)))
+svint64_t svsubltb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_s16)))
+svint16_t svsubltb(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_s32)))
+svint32_t svsubwb(svint32_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_s64)))
+svint64_t svsubwb(svint64_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_s16)))
+svint16_t svsubwb(svint16_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_u32)))
+svuint32_t svsubwb(svuint32_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_u64)))
+svuint64_t svsubwb(svuint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_u16)))
+svuint16_t svsubwb(svuint16_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_s32)))
+svint32_t svsubwb(svint32_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_s64)))
+svint64_t svsubwb(svint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_s16)))
+svint16_t svsubwb(svint16_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_u32)))
+svuint32_t svsubwb(svuint32_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_u64)))
+svuint64_t svsubwb(svuint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_u16)))
+svuint16_t svsubwb(svuint16_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_s32)))
+svint32_t svsubwt(svint32_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_s64)))
+svint64_t svsubwt(svint64_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_s16)))
+svint16_t svsubwt(svint16_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_u32)))
+svuint32_t svsubwt(svuint32_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_u64)))
+svuint64_t svsubwt(svuint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_u16)))
+svuint16_t svsubwt(svuint16_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_s32)))
+svint32_t svsubwt(svint32_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_s64)))
+svint64_t svsubwt(svint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_s16)))
+svint16_t svsubwt(svint16_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_u32)))
+svuint32_t svsubwt(svuint32_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_u64)))
+svuint64_t svsubwt(svuint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_u16)))
+svuint16_t svsubwt(svuint16_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u8)))
+svuint8_t svtbl2(svuint8x2_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u32)))
+svuint32_t svtbl2(svuint32x2_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u64)))
+svuint64_t svtbl2(svuint64x2_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u16)))
+svuint16_t svtbl2(svuint16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s8)))
+svint8_t svtbl2(svint8x2_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_f64)))
+svfloat64_t svtbl2(svfloat64x2_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_f32)))
+svfloat32_t svtbl2(svfloat32x2_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_f16)))
+svfloat16_t svtbl2(svfloat16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s32)))
+svint32_t svtbl2(svint32x2_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s64)))
+svint64_t svtbl2(svint64x2_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s16)))
+svint16_t svtbl2(svint16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u8)))
+svuint8_t svtbx(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u32)))
+svuint32_t svtbx(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u64)))
+svuint64_t svtbx(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u16)))
+svuint16_t svtbx(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s8)))
+svint8_t svtbx(svint8_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_f64)))
+svfloat64_t svtbx(svfloat64_t, svfloat64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_f32)))
+svfloat32_t svtbx(svfloat32_t, svfloat32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_f16)))
+svfloat16_t svtbx(svfloat16_t, svfloat16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s32)))
+svint32_t svtbx(svint32_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s64)))
+svint64_t svtbx(svint64_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s16)))
+svint16_t svtbx(svint16_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s8_m)))
+svint8_t svuqadd_m(svbool_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s32_m)))
+svint32_t svuqadd_m(svbool_t, svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s64_m)))
+svint64_t svuqadd_m(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s16_m)))
+svint16_t svuqadd_m(svbool_t, svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s8_x)))
+svint8_t svuqadd_x(svbool_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s32_x)))
+svint32_t svuqadd_x(svbool_t, svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s64_x)))
+svint64_t svuqadd_x(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s16_x)))
+svint16_t svuqadd_x(svbool_t, svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s8_z)))
+svint8_t svuqadd_z(svbool_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s32_z)))
+svint32_t svuqadd_z(svbool_t, svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s64_z)))
+svint64_t svuqadd_z(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s16_z)))
+svint16_t svuqadd_z(svbool_t, svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s8_m)))
+svint8_t svuqadd_m(svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s32_m)))
+svint32_t svuqadd_m(svbool_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s64_m)))
+svint64_t svuqadd_m(svbool_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s16_m)))
+svint16_t svuqadd_m(svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s8_x)))
+svint8_t svuqadd_x(svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s32_x)))
+svint32_t svuqadd_x(svbool_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s64_x)))
+svint64_t svuqadd_x(svbool_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s16_x)))
+svint16_t svuqadd_x(svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s8_z)))
+svint8_t svuqadd_z(svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s32_z)))
+svint32_t svuqadd_z(svbool_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s64_z)))
+svint64_t svuqadd_z(svbool_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s16_z)))
+svint16_t svuqadd_z(svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_s32)))
+svbool_t svwhilege_b8(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_s32)))
+svbool_t svwhilege_b32(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_s32)))
+svbool_t svwhilege_b64(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_s32)))
+svbool_t svwhilege_b16(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_s64)))
+svbool_t svwhilege_b8(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_s64)))
+svbool_t svwhilege_b32(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_s64)))
+svbool_t svwhilege_b64(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_s64)))
+svbool_t svwhilege_b16(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_u32)))
+svbool_t svwhilege_b8(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_u32)))
+svbool_t svwhilege_b32(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_u32)))
+svbool_t svwhilege_b64(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_u32)))
+svbool_t svwhilege_b16(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_u64)))
+svbool_t svwhilege_b8(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_u64)))
+svbool_t svwhilege_b32(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_u64)))
+svbool_t svwhilege_b64(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_u64)))
+svbool_t svwhilege_b16(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_s32)))
+svbool_t svwhilegt_b8(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_s32)))
+svbool_t svwhilegt_b32(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_s32)))
+svbool_t svwhilegt_b64(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_s32)))
+svbool_t svwhilegt_b16(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_s64)))
+svbool_t svwhilegt_b8(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_s64)))
+svbool_t svwhilegt_b32(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_s64)))
+svbool_t svwhilegt_b64(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_s64)))
+svbool_t svwhilegt_b16(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_u32)))
+svbool_t svwhilegt_b8(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_u32)))
+svbool_t svwhilegt_b32(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_u32)))
+svbool_t svwhilegt_b64(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_u32)))
+svbool_t svwhilegt_b16(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_u64)))
+svbool_t svwhilegt_b8(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_u64)))
+svbool_t svwhilegt_b32(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_u64)))
+svbool_t svwhilegt_b64(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_u64)))
+svbool_t svwhilegt_b16(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u8)))
+svbool_t svwhilerw(uint8_t const *, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s8)))
+svbool_t svwhilerw(int8_t const *, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u64)))
+svbool_t svwhilerw(uint64_t const *, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_f64)))
+svbool_t svwhilerw(float64_t const *, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s64)))
+svbool_t svwhilerw(int64_t const *, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u16)))
+svbool_t svwhilerw(uint16_t const *, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_f16)))
+svbool_t svwhilerw(float16_t const *, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s16)))
+svbool_t svwhilerw(int16_t const *, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u32)))
+svbool_t svwhilerw(uint32_t const *, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_f32)))
+svbool_t svwhilerw(float32_t const *, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s32)))
+svbool_t svwhilerw(int32_t const *, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u8)))
+svbool_t svwhilewr(uint8_t const *, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s8)))
+svbool_t svwhilewr(int8_t const *, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u64)))
+svbool_t svwhilewr(uint64_t const *, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_f64)))
+svbool_t svwhilewr(float64_t const *, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s64)))
+svbool_t svwhilewr(int64_t const *, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u16)))
+svbool_t svwhilewr(uint16_t const *, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_f16)))
+svbool_t svwhilewr(float16_t const *, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s16)))
+svbool_t svwhilewr(int16_t const *, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u32)))
+svbool_t svwhilewr(uint32_t const *, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_f32)))
+svbool_t svwhilewr(float32_t const *, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s32)))
+svbool_t svwhilewr(int32_t const *, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u8)))
+svuint8_t svxar(svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u32)))
+svuint32_t svxar(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u64)))
+svuint64_t svxar(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u16)))
+svuint16_t svxar(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s8)))
+svint8_t svxar(svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s32)))
+svint32_t svxar(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s64)))
+svint64_t svxar(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s16)))
+svint16_t svxar(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f64_m)))
+svfloat64_t svabd_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f32_m)))
+svfloat32_t svabd_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f16_m)))
+svfloat16_t svabd_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f64_x)))
+svfloat64_t svabd_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f32_x)))
+svfloat32_t svabd_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f16_x)))
+svfloat16_t svabd_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f64_z)))
+svfloat64_t svabd_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f32_z)))
+svfloat32_t svabd_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f16_z)))
+svfloat16_t svabd_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s8_m)))
+svint8_t svabd_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s32_m)))
+svint32_t svabd_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s64_m)))
+svint64_t svabd_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s16_m)))
+svint16_t svabd_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s8_x)))
+svint8_t svabd_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s32_x)))
+svint32_t svabd_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s64_x)))
+svint64_t svabd_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s16_x)))
+svint16_t svabd_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s8_z)))
+svint8_t svabd_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s32_z)))
+svint32_t svabd_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s64_z)))
+svint64_t svabd_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s16_z)))
+svint16_t svabd_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u8_m)))
+svuint8_t svabd_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u32_m)))
+svuint32_t svabd_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u64_m)))
+svuint64_t svabd_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u16_m)))
+svuint16_t svabd_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u8_x)))
+svuint8_t svabd_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u32_x)))
+svuint32_t svabd_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u64_x)))
+svuint64_t svabd_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u16_x)))
+svuint16_t svabd_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u8_z)))
+svuint8_t svabd_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u32_z)))
+svuint32_t svabd_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u64_z)))
+svuint64_t svabd_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u16_z)))
+svuint16_t svabd_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f64_m)))
+svfloat64_t svabd_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f32_m)))
+svfloat32_t svabd_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f16_m)))
+svfloat16_t svabd_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f64_x)))
+svfloat64_t svabd_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f32_x)))
+svfloat32_t svabd_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f16_x)))
+svfloat16_t svabd_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f64_z)))
+svfloat64_t svabd_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f32_z)))
+svfloat32_t svabd_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f16_z)))
+svfloat16_t svabd_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s8_m)))
+svint8_t svabd_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s32_m)))
+svint32_t svabd_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s64_m)))
+svint64_t svabd_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s16_m)))
+svint16_t svabd_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s8_x)))
+svint8_t svabd_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s32_x)))
+svint32_t svabd_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s64_x)))
+svint64_t svabd_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s16_x)))
+svint16_t svabd_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s8_z)))
+svint8_t svabd_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s32_z)))
+svint32_t svabd_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s64_z)))
+svint64_t svabd_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s16_z)))
+svint16_t svabd_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u8_m)))
+svuint8_t svabd_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u32_m)))
+svuint32_t svabd_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u64_m)))
+svuint64_t svabd_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u16_m)))
+svuint16_t svabd_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u8_x)))
+svuint8_t svabd_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u32_x)))
+svuint32_t svabd_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u64_x)))
+svuint64_t svabd_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u16_x)))
+svuint16_t svabd_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u8_z)))
+svuint8_t svabd_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u32_z)))
+svuint32_t svabd_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u64_z)))
+svuint64_t svabd_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u16_z)))
+svuint16_t svabd_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f64_m)))
+svfloat64_t svabs_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f32_m)))
+svfloat32_t svabs_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f16_m)))
+svfloat16_t svabs_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f64_x)))
+svfloat64_t svabs_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f32_x)))
+svfloat32_t svabs_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f16_x)))
+svfloat16_t svabs_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f64_z)))
+svfloat64_t svabs_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f32_z)))
+svfloat32_t svabs_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f16_z)))
+svfloat16_t svabs_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s8_m)))
+svint8_t svabs_s8_m(svint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s32_m)))
+svint32_t svabs_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s64_m)))
+svint64_t svabs_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s16_m)))
+svint16_t svabs_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s8_x)))
+svint8_t svabs_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s32_x)))
+svint32_t svabs_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s64_x)))
+svint64_t svabs_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s16_x)))
+svint16_t svabs_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s8_z)))
+svint8_t svabs_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s32_z)))
+svint32_t svabs_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s64_z)))
+svint64_t svabs_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s16_z)))
+svint16_t svabs_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_n_f64)))
+svbool_t svacge_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_n_f32)))
+svbool_t svacge_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_n_f16)))
+svbool_t svacge_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_f64)))
+svbool_t svacge_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_f32)))
+svbool_t svacge_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_f16)))
+svbool_t svacge_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_n_f64)))
+svbool_t svacgt_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_n_f32)))
+svbool_t svacgt_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_n_f16)))
+svbool_t svacgt_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_f64)))
+svbool_t svacgt_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_f32)))
+svbool_t svacgt_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_f16)))
+svbool_t svacgt_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_n_f64)))
+svbool_t svacle_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_n_f32)))
+svbool_t svacle_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_n_f16)))
+svbool_t svacle_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_f64)))
+svbool_t svacle_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_f32)))
+svbool_t svacle_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_f16)))
+svbool_t svacle_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_n_f64)))
+svbool_t svaclt_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_n_f32)))
+svbool_t svaclt_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_n_f16)))
+svbool_t svaclt_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_f64)))
+svbool_t svaclt_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_f32)))
+svbool_t svaclt_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_f16)))
+svbool_t svaclt_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f64_m)))
+svfloat64_t svadd_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f32_m)))
+svfloat32_t svadd_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f16_m)))
+svfloat16_t svadd_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f64_x)))
+svfloat64_t svadd_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f32_x)))
+svfloat32_t svadd_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f16_x)))
+svfloat16_t svadd_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f64_z)))
+svfloat64_t svadd_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f32_z)))
+svfloat32_t svadd_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f16_z)))
+svfloat16_t svadd_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u8_m)))
+svuint8_t svadd_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u32_m)))
+svuint32_t svadd_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u64_m)))
+svuint64_t svadd_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u16_m)))
+svuint16_t svadd_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s8_m)))
+svint8_t svadd_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s32_m)))
+svint32_t svadd_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s64_m)))
+svint64_t svadd_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s16_m)))
+svint16_t svadd_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u8_x)))
+svuint8_t svadd_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u32_x)))
+svuint32_t svadd_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u64_x)))
+svuint64_t svadd_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u16_x)))
+svuint16_t svadd_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s8_x)))
+svint8_t svadd_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s32_x)))
+svint32_t svadd_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s64_x)))
+svint64_t svadd_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s16_x)))
+svint16_t svadd_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u8_z)))
+svuint8_t svadd_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u32_z)))
+svuint32_t svadd_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u64_z)))
+svuint64_t svadd_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u16_z)))
+svuint16_t svadd_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s8_z)))
+svint8_t svadd_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s32_z)))
+svint32_t svadd_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s64_z)))
+svint64_t svadd_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s16_z)))
+svint16_t svadd_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f64_m)))
+svfloat64_t svadd_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f32_m)))
+svfloat32_t svadd_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f16_m)))
+svfloat16_t svadd_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f64_x)))
+svfloat64_t svadd_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f32_x)))
+svfloat32_t svadd_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f16_x)))
+svfloat16_t svadd_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f64_z)))
+svfloat64_t svadd_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f32_z)))
+svfloat32_t svadd_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f16_z)))
+svfloat16_t svadd_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u8_m)))
+svuint8_t svadd_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u32_m)))
+svuint32_t svadd_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u64_m)))
+svuint64_t svadd_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u16_m)))
+svuint16_t svadd_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s8_m)))
+svint8_t svadd_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s32_m)))
+svint32_t svadd_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s64_m)))
+svint64_t svadd_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s16_m)))
+svint16_t svadd_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u8_x)))
+svuint8_t svadd_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u32_x)))
+svuint32_t svadd_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u64_x)))
+svuint64_t svadd_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u16_x)))
+svuint16_t svadd_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s8_x)))
+svint8_t svadd_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s32_x)))
+svint32_t svadd_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s64_x)))
+svint64_t svadd_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s16_x)))
+svint16_t svadd_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u8_z)))
+svuint8_t svadd_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u32_z)))
+svuint32_t svadd_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u64_z)))
+svuint64_t svadd_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u16_z)))
+svuint16_t svadd_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s8_z)))
+svint8_t svadd_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s32_z)))
+svint32_t svadd_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s64_z)))
+svint64_t svadd_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s16_z)))
+svint16_t svadd_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadda_f64)))
+float64_t svadda_f64(svbool_t, float64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadda_f32)))
+float32_t svadda_f32(svbool_t, float32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadda_f16)))
+float16_t svadda_f16(svbool_t, float16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s8)))
+int64_t svaddv_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s32)))
+int64_t svaddv_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s64)))
+int64_t svaddv_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s16)))
+int64_t svaddv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u8)))
+uint64_t svaddv_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u32)))
+uint64_t svaddv_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u64)))
+uint64_t svaddv_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u16)))
+uint64_t svaddv_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_f64)))
+float64_t svaddv_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_f32)))
+float32_t svaddv_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_f16)))
+float16_t svaddv_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_b_z)))
+svbool_t svand_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u8_m)))
+svuint8_t svand_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u32_m)))
+svuint32_t svand_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u64_m)))
+svuint64_t svand_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u16_m)))
+svuint16_t svand_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s8_m)))
+svint8_t svand_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s32_m)))
+svint32_t svand_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s64_m)))
+svint64_t svand_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s16_m)))
+svint16_t svand_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u8_x)))
+svuint8_t svand_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u32_x)))
+svuint32_t svand_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u64_x)))
+svuint64_t svand_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u16_x)))
+svuint16_t svand_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s8_x)))
+svint8_t svand_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s32_x)))
+svint32_t svand_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s64_x)))
+svint64_t svand_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s16_x)))
+svint16_t svand_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u8_z)))
+svuint8_t svand_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u32_z)))
+svuint32_t svand_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u64_z)))
+svuint64_t svand_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u16_z)))
+svuint16_t svand_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s8_z)))
+svint8_t svand_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s32_z)))
+svint32_t svand_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s64_z)))
+svint64_t svand_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s16_z)))
+svint16_t svand_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u8_m)))
+svuint8_t svand_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u32_m)))
+svuint32_t svand_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u64_m)))
+svuint64_t svand_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u16_m)))
+svuint16_t svand_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s8_m)))
+svint8_t svand_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s32_m)))
+svint32_t svand_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s64_m)))
+svint64_t svand_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s16_m)))
+svint16_t svand_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u8_x)))
+svuint8_t svand_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u32_x)))
+svuint32_t svand_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u64_x)))
+svuint64_t svand_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u16_x)))
+svuint16_t svand_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s8_x)))
+svint8_t svand_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s32_x)))
+svint32_t svand_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s64_x)))
+svint64_t svand_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s16_x)))
+svint16_t svand_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u8_z)))
+svuint8_t svand_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u32_z)))
+svuint32_t svand_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u64_z)))
+svuint64_t svand_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u16_z)))
+svuint16_t svand_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s8_z)))
+svint8_t svand_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s32_z)))
+svint32_t svand_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s64_z)))
+svint64_t svand_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s16_z)))
+svint16_t svand_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u8)))
+uint8_t svandv_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u32)))
+uint32_t svandv_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u64)))
+uint64_t svandv_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u16)))
+uint16_t svandv_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s8)))
+int8_t svandv_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s32)))
+int32_t svandv_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s64)))
+int64_t svandv_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s16)))
+int16_t svandv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s8_m)))
+svint8_t svasr_n_s8_m(svbool_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s32_m)))
+svint32_t svasr_n_s32_m(svbool_t, svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s64_m)))
+svint64_t svasr_n_s64_m(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s16_m)))
+svint16_t svasr_n_s16_m(svbool_t, svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s8_x)))
+svint8_t svasr_n_s8_x(svbool_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s32_x)))
+svint32_t svasr_n_s32_x(svbool_t, svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s64_x)))
+svint64_t svasr_n_s64_x(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s16_x)))
+svint16_t svasr_n_s16_x(svbool_t, svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s8_z)))
+svint8_t svasr_n_s8_z(svbool_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s32_z)))
+svint32_t svasr_n_s32_z(svbool_t, svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s64_z)))
+svint64_t svasr_n_s64_z(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s16_z)))
+svint16_t svasr_n_s16_z(svbool_t, svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s8_m)))
+svint8_t svasr_s8_m(svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s32_m)))
+svint32_t svasr_s32_m(svbool_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s64_m)))
+svint64_t svasr_s64_m(svbool_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s16_m)))
+svint16_t svasr_s16_m(svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s8_x)))
+svint8_t svasr_s8_x(svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s32_x)))
+svint32_t svasr_s32_x(svbool_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s64_x)))
+svint64_t svasr_s64_x(svbool_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s16_x)))
+svint16_t svasr_s16_x(svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s8_z)))
+svint8_t svasr_s8_z(svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s32_z)))
+svint32_t svasr_s32_z(svbool_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s64_z)))
+svint64_t svasr_s64_z(svbool_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s16_z)))
+svint16_t svasr_s16_z(svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s8_m)))
+svint8_t svasr_wide_n_s8_m(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s32_m)))
+svint32_t svasr_wide_n_s32_m(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s16_m)))
+svint16_t svasr_wide_n_s16_m(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s8_x)))
+svint8_t svasr_wide_n_s8_x(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s32_x)))
+svint32_t svasr_wide_n_s32_x(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s16_x)))
+svint16_t svasr_wide_n_s16_x(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s8_z)))
+svint8_t svasr_wide_n_s8_z(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s32_z)))
+svint32_t svasr_wide_n_s32_z(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s16_z)))
+svint16_t svasr_wide_n_s16_z(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s8_m)))
+svint8_t svasr_wide_s8_m(svbool_t, svint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s32_m)))
+svint32_t svasr_wide_s32_m(svbool_t, svint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s16_m)))
+svint16_t svasr_wide_s16_m(svbool_t, svint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s8_x)))
+svint8_t svasr_wide_s8_x(svbool_t, svint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s32_x)))
+svint32_t svasr_wide_s32_x(svbool_t, svint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s16_x)))
+svint16_t svasr_wide_s16_x(svbool_t, svint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s8_z)))
+svint8_t svasr_wide_s8_z(svbool_t, svint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s32_z)))
+svint32_t svasr_wide_s32_z(svbool_t, svint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s16_z)))
+svint16_t svasr_wide_s16_z(svbool_t, svint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s8_m)))
+svint8_t svasrd_n_s8_m(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s32_m)))
+svint32_t svasrd_n_s32_m(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s64_m)))
+svint64_t svasrd_n_s64_m(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s16_m)))
+svint16_t svasrd_n_s16_m(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s8_x)))
+svint8_t svasrd_n_s8_x(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s32_x)))
+svint32_t svasrd_n_s32_x(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s64_x)))
+svint64_t svasrd_n_s64_x(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s16_x)))
+svint16_t svasrd_n_s16_x(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s8_z)))
+svint8_t svasrd_n_s8_z(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s32_z)))
+svint32_t svasrd_n_s32_z(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s64_z)))
+svint64_t svasrd_n_s64_z(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s16_z)))
+svint16_t svasrd_n_s16_z(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_b_z)))
+svbool_t svbic_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u8_m)))
+svuint8_t svbic_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u32_m)))
+svuint32_t svbic_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u64_m)))
+svuint64_t svbic_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u16_m)))
+svuint16_t svbic_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s8_m)))
+svint8_t svbic_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s32_m)))
+svint32_t svbic_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s64_m)))
+svint64_t svbic_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s16_m)))
+svint16_t svbic_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u8_x)))
+svuint8_t svbic_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u32_x)))
+svuint32_t svbic_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u64_x)))
+svuint64_t svbic_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u16_x)))
+svuint16_t svbic_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s8_x)))
+svint8_t svbic_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s32_x)))
+svint32_t svbic_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s64_x)))
+svint64_t svbic_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s16_x)))
+svint16_t svbic_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u8_z)))
+svuint8_t svbic_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u32_z)))
+svuint32_t svbic_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u64_z)))
+svuint64_t svbic_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u16_z)))
+svuint16_t svbic_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s8_z)))
+svint8_t svbic_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s32_z)))
+svint32_t svbic_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s64_z)))
+svint64_t svbic_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s16_z)))
+svint16_t svbic_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u8_m)))
+svuint8_t svbic_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u32_m)))
+svuint32_t svbic_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u64_m)))
+svuint64_t svbic_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u16_m)))
+svuint16_t svbic_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s8_m)))
+svint8_t svbic_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s32_m)))
+svint32_t svbic_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s64_m)))
+svint64_t svbic_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s16_m)))
+svint16_t svbic_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u8_x)))
+svuint8_t svbic_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u32_x)))
+svuint32_t svbic_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u64_x)))
+svuint64_t svbic_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u16_x)))
+svuint16_t svbic_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s8_x)))
+svint8_t svbic_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s32_x)))
+svint32_t svbic_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s64_x)))
+svint64_t svbic_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s16_x)))
+svint16_t svbic_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u8_z)))
+svuint8_t svbic_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u32_z)))
+svuint32_t svbic_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u64_z)))
+svuint64_t svbic_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u16_z)))
+svuint16_t svbic_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s8_z)))
+svint8_t svbic_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s32_z)))
+svint32_t svbic_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s64_z)))
+svint64_t svbic_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s16_z)))
+svint16_t svbic_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrka_b_m)))
+svbool_t svbrka_b_m(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrka_b_z)))
+svbool_t svbrka_b_z(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkb_b_m)))
+svbool_t svbrkb_b_m(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkb_b_z)))
+svbool_t svbrkb_b_z(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkn_b_z)))
+svbool_t svbrkn_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkpa_b_z)))
+svbool_t svbrkpa_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkpb_b_z)))
+svbool_t svbrkpb_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f64_m)))
+svfloat64_t svcadd_f64_m(svbool_t, svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f32_m)))
+svfloat32_t svcadd_f32_m(svbool_t, svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f16_m)))
+svfloat16_t svcadd_f16_m(svbool_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f64_x)))
+svfloat64_t svcadd_f64_x(svbool_t, svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f32_x)))
+svfloat32_t svcadd_f32_x(svbool_t, svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f16_x)))
+svfloat16_t svcadd_f16_x(svbool_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f64_z)))
+svfloat64_t svcadd_f64_z(svbool_t, svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f32_z)))
+svfloat32_t svcadd_f32_z(svbool_t, svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f16_z)))
+svfloat16_t svcadd_f16_z(svbool_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u8)))
+uint8_t svclasta_n_u8(svbool_t, uint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u32)))
+uint32_t svclasta_n_u32(svbool_t, uint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u64)))
+uint64_t svclasta_n_u64(svbool_t, uint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u16)))
+uint16_t svclasta_n_u16(svbool_t, uint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s8)))
+int8_t svclasta_n_s8(svbool_t, int8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_f64)))
+float64_t svclasta_n_f64(svbool_t, float64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_f32)))
+float32_t svclasta_n_f32(svbool_t, float32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_f16)))
+float16_t svclasta_n_f16(svbool_t, float16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s32)))
+int32_t svclasta_n_s32(svbool_t, int32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s64)))
+int64_t svclasta_n_s64(svbool_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s16)))
+int16_t svclasta_n_s16(svbool_t, int16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u8)))
+svuint8_t svclasta_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u32)))
+svuint32_t svclasta_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u64)))
+svuint64_t svclasta_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u16)))
+svuint16_t svclasta_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s8)))
+svint8_t svclasta_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_f64)))
+svfloat64_t svclasta_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_f32)))
+svfloat32_t svclasta_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_f16)))
+svfloat16_t svclasta_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s32)))
+svint32_t svclasta_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s64)))
+svint64_t svclasta_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s16)))
+svint16_t svclasta_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u8)))
+uint8_t svclastb_n_u8(svbool_t, uint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u32)))
+uint32_t svclastb_n_u32(svbool_t, uint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u64)))
+uint64_t svclastb_n_u64(svbool_t, uint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u16)))
+uint16_t svclastb_n_u16(svbool_t, uint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s8)))
+int8_t svclastb_n_s8(svbool_t, int8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_f64)))
+float64_t svclastb_n_f64(svbool_t, float64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_f32)))
+float32_t svclastb_n_f32(svbool_t, float32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_f16)))
+float16_t svclastb_n_f16(svbool_t, float16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s32)))
+int32_t svclastb_n_s32(svbool_t, int32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s64)))
+int64_t svclastb_n_s64(svbool_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s16)))
+int16_t svclastb_n_s16(svbool_t, int16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u8)))
+svuint8_t svclastb_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u32)))
+svuint32_t svclastb_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u64)))
+svuint64_t svclastb_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u16)))
+svuint16_t svclastb_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s8)))
+svint8_t svclastb_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_f64)))
+svfloat64_t svclastb_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_f32)))
+svfloat32_t svclastb_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_f16)))
+svfloat16_t svclastb_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s32)))
+svint32_t svclastb_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s64)))
+svint64_t svclastb_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s16)))
+svint16_t svclastb_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s8_m)))
+svuint8_t svcls_s8_m(svuint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s32_m)))
+svuint32_t svcls_s32_m(svuint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s64_m)))
+svuint64_t svcls_s64_m(svuint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s16_m)))
+svuint16_t svcls_s16_m(svuint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s8_x)))
+svuint8_t svcls_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s32_x)))
+svuint32_t svcls_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s64_x)))
+svuint64_t svcls_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s16_x)))
+svuint16_t svcls_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s8_z)))
+svuint8_t svcls_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s32_z)))
+svuint32_t svcls_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s64_z)))
+svuint64_t svcls_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s16_z)))
+svuint16_t svcls_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u8_m)))
+svuint8_t svclz_u8_m(svuint8_t, svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u32_m)))
+svuint32_t svclz_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u64_m)))
+svuint64_t svclz_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u16_m)))
+svuint16_t svclz_u16_m(svuint16_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s8_m)))
+svuint8_t svclz_s8_m(svuint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s32_m)))
+svuint32_t svclz_s32_m(svuint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s64_m)))
+svuint64_t svclz_s64_m(svuint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s16_m)))
+svuint16_t svclz_s16_m(svuint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u8_x)))
+svuint8_t svclz_u8_x(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u32_x)))
+svuint32_t svclz_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u64_x)))
+svuint64_t svclz_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u16_x)))
+svuint16_t svclz_u16_x(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s8_x)))
+svuint8_t svclz_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s32_x)))
+svuint32_t svclz_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s64_x)))
+svuint64_t svclz_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s16_x)))
+svuint16_t svclz_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u8_z)))
+svuint8_t svclz_u8_z(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u32_z)))
+svuint32_t svclz_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u64_z)))
+svuint64_t svclz_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u16_z)))
+svuint16_t svclz_u16_z(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s8_z)))
+svuint8_t svclz_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s32_z)))
+svuint32_t svclz_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s64_z)))
+svuint64_t svclz_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s16_z)))
+svuint16_t svclz_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f64_m)))
+svfloat64_t svcmla_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f32_m)))
+svfloat32_t svcmla_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f16_m)))
+svfloat16_t svcmla_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f64_x)))
+svfloat64_t svcmla_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f32_x)))
+svfloat32_t svcmla_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f16_x)))
+svfloat16_t svcmla_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f64_z)))
+svfloat64_t svcmla_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f32_z)))
+svfloat32_t svcmla_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f16_z)))
+svfloat16_t svcmla_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_f32)))
+svfloat32_t svcmla_lane_f32(svfloat32_t, svfloat32_t, svfloat32_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_f16)))
+svfloat16_t svcmla_lane_f16(svfloat16_t, svfloat16_t, svfloat16_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_f64)))
+svbool_t svcmpeq_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_f32)))
+svbool_t svcmpeq_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_f16)))
+svbool_t svcmpeq_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u8)))
+svbool_t svcmpeq_n_u8(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u32)))
+svbool_t svcmpeq_n_u32(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u64)))
+svbool_t svcmpeq_n_u64(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u16)))
+svbool_t svcmpeq_n_u16(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s8)))
+svbool_t svcmpeq_n_s8(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s32)))
+svbool_t svcmpeq_n_s32(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s64)))
+svbool_t svcmpeq_n_s64(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s16)))
+svbool_t svcmpeq_n_s16(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u8)))
+svbool_t svcmpeq_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u32)))
+svbool_t svcmpeq_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u64)))
+svbool_t svcmpeq_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u16)))
+svbool_t svcmpeq_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s8)))
+svbool_t svcmpeq_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s32)))
+svbool_t svcmpeq_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s64)))
+svbool_t svcmpeq_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s16)))
+svbool_t svcmpeq_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_f64)))
+svbool_t svcmpeq_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_f32)))
+svbool_t svcmpeq_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_f16)))
+svbool_t svcmpeq_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_n_s8)))
+svbool_t svcmpeq_wide_n_s8(svbool_t, svint8_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_n_s32)))
+svbool_t svcmpeq_wide_n_s32(svbool_t, svint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_n_s16)))
+svbool_t svcmpeq_wide_n_s16(svbool_t, svint16_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_s8)))
+svbool_t svcmpeq_wide_s8(svbool_t, svint8_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_s32)))
+svbool_t svcmpeq_wide_s32(svbool_t, svint32_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_s16)))
+svbool_t svcmpeq_wide_s16(svbool_t, svint16_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_f64)))
+svbool_t svcmpge_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_f32)))
+svbool_t svcmpge_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_f16)))
+svbool_t svcmpge_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s8)))
+svbool_t svcmpge_n_s8(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s32)))
+svbool_t svcmpge_n_s32(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s64)))
+svbool_t svcmpge_n_s64(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s16)))
+svbool_t svcmpge_n_s16(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u8)))
+svbool_t svcmpge_n_u8(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u32)))
+svbool_t svcmpge_n_u32(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u64)))
+svbool_t svcmpge_n_u64(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u16)))
+svbool_t svcmpge_n_u16(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s8)))
+svbool_t svcmpge_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s32)))
+svbool_t svcmpge_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s64)))
+svbool_t svcmpge_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s16)))
+svbool_t svcmpge_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_f64)))
+svbool_t svcmpge_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_f32)))
+svbool_t svcmpge_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_f16)))
+svbool_t svcmpge_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u8)))
+svbool_t svcmpge_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u32)))
+svbool_t svcmpge_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u64)))
+svbool_t svcmpge_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u16)))
+svbool_t svcmpge_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_s8)))
+svbool_t svcmpge_wide_n_s8(svbool_t, svint8_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_s32)))
+svbool_t svcmpge_wide_n_s32(svbool_t, svint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_s16)))
+svbool_t svcmpge_wide_n_s16(svbool_t, svint16_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_u8)))
+svbool_t svcmpge_wide_n_u8(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_u32)))
+svbool_t svcmpge_wide_n_u32(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_u16)))
+svbool_t svcmpge_wide_n_u16(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_s8)))
+svbool_t svcmpge_wide_s8(svbool_t, svint8_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_s32)))
+svbool_t svcmpge_wide_s32(svbool_t, svint32_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_s16)))
+svbool_t svcmpge_wide_s16(svbool_t, svint16_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_u8)))
+svbool_t svcmpge_wide_u8(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_u32)))
+svbool_t svcmpge_wide_u32(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_u16)))
+svbool_t svcmpge_wide_u16(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_f64)))
+svbool_t svcmpgt_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_f32)))
+svbool_t svcmpgt_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_f16)))
+svbool_t svcmpgt_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s8)))
+svbool_t svcmpgt_n_s8(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s32)))
+svbool_t svcmpgt_n_s32(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s64)))
+svbool_t svcmpgt_n_s64(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s16)))
+svbool_t svcmpgt_n_s16(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u8)))
+svbool_t svcmpgt_n_u8(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u32)))
+svbool_t svcmpgt_n_u32(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u64)))
+svbool_t svcmpgt_n_u64(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u16)))
+svbool_t svcmpgt_n_u16(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s8)))
+svbool_t svcmpgt_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s32)))
+svbool_t svcmpgt_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s64)))
+svbool_t svcmpgt_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s16)))
+svbool_t svcmpgt_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_f64)))
+svbool_t svcmpgt_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_f32)))
+svbool_t svcmpgt_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_f16)))
+svbool_t svcmpgt_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u8)))
+svbool_t svcmpgt_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u32)))
+svbool_t svcmpgt_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u64)))
+svbool_t svcmpgt_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u16)))
+svbool_t svcmpgt_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_s8)))
+svbool_t svcmpgt_wide_n_s8(svbool_t, svint8_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_s32)))
+svbool_t svcmpgt_wide_n_s32(svbool_t, svint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_s16)))
+svbool_t svcmpgt_wide_n_s16(svbool_t, svint16_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_u8)))
+svbool_t svcmpgt_wide_n_u8(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_u32)))
+svbool_t svcmpgt_wide_n_u32(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_u16)))
+svbool_t svcmpgt_wide_n_u16(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_s8)))
+svbool_t svcmpgt_wide_s8(svbool_t, svint8_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_s32)))
+svbool_t svcmpgt_wide_s32(svbool_t, svint32_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_s16)))
+svbool_t svcmpgt_wide_s16(svbool_t, svint16_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_u8)))
+svbool_t svcmpgt_wide_u8(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_u32)))
+svbool_t svcmpgt_wide_u32(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_u16)))
+svbool_t svcmpgt_wide_u16(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_f64)))
+svbool_t svcmple_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_f32)))
+svbool_t svcmple_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_f16)))
+svbool_t svcmple_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s8)))
+svbool_t svcmple_n_s8(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s32)))
+svbool_t svcmple_n_s32(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s64)))
+svbool_t svcmple_n_s64(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s16)))
+svbool_t svcmple_n_s16(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u8)))
+svbool_t svcmple_n_u8(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u32)))
+svbool_t svcmple_n_u32(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u64)))
+svbool_t svcmple_n_u64(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u16)))
+svbool_t svcmple_n_u16(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s8)))
+svbool_t svcmple_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s32)))
+svbool_t svcmple_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s64)))
+svbool_t svcmple_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s16)))
+svbool_t svcmple_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_f64)))
+svbool_t svcmple_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_f32)))
+svbool_t svcmple_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_f16)))
+svbool_t svcmple_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u8)))
+svbool_t svcmple_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u32)))
+svbool_t svcmple_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u64)))
+svbool_t svcmple_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u16)))
+svbool_t svcmple_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_s8)))
+svbool_t svcmple_wide_n_s8(svbool_t, svint8_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_s32)))
+svbool_t svcmple_wide_n_s32(svbool_t, svint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_s16)))
+svbool_t svcmple_wide_n_s16(svbool_t, svint16_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_u8)))
+svbool_t svcmple_wide_n_u8(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_u32)))
+svbool_t svcmple_wide_n_u32(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_u16)))
+svbool_t svcmple_wide_n_u16(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_s8)))
+svbool_t svcmple_wide_s8(svbool_t, svint8_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_s32)))
+svbool_t svcmple_wide_s32(svbool_t, svint32_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_s16)))
+svbool_t svcmple_wide_s16(svbool_t, svint16_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_u8)))
+svbool_t svcmple_wide_u8(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_u32)))
+svbool_t svcmple_wide_u32(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_u16)))
+svbool_t svcmple_wide_u16(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u8)))
+svbool_t svcmplt_n_u8(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u32)))
+svbool_t svcmplt_n_u32(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u64)))
+svbool_t svcmplt_n_u64(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u16)))
+svbool_t svcmplt_n_u16(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_f64)))
+svbool_t svcmplt_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_f32)))
+svbool_t svcmplt_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_f16)))
+svbool_t svcmplt_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s8)))
+svbool_t svcmplt_n_s8(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s32)))
+svbool_t svcmplt_n_s32(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s64)))
+svbool_t svcmplt_n_s64(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s16)))
+svbool_t svcmplt_n_s16(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u8)))
+svbool_t svcmplt_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u32)))
+svbool_t svcmplt_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u64)))
+svbool_t svcmplt_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u16)))
+svbool_t svcmplt_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s8)))
+svbool_t svcmplt_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s32)))
+svbool_t svcmplt_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s64)))
+svbool_t svcmplt_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s16)))
+svbool_t svcmplt_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f64)))
+svbool_t svcmplt_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f32)))
+svbool_t svcmplt_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f16)))
+svbool_t svcmplt_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_u8)))
+svbool_t svcmplt_wide_n_u8(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_u32)))
+svbool_t svcmplt_wide_n_u32(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_u16)))
+svbool_t svcmplt_wide_n_u16(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_s8)))
+svbool_t svcmplt_wide_n_s8(svbool_t, svint8_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_s32)))
+svbool_t svcmplt_wide_n_s32(svbool_t, svint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_s16)))
+svbool_t svcmplt_wide_n_s16(svbool_t, svint16_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_u8)))
+svbool_t svcmplt_wide_u8(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_u32)))
+svbool_t svcmplt_wide_u32(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_u16)))
+svbool_t svcmplt_wide_u16(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_s8)))
+svbool_t svcmplt_wide_s8(svbool_t, svint8_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_s32)))
+svbool_t svcmplt_wide_s32(svbool_t, svint32_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_s16)))
+svbool_t svcmplt_wide_s16(svbool_t, svint16_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_f64)))
+svbool_t svcmpne_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_f32)))
+svbool_t svcmpne_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_f16)))
+svbool_t svcmpne_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u8)))
+svbool_t svcmpne_n_u8(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u32)))
+svbool_t svcmpne_n_u32(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u64)))
+svbool_t svcmpne_n_u64(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u16)))
+svbool_t svcmpne_n_u16(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s8)))
+svbool_t svcmpne_n_s8(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s32)))
+svbool_t svcmpne_n_s32(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s64)))
+svbool_t svcmpne_n_s64(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s16)))
+svbool_t svcmpne_n_s16(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u8)))
+svbool_t svcmpne_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u32)))
+svbool_t svcmpne_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u64)))
+svbool_t svcmpne_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u16)))
+svbool_t svcmpne_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s8)))
+svbool_t svcmpne_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s32)))
+svbool_t svcmpne_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s64)))
+svbool_t svcmpne_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s16)))
+svbool_t svcmpne_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_f64)))
+svbool_t svcmpne_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_f32)))
+svbool_t svcmpne_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_f16)))
+svbool_t svcmpne_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_n_s8)))
+svbool_t svcmpne_wide_n_s8(svbool_t, svint8_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_n_s32)))
+svbool_t svcmpne_wide_n_s32(svbool_t, svint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_n_s16)))
+svbool_t svcmpne_wide_n_s16(svbool_t, svint16_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_s8)))
+svbool_t svcmpne_wide_s8(svbool_t, svint8_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_s32)))
+svbool_t svcmpne_wide_s32(svbool_t, svint32_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_s16)))
+svbool_t svcmpne_wide_s16(svbool_t, svint16_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_n_f64)))
+svbool_t svcmpuo_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_n_f32)))
+svbool_t svcmpuo_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_n_f16)))
+svbool_t svcmpuo_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_f64)))
+svbool_t svcmpuo_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_f32)))
+svbool_t svcmpuo_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_f16)))
+svbool_t svcmpuo_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u8_m)))
+svuint8_t svcnot_u8_m(svuint8_t, svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u32_m)))
+svuint32_t svcnot_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u64_m)))
+svuint64_t svcnot_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u16_m)))
+svuint16_t svcnot_u16_m(svuint16_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s8_m)))
+svint8_t svcnot_s8_m(svint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s32_m)))
+svint32_t svcnot_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s64_m)))
+svint64_t svcnot_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s16_m)))
+svint16_t svcnot_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u8_x)))
+svuint8_t svcnot_u8_x(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u32_x)))
+svuint32_t svcnot_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u64_x)))
+svuint64_t svcnot_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u16_x)))
+svuint16_t svcnot_u16_x(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s8_x)))
+svint8_t svcnot_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s32_x)))
+svint32_t svcnot_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s64_x)))
+svint64_t svcnot_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s16_x)))
+svint16_t svcnot_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u8_z)))
+svuint8_t svcnot_u8_z(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u32_z)))
+svuint32_t svcnot_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u64_z)))
+svuint64_t svcnot_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u16_z)))
+svuint16_t svcnot_u16_z(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s8_z)))
+svint8_t svcnot_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s32_z)))
+svint32_t svcnot_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s64_z)))
+svint64_t svcnot_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s16_z)))
+svint16_t svcnot_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u8_m)))
+svuint8_t svcnt_u8_m(svuint8_t, svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u32_m)))
+svuint32_t svcnt_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u64_m)))
+svuint64_t svcnt_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u16_m)))
+svuint16_t svcnt_u16_m(svuint16_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s8_m)))
+svuint8_t svcnt_s8_m(svuint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f64_m)))
+svuint64_t svcnt_f64_m(svuint64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f32_m)))
+svuint32_t svcnt_f32_m(svuint32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f16_m)))
+svuint16_t svcnt_f16_m(svuint16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s32_m)))
+svuint32_t svcnt_s32_m(svuint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s64_m)))
+svuint64_t svcnt_s64_m(svuint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s16_m)))
+svuint16_t svcnt_s16_m(svuint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u8_x)))
+svuint8_t svcnt_u8_x(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u32_x)))
+svuint32_t svcnt_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u64_x)))
+svuint64_t svcnt_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u16_x)))
+svuint16_t svcnt_u16_x(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s8_x)))
+svuint8_t svcnt_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f64_x)))
+svuint64_t svcnt_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f32_x)))
+svuint32_t svcnt_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f16_x)))
+svuint16_t svcnt_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s32_x)))
+svuint32_t svcnt_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s64_x)))
+svuint64_t svcnt_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s16_x)))
+svuint16_t svcnt_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u8_z)))
+svuint8_t svcnt_u8_z(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u32_z)))
+svuint32_t svcnt_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u64_z)))
+svuint64_t svcnt_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u16_z)))
+svuint16_t svcnt_u16_z(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s8_z)))
+svuint8_t svcnt_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f64_z)))
+svuint64_t svcnt_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f32_z)))
+svuint32_t svcnt_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f16_z)))
+svuint16_t svcnt_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s32_z)))
+svuint32_t svcnt_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s64_z)))
+svuint64_t svcnt_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s16_z)))
+svuint16_t svcnt_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntb)))
+uint64_t svcntb(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntb_pat)))
+uint64_t svcntb_pat(enum svpattern);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntd)))
+uint64_t svcntd(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntd_pat)))
+uint64_t svcntd_pat(enum svpattern);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnth)))
+uint64_t svcnth(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnth_pat)))
+uint64_t svcnth_pat(enum svpattern);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntp_b8)))
+uint64_t svcntp_b8(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntp_b32)))
+uint64_t svcntp_b32(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntp_b64)))
+uint64_t svcntp_b64(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntp_b16)))
+uint64_t svcntp_b16(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntw)))
+uint64_t svcntw(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntw_pat)))
+uint64_t svcntw_pat(enum svpattern);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u8)))
+svuint8x2_t svcreate2_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u32)))
+svuint32x2_t svcreate2_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u64)))
+svuint64x2_t svcreate2_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u16)))
+svuint16x2_t svcreate2_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s8)))
+svint8x2_t svcreate2_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_f64)))
+svfloat64x2_t svcreate2_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_f32)))
+svfloat32x2_t svcreate2_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_f16)))
+svfloat16x2_t svcreate2_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s32)))
+svint32x2_t svcreate2_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s64)))
+svint64x2_t svcreate2_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s16)))
+svint16x2_t svcreate2_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u8)))
+svuint8x3_t svcreate3_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u32)))
+svuint32x3_t svcreate3_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u64)))
+svuint64x3_t svcreate3_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u16)))
+svuint16x3_t svcreate3_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s8)))
+svint8x3_t svcreate3_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_f64)))
+svfloat64x3_t svcreate3_f64(svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_f32)))
+svfloat32x3_t svcreate3_f32(svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_f16)))
+svfloat16x3_t svcreate3_f16(svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s32)))
+svint32x3_t svcreate3_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s64)))
+svint64x3_t svcreate3_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s16)))
+svint16x3_t svcreate3_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u8)))
+svuint8x4_t svcreate4_u8(svuint8_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u32)))
+svuint32x4_t svcreate4_u32(svuint32_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u64)))
+svuint64x4_t svcreate4_u64(svuint64_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u16)))
+svuint16x4_t svcreate4_u16(svuint16_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s8)))
+svint8x4_t svcreate4_s8(svint8_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_f64)))
+svfloat64x4_t svcreate4_f64(svfloat64_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_f32)))
+svfloat32x4_t svcreate4_f32(svfloat32_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_f16)))
+svfloat16x4_t svcreate4_f16(svfloat16_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s32)))
+svint32x4_t svcreate4_s32(svint32_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s64)))
+svint64x4_t svcreate4_s64(svint64_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s16)))
+svint16x4_t svcreate4_s16(svint16_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_m)))
+svfloat16_t svcvt_f16_f32_m(svfloat16_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_x)))
+svfloat16_t svcvt_f16_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_z)))
+svfloat16_t svcvt_f16_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f64_m)))
+svfloat16_t svcvt_f16_f64_m(svfloat16_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f64_x)))
+svfloat16_t svcvt_f16_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f64_z)))
+svfloat16_t svcvt_f16_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s16_m)))
+svfloat16_t svcvt_f16_s16_m(svfloat16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s16_x)))
+svfloat16_t svcvt_f16_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s16_z)))
+svfloat16_t svcvt_f16_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s32_m)))
+svfloat16_t svcvt_f16_s32_m(svfloat16_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s32_x)))
+svfloat16_t svcvt_f16_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s32_z)))
+svfloat16_t svcvt_f16_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s64_m)))
+svfloat16_t svcvt_f16_s64_m(svfloat16_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s64_x)))
+svfloat16_t svcvt_f16_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s64_z)))
+svfloat16_t svcvt_f16_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u16_m)))
+svfloat16_t svcvt_f16_u16_m(svfloat16_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u16_x)))
+svfloat16_t svcvt_f16_u16_x(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u16_z)))
+svfloat16_t svcvt_f16_u16_z(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u32_m)))
+svfloat16_t svcvt_f16_u32_m(svfloat16_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u32_x)))
+svfloat16_t svcvt_f16_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u32_z)))
+svfloat16_t svcvt_f16_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u64_m)))
+svfloat16_t svcvt_f16_u64_m(svfloat16_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u64_x)))
+svfloat16_t svcvt_f16_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u64_z)))
+svfloat16_t svcvt_f16_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_m)))
+svfloat32_t svcvt_f32_f16_m(svfloat32_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_x)))
+svfloat32_t svcvt_f32_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_z)))
+svfloat32_t svcvt_f32_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f64_m)))
+svfloat32_t svcvt_f32_f64_m(svfloat32_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f64_x)))
+svfloat32_t svcvt_f32_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f64_z)))
+svfloat32_t svcvt_f32_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_m)))
+svfloat32_t svcvt_f32_s32_m(svfloat32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_x)))
+svfloat32_t svcvt_f32_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_z)))
+svfloat32_t svcvt_f32_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s64_m)))
+svfloat32_t svcvt_f32_s64_m(svfloat32_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s64_x)))
+svfloat32_t svcvt_f32_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s64_z)))
+svfloat32_t svcvt_f32_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_m)))
+svfloat32_t svcvt_f32_u32_m(svfloat32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_x)))
+svfloat32_t svcvt_f32_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_z)))
+svfloat32_t svcvt_f32_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u64_m)))
+svfloat32_t svcvt_f32_u64_m(svfloat32_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u64_x)))
+svfloat32_t svcvt_f32_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u64_z)))
+svfloat32_t svcvt_f32_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f16_m)))
+svfloat64_t svcvt_f64_f16_m(svfloat64_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f16_x)))
+svfloat64_t svcvt_f64_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f16_z)))
+svfloat64_t svcvt_f64_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f32_m)))
+svfloat64_t svcvt_f64_f32_m(svfloat64_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f32_x)))
+svfloat64_t svcvt_f64_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f32_z)))
+svfloat64_t svcvt_f64_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s32_m)))
+svfloat64_t svcvt_f64_s32_m(svfloat64_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s32_x)))
+svfloat64_t svcvt_f64_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s32_z)))
+svfloat64_t svcvt_f64_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s64_m)))
+svfloat64_t svcvt_f64_s64_m(svfloat64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s64_x)))
+svfloat64_t svcvt_f64_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s64_z)))
+svfloat64_t svcvt_f64_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u32_m)))
+svfloat64_t svcvt_f64_u32_m(svfloat64_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u32_x)))
+svfloat64_t svcvt_f64_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u32_z)))
+svfloat64_t svcvt_f64_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u64_m)))
+svfloat64_t svcvt_f64_u64_m(svfloat64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u64_x)))
+svfloat64_t svcvt_f64_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u64_z)))
+svfloat64_t svcvt_f64_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s16_f16_m)))
+svint16_t svcvt_s16_f16_m(svint16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s16_f16_x)))
+svint16_t svcvt_s16_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s16_f16_z)))
+svint16_t svcvt_s16_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f16_m)))
+svint32_t svcvt_s32_f16_m(svint32_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f16_x)))
+svint32_t svcvt_s32_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f16_z)))
+svint32_t svcvt_s32_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_m)))
+svint32_t svcvt_s32_f32_m(svint32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_x)))
+svint32_t svcvt_s32_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_z)))
+svint32_t svcvt_s32_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f64_m)))
+svint32_t svcvt_s32_f64_m(svint32_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f64_x)))
+svint32_t svcvt_s32_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f64_z)))
+svint32_t svcvt_s32_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f16_m)))
+svint64_t svcvt_s64_f16_m(svint64_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f16_x)))
+svint64_t svcvt_s64_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f16_z)))
+svint64_t svcvt_s64_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f32_m)))
+svint64_t svcvt_s64_f32_m(svint64_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f32_x)))
+svint64_t svcvt_s64_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f32_z)))
+svint64_t svcvt_s64_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f64_m)))
+svint64_t svcvt_s64_f64_m(svint64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f64_x)))
+svint64_t svcvt_s64_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f64_z)))
+svint64_t svcvt_s64_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u16_f16_m)))
+svuint16_t svcvt_u16_f16_m(svuint16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u16_f16_x)))
+svuint16_t svcvt_u16_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u16_f16_z)))
+svuint16_t svcvt_u16_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f16_m)))
+svuint32_t svcvt_u32_f16_m(svuint32_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f16_x)))
+svuint32_t svcvt_u32_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f16_z)))
+svuint32_t svcvt_u32_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_m)))
+svuint32_t svcvt_u32_f32_m(svuint32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_x)))
+svuint32_t svcvt_u32_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_z)))
+svuint32_t svcvt_u32_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f64_m)))
+svuint32_t svcvt_u32_f64_m(svuint32_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f64_x)))
+svuint32_t svcvt_u32_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f64_z)))
+svuint32_t svcvt_u32_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f16_m)))
+svuint64_t svcvt_u64_f16_m(svuint64_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f16_x)))
+svuint64_t svcvt_u64_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f16_z)))
+svuint64_t svcvt_u64_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f32_m)))
+svuint64_t svcvt_u64_f32_m(svuint64_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f32_x)))
+svuint64_t svcvt_u64_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f32_z)))
+svuint64_t svcvt_u64_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f64_m)))
+svuint64_t svcvt_u64_f64_m(svuint64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f64_x)))
+svuint64_t svcvt_u64_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f64_z)))
+svuint64_t svcvt_u64_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f64_m)))
+svfloat64_t svdiv_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f32_m)))
+svfloat32_t svdiv_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f16_m)))
+svfloat16_t svdiv_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f64_x)))
+svfloat64_t svdiv_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f32_x)))
+svfloat32_t svdiv_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f16_x)))
+svfloat16_t svdiv_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f64_z)))
+svfloat64_t svdiv_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f32_z)))
+svfloat32_t svdiv_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f16_z)))
+svfloat16_t svdiv_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s32_m)))
+svint32_t svdiv_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s64_m)))
+svint64_t svdiv_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s32_x)))
+svint32_t svdiv_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s64_x)))
+svint64_t svdiv_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s32_z)))
+svint32_t svdiv_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s64_z)))
+svint64_t svdiv_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u32_m)))
+svuint32_t svdiv_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u64_m)))
+svuint64_t svdiv_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u32_x)))
+svuint32_t svdiv_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u64_x)))
+svuint64_t svdiv_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u32_z)))
+svuint32_t svdiv_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u64_z)))
+svuint64_t svdiv_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f64_m)))
+svfloat64_t svdiv_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f32_m)))
+svfloat32_t svdiv_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f16_m)))
+svfloat16_t svdiv_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f64_x)))
+svfloat64_t svdiv_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f32_x)))
+svfloat32_t svdiv_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f16_x)))
+svfloat16_t svdiv_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f64_z)))
+svfloat64_t svdiv_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f32_z)))
+svfloat32_t svdiv_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f16_z)))
+svfloat16_t svdiv_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s32_m)))
+svint32_t svdiv_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s64_m)))
+svint64_t svdiv_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s32_x)))
+svint32_t svdiv_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s64_x)))
+svint64_t svdiv_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s32_z)))
+svint32_t svdiv_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s64_z)))
+svint64_t svdiv_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u32_m)))
+svuint32_t svdiv_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u64_m)))
+svuint64_t svdiv_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u32_x)))
+svuint32_t svdiv_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u64_x)))
+svuint64_t svdiv_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u32_z)))
+svuint32_t svdiv_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u64_z)))
+svuint64_t svdiv_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f64_m)))
+svfloat64_t svdivr_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f32_m)))
+svfloat32_t svdivr_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f16_m)))
+svfloat16_t svdivr_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f64_x)))
+svfloat64_t svdivr_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f32_x)))
+svfloat32_t svdivr_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f16_x)))
+svfloat16_t svdivr_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f64_z)))
+svfloat64_t svdivr_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f32_z)))
+svfloat32_t svdivr_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f16_z)))
+svfloat16_t svdivr_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s32_m)))
+svint32_t svdivr_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s64_m)))
+svint64_t svdivr_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s32_x)))
+svint32_t svdivr_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s64_x)))
+svint64_t svdivr_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s32_z)))
+svint32_t svdivr_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s64_z)))
+svint64_t svdivr_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u32_m)))
+svuint32_t svdivr_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u64_m)))
+svuint64_t svdivr_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u32_x)))
+svuint32_t svdivr_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u64_x)))
+svuint64_t svdivr_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u32_z)))
+svuint32_t svdivr_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u64_z)))
+svuint64_t svdivr_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f64_m)))
+svfloat64_t svdivr_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f32_m)))
+svfloat32_t svdivr_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f16_m)))
+svfloat16_t svdivr_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f64_x)))
+svfloat64_t svdivr_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f32_x)))
+svfloat32_t svdivr_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f16_x)))
+svfloat16_t svdivr_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f64_z)))
+svfloat64_t svdivr_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f32_z)))
+svfloat32_t svdivr_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f16_z)))
+svfloat16_t svdivr_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s32_m)))
+svint32_t svdivr_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s64_m)))
+svint64_t svdivr_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s32_x)))
+svint32_t svdivr_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s64_x)))
+svint64_t svdivr_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s32_z)))
+svint32_t svdivr_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s64_z)))
+svint64_t svdivr_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u32_m)))
+svuint32_t svdivr_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u64_m)))
+svuint64_t svdivr_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u32_x)))
+svuint32_t svdivr_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u64_x)))
+svuint64_t svdivr_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u32_z)))
+svuint32_t svdivr_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u64_z)))
+svuint64_t svdivr_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_s32)))
+svint32_t svdot_n_s32(svint32_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_s64)))
+svint64_t svdot_n_s64(svint64_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_u32)))
+svuint32_t svdot_n_u32(svuint32_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_u64)))
+svuint64_t svdot_n_u64(svuint64_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_s32)))
+svint32_t svdot_s32(svint32_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_s64)))
+svint64_t svdot_s64(svint64_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_u32)))
+svuint32_t svdot_u32(svuint32_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_u64)))
+svuint64_t svdot_u64(svuint64_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_s32)))
+svint32_t svdot_lane_s32(svint32_t, svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_s64)))
+svint64_t svdot_lane_s64(svint64_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_u32)))
+svuint32_t svdot_lane_u32(svuint32_t, svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_u64)))
+svuint64_t svdot_lane_u64(svuint64_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8)))
+svuint8_t svdup_n_u8(uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32)))
+svuint32_t svdup_n_u32(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64)))
+svuint64_t svdup_n_u64(uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16)))
+svuint16_t svdup_n_u16(uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8)))
+svint8_t svdup_n_s8(int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64)))
+svfloat64_t svdup_n_f64(float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32)))
+svfloat32_t svdup_n_f32(float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16)))
+svfloat16_t svdup_n_f16(float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32)))
+svint32_t svdup_n_s32(int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64)))
+svint64_t svdup_n_s64(int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16)))
+svint16_t svdup_n_s16(int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8_m)))
+svuint8_t svdup_n_u8_m(svuint8_t, svbool_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32_m)))
+svuint32_t svdup_n_u32_m(svuint32_t, svbool_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64_m)))
+svuint64_t svdup_n_u64_m(svuint64_t, svbool_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16_m)))
+svuint16_t svdup_n_u16_m(svuint16_t, svbool_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8_m)))
+svint8_t svdup_n_s8_m(svint8_t, svbool_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64_m)))
+svfloat64_t svdup_n_f64_m(svfloat64_t, svbool_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32_m)))
+svfloat32_t svdup_n_f32_m(svfloat32_t, svbool_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16_m)))
+svfloat16_t svdup_n_f16_m(svfloat16_t, svbool_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32_m)))
+svint32_t svdup_n_s32_m(svint32_t, svbool_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64_m)))
+svint64_t svdup_n_s64_m(svint64_t, svbool_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16_m)))
+svint16_t svdup_n_s16_m(svint16_t, svbool_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b8)))
+svbool_t svdup_n_b8(bool);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b32)))
+svbool_t svdup_n_b32(bool);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b64)))
+svbool_t svdup_n_b64(bool);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b16)))
+svbool_t svdup_n_b16(bool);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8_x)))
+svuint8_t svdup_n_u8_x(svbool_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32_x)))
+svuint32_t svdup_n_u32_x(svbool_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64_x)))
+svuint64_t svdup_n_u64_x(svbool_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16_x)))
+svuint16_t svdup_n_u16_x(svbool_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8_x)))
+svint8_t svdup_n_s8_x(svbool_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64_x)))
+svfloat64_t svdup_n_f64_x(svbool_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32_x)))
+svfloat32_t svdup_n_f32_x(svbool_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16_x)))
+svfloat16_t svdup_n_f16_x(svbool_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32_x)))
+svint32_t svdup_n_s32_x(svbool_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64_x)))
+svint64_t svdup_n_s64_x(svbool_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16_x)))
+svint16_t svdup_n_s16_x(svbool_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8_z)))
+svuint8_t svdup_n_u8_z(svbool_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32_z)))
+svuint32_t svdup_n_u32_z(svbool_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64_z)))
+svuint64_t svdup_n_u64_z(svbool_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16_z)))
+svuint16_t svdup_n_u16_z(svbool_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8_z)))
+svint8_t svdup_n_s8_z(svbool_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64_z)))
+svfloat64_t svdup_n_f64_z(svbool_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32_z)))
+svfloat32_t svdup_n_f32_z(svbool_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16_z)))
+svfloat16_t svdup_n_f16_z(svbool_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32_z)))
+svint32_t svdup_n_s32_z(svbool_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64_z)))
+svint64_t svdup_n_s64_z(svbool_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16_z)))
+svint16_t svdup_n_s16_z(svbool_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u8)))
+svuint8_t svdup_lane_u8(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u32)))
+svuint32_t svdup_lane_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u64)))
+svuint64_t svdup_lane_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u16)))
+svuint16_t svdup_lane_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s8)))
+svint8_t svdup_lane_s8(svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_f64)))
+svfloat64_t svdup_lane_f64(svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_f32)))
+svfloat32_t svdup_lane_f32(svfloat32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_f16)))
+svfloat16_t svdup_lane_f16(svfloat16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s32)))
+svint32_t svdup_lane_s32(svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s64)))
+svint64_t svdup_lane_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s16)))
+svint16_t svdup_lane_s16(svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u8)))
+svuint8_t svdupq_n_u8(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s8)))
+svint8_t svdupq_n_s8(int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u16)))
+svuint16_t svdupq_n_u16(uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_f16)))
+svfloat16_t svdupq_n_f16(float16_t, float16_t, float16_t, float16_t, float16_t, float16_t, float16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s16)))
+svint16_t svdupq_n_s16(int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u32)))
+svuint32_t svdupq_n_u32(uint32_t, uint32_t, uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_f32)))
+svfloat32_t svdupq_n_f32(float32_t, float32_t, float32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s32)))
+svint32_t svdupq_n_s32(int32_t, int32_t, int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u64)))
+svuint64_t svdupq_n_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_f64)))
+svfloat64_t svdupq_n_f64(float64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s64)))
+svint64_t svdupq_n_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b8)))
+svbool_t svdupq_n_b8(bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b16)))
+svbool_t svdupq_n_b16(bool, bool, bool, bool, bool, bool, bool, bool);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b32)))
+svbool_t svdupq_n_b32(bool, bool, bool, bool);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b64)))
+svbool_t svdupq_n_b64(bool, bool);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u8)))
+svuint8_t svdupq_lane_u8(svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u32)))
+svuint32_t svdupq_lane_u32(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u64)))
+svuint64_t svdupq_lane_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u16)))
+svuint16_t svdupq_lane_u16(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s8)))
+svint8_t svdupq_lane_s8(svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_f64)))
+svfloat64_t svdupq_lane_f64(svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_f32)))
+svfloat32_t svdupq_lane_f32(svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_f16)))
+svfloat16_t svdupq_lane_f16(svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s32)))
+svint32_t svdupq_lane_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s64)))
+svint64_t svdupq_lane_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s16)))
+svint16_t svdupq_lane_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_b_z)))
+svbool_t sveor_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u8_m)))
+svuint8_t sveor_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u32_m)))
+svuint32_t sveor_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u64_m)))
+svuint64_t sveor_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u16_m)))
+svuint16_t sveor_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s8_m)))
+svint8_t sveor_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s32_m)))
+svint32_t sveor_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s64_m)))
+svint64_t sveor_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s16_m)))
+svint16_t sveor_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u8_x)))
+svuint8_t sveor_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u32_x)))
+svuint32_t sveor_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u64_x)))
+svuint64_t sveor_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u16_x)))
+svuint16_t sveor_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s8_x)))
+svint8_t sveor_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s32_x)))
+svint32_t sveor_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s64_x)))
+svint64_t sveor_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s16_x)))
+svint16_t sveor_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u8_z)))
+svuint8_t sveor_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u32_z)))
+svuint32_t sveor_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u64_z)))
+svuint64_t sveor_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u16_z)))
+svuint16_t sveor_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s8_z)))
+svint8_t sveor_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s32_z)))
+svint32_t sveor_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s64_z)))
+svint64_t sveor_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s16_z)))
+svint16_t sveor_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u8_m)))
+svuint8_t sveor_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u32_m)))
+svuint32_t sveor_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u64_m)))
+svuint64_t sveor_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u16_m)))
+svuint16_t sveor_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s8_m)))
+svint8_t sveor_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s32_m)))
+svint32_t sveor_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s64_m)))
+svint64_t sveor_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s16_m)))
+svint16_t sveor_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u8_x)))
+svuint8_t sveor_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u32_x)))
+svuint32_t sveor_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u64_x)))
+svuint64_t sveor_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u16_x)))
+svuint16_t sveor_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s8_x)))
+svint8_t sveor_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s32_x)))
+svint32_t sveor_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s64_x)))
+svint64_t sveor_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s16_x)))
+svint16_t sveor_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u8_z)))
+svuint8_t sveor_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u32_z)))
+svuint32_t sveor_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u64_z)))
+svuint64_t sveor_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u16_z)))
+svuint16_t sveor_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s8_z)))
+svint8_t sveor_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s32_z)))
+svint32_t sveor_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s64_z)))
+svint64_t sveor_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s16_z)))
+svint16_t sveor_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u8)))
+uint8_t sveorv_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u32)))
+uint32_t sveorv_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u64)))
+uint64_t sveorv_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u16)))
+uint16_t sveorv_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s8)))
+int8_t sveorv_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s32)))
+int32_t sveorv_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s64)))
+int64_t sveorv_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s16)))
+int16_t sveorv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u8)))
+svuint8_t svext_u8(svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u32)))
+svuint32_t svext_u32(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u64)))
+svuint64_t svext_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u16)))
+svuint16_t svext_u16(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s8)))
+svint8_t svext_s8(svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_f64)))
+svfloat64_t svext_f64(svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_f32)))
+svfloat32_t svext_f32(svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_f16)))
+svfloat16_t svext_f16(svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s32)))
+svint32_t svext_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s64)))
+svint64_t svext_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s16)))
+svint16_t svext_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s32_m)))
+svint32_t svextb_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s64_m)))
+svint64_t svextb_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s16_m)))
+svint16_t svextb_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s32_x)))
+svint32_t svextb_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s64_x)))
+svint64_t svextb_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s16_x)))
+svint16_t svextb_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s32_z)))
+svint32_t svextb_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s64_z)))
+svint64_t svextb_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s16_z)))
+svint16_t svextb_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u32_m)))
+svuint32_t svextb_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u64_m)))
+svuint64_t svextb_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u16_m)))
+svuint16_t svextb_u16_m(svuint16_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u32_x)))
+svuint32_t svextb_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u64_x)))
+svuint64_t svextb_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u16_x)))
+svuint16_t svextb_u16_x(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u32_z)))
+svuint32_t svextb_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u64_z)))
+svuint64_t svextb_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u16_z)))
+svuint16_t svextb_u16_z(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s32_m)))
+svint32_t svexth_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s64_m)))
+svint64_t svexth_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s32_x)))
+svint32_t svexth_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s64_x)))
+svint64_t svexth_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s32_z)))
+svint32_t svexth_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s64_z)))
+svint64_t svexth_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u32_m)))
+svuint32_t svexth_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u64_m)))
+svuint64_t svexth_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u32_x)))
+svuint32_t svexth_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u64_x)))
+svuint64_t svexth_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u32_z)))
+svuint32_t svexth_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u64_z)))
+svuint64_t svexth_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_s64_m)))
+svint64_t svextw_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_s64_x)))
+svint64_t svextw_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_s64_z)))
+svint64_t svextw_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_u64_m)))
+svuint64_t svextw_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_u64_x)))
+svuint64_t svextw_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_u64_z)))
+svuint64_t svextw_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u8)))
+svuint8_t svget2_u8(svuint8x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u32)))
+svuint32_t svget2_u32(svuint32x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u64)))
+svuint64_t svget2_u64(svuint64x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u16)))
+svuint16_t svget2_u16(svuint16x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s8)))
+svint8_t svget2_s8(svint8x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_f64)))
+svfloat64_t svget2_f64(svfloat64x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_f32)))
+svfloat32_t svget2_f32(svfloat32x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_f16)))
+svfloat16_t svget2_f16(svfloat16x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s32)))
+svint32_t svget2_s32(svint32x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s64)))
+svint64_t svget2_s64(svint64x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s16)))
+svint16_t svget2_s16(svint16x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u8)))
+svuint8_t svget3_u8(svuint8x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u32)))
+svuint32_t svget3_u32(svuint32x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u64)))
+svuint64_t svget3_u64(svuint64x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u16)))
+svuint16_t svget3_u16(svuint16x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s8)))
+svint8_t svget3_s8(svint8x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_f64)))
+svfloat64_t svget3_f64(svfloat64x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_f32)))
+svfloat32_t svget3_f32(svfloat32x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_f16)))
+svfloat16_t svget3_f16(svfloat16x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s32)))
+svint32_t svget3_s32(svint32x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s64)))
+svint64_t svget3_s64(svint64x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s16)))
+svint16_t svget3_s16(svint16x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u8)))
+svuint8_t svget4_u8(svuint8x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u32)))
+svuint32_t svget4_u32(svuint32x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u64)))
+svuint64_t svget4_u64(svuint64x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u16)))
+svuint16_t svget4_u16(svuint16x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s8)))
+svint8_t svget4_s8(svint8x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_f64)))
+svfloat64_t svget4_f64(svfloat64x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_f32)))
+svfloat32_t svget4_f32(svfloat32x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_f16)))
+svfloat16_t svget4_f16(svfloat16x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s32)))
+svint32_t svget4_s32(svint32x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s64)))
+svint64_t svget4_s64(svint64x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s16)))
+svint16_t svget4_s16(svint16x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_u8)))
+svuint8_t svindex_u8(uint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_u32)))
+svuint32_t svindex_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_u64)))
+svuint64_t svindex_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_u16)))
+svuint16_t svindex_u16(uint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_s8)))
+svint8_t svindex_s8(int8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_s32)))
+svint32_t svindex_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_s64)))
+svint64_t svindex_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_s16)))
+svint16_t svindex_s16(int16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u8)))
+svuint8_t svinsr_n_u8(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u32)))
+svuint32_t svinsr_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u64)))
+svuint64_t svinsr_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u16)))
+svuint16_t svinsr_n_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s8)))
+svint8_t svinsr_n_s8(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_f64)))
+svfloat64_t svinsr_n_f64(svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_f32)))
+svfloat32_t svinsr_n_f32(svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_f16)))
+svfloat16_t svinsr_n_f16(svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s32)))
+svint32_t svinsr_n_s32(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s64)))
+svint64_t svinsr_n_s64(svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s16)))
+svint16_t svinsr_n_s16(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u8)))
+uint8_t svlasta_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u32)))
+uint32_t svlasta_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u64)))
+uint64_t svlasta_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u16)))
+uint16_t svlasta_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s8)))
+int8_t svlasta_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_f64)))
+float64_t svlasta_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_f32)))
+float32_t svlasta_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_f16)))
+float16_t svlasta_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s32)))
+int32_t svlasta_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s64)))
+int64_t svlasta_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s16)))
+int16_t svlasta_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u8)))
+uint8_t svlastb_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u32)))
+uint32_t svlastb_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u64)))
+uint64_t svlastb_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u16)))
+uint16_t svlastb_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s8)))
+int8_t svlastb_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_f64)))
+float64_t svlastb_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_f32)))
+float32_t svlastb_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_f16)))
+float16_t svlastb_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s32)))
+int32_t svlastb_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s64)))
+int64_t svlastb_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s16)))
+int16_t svlastb_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u8)))
+svuint8_t svld1_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u32)))
+svuint32_t svld1_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u64)))
+svuint64_t svld1_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u16)))
+svuint16_t svld1_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s8)))
+svint8_t svld1_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f64)))
+svfloat64_t svld1_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f32)))
+svfloat32_t svld1_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f16)))
+svfloat16_t svld1_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s32)))
+svint32_t svld1_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s64)))
+svint64_t svld1_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s16)))
+svint16_t svld1_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u8)))
+svuint8_t svld1_vnum_u8(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u32)))
+svuint32_t svld1_vnum_u32(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u64)))
+svuint64_t svld1_vnum_u64(svbool_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u16)))
+svuint16_t svld1_vnum_u16(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s8)))
+svint8_t svld1_vnum_s8(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f64)))
+svfloat64_t svld1_vnum_f64(svbool_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f32)))
+svfloat32_t svld1_vnum_f32(svbool_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f16)))
+svfloat16_t svld1_vnum_f16(svbool_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s32)))
+svint32_t svld1_vnum_s32(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s64)))
+svint64_t svld1_vnum_s64(svbool_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s16)))
+svint16_t svld1_vnum_s16(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u8)))
+svuint8_t svld1rq_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u32)))
+svuint32_t svld1rq_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u64)))
+svuint64_t svld1rq_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u16)))
+svuint16_t svld1rq_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s8)))
+svint8_t svld1rq_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_f64)))
+svfloat64_t svld1rq_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_f32)))
+svfloat32_t svld1rq_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_f16)))
+svfloat16_t svld1rq_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s32)))
+svint32_t svld1rq_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s64)))
+svint64_t svld1rq_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s16)))
+svint16_t svld1rq_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_vnum_u32)))
+svuint32_t svld1sb_vnum_u32(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_vnum_u64)))
+svuint64_t svld1sb_vnum_u64(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_vnum_u16)))
+svuint16_t svld1sb_vnum_u16(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_vnum_s32)))
+svint32_t svld1sb_vnum_s32(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_vnum_s64)))
+svint64_t svld1sb_vnum_s64(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_vnum_s16)))
+svint16_t svld1sb_vnum_s16(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_u32)))
+svuint32_t svld1sb_u32(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_u64)))
+svuint64_t svld1sb_u64(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_u16)))
+svuint16_t svld1sb_u16(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_s32)))
+svint32_t svld1sb_s32(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_s64)))
+svint64_t svld1sb_s64(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_s16)))
+svint16_t svld1sb_s16(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_vnum_u32)))
+svuint32_t svld1sh_vnum_u32(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_vnum_u64)))
+svuint64_t svld1sh_vnum_u64(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_vnum_s32)))
+svint32_t svld1sh_vnum_s32(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_vnum_s64)))
+svint64_t svld1sh_vnum_s64(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_u32)))
+svuint32_t svld1sh_u32(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_u64)))
+svuint64_t svld1sh_u64(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_s32)))
+svint32_t svld1sh_s32(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_s64)))
+svint64_t svld1sh_s64(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_vnum_u64)))
+svuint64_t svld1sw_vnum_u64(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_vnum_s64)))
+svint64_t svld1sw_vnum_s64(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_u64)))
+svuint64_t svld1sw_u64(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_s64)))
+svint64_t svld1sw_s64(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_vnum_u32)))
+svuint32_t svld1ub_vnum_u32(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_vnum_u64)))
+svuint64_t svld1ub_vnum_u64(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_vnum_u16)))
+svuint16_t svld1ub_vnum_u16(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_vnum_s32)))
+svint32_t svld1ub_vnum_s32(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_vnum_s64)))
+svint64_t svld1ub_vnum_s64(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_vnum_s16)))
+svint16_t svld1ub_vnum_s16(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_u32)))
+svuint32_t svld1ub_u32(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_u64)))
+svuint64_t svld1ub_u64(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_u16)))
+svuint16_t svld1ub_u16(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_s32)))
+svint32_t svld1ub_s32(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_s64)))
+svint64_t svld1ub_s64(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_s16)))
+svint16_t svld1ub_s16(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_vnum_u32)))
+svuint32_t svld1uh_vnum_u32(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_vnum_u64)))
+svuint64_t svld1uh_vnum_u64(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_vnum_s32)))
+svint32_t svld1uh_vnum_s32(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_vnum_s64)))
+svint64_t svld1uh_vnum_s64(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_u32)))
+svuint32_t svld1uh_u32(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_u64)))
+svuint64_t svld1uh_u64(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_s32)))
+svint32_t svld1uh_s32(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_s64)))
+svint64_t svld1uh_s64(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_vnum_u64)))
+svuint64_t svld1uw_vnum_u64(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_vnum_s64)))
+svint64_t svld1uw_vnum_s64(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_u64)))
+svuint64_t svld1uw_u64(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_s64)))
+svint64_t svld1uw_s64(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u8)))
+svuint8x2_t svld2_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u32)))
+svuint32x2_t svld2_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u64)))
+svuint64x2_t svld2_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u16)))
+svuint16x2_t svld2_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s8)))
+svint8x2_t svld2_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_f64)))
+svfloat64x2_t svld2_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_f32)))
+svfloat32x2_t svld2_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_f16)))
+svfloat16x2_t svld2_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s32)))
+svint32x2_t svld2_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s64)))
+svint64x2_t svld2_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s16)))
+svint16x2_t svld2_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u8)))
+svuint8x2_t svld2_vnum_u8(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u32)))
+svuint32x2_t svld2_vnum_u32(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u64)))
+svuint64x2_t svld2_vnum_u64(svbool_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u16)))
+svuint16x2_t svld2_vnum_u16(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s8)))
+svint8x2_t svld2_vnum_s8(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_f64)))
+svfloat64x2_t svld2_vnum_f64(svbool_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_f32)))
+svfloat32x2_t svld2_vnum_f32(svbool_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_f16)))
+svfloat16x2_t svld2_vnum_f16(svbool_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s32)))
+svint32x2_t svld2_vnum_s32(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s64)))
+svint64x2_t svld2_vnum_s64(svbool_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s16)))
+svint16x2_t svld2_vnum_s16(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u8)))
+svuint8x3_t svld3_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u32)))
+svuint32x3_t svld3_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u64)))
+svuint64x3_t svld3_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u16)))
+svuint16x3_t svld3_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s8)))
+svint8x3_t svld3_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_f64)))
+svfloat64x3_t svld3_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_f32)))
+svfloat32x3_t svld3_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_f16)))
+svfloat16x3_t svld3_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s32)))
+svint32x3_t svld3_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s64)))
+svint64x3_t svld3_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s16)))
+svint16x3_t svld3_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u8)))
+svuint8x3_t svld3_vnum_u8(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u32)))
+svuint32x3_t svld3_vnum_u32(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u64)))
+svuint64x3_t svld3_vnum_u64(svbool_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u16)))
+svuint16x3_t svld3_vnum_u16(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s8)))
+svint8x3_t svld3_vnum_s8(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_f64)))
+svfloat64x3_t svld3_vnum_f64(svbool_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_f32)))
+svfloat32x3_t svld3_vnum_f32(svbool_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_f16)))
+svfloat16x3_t svld3_vnum_f16(svbool_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s32)))
+svint32x3_t svld3_vnum_s32(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s64)))
+svint64x3_t svld3_vnum_s64(svbool_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s16)))
+svint16x3_t svld3_vnum_s16(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u8)))
+svuint8x4_t svld4_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u32)))
+svuint32x4_t svld4_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u64)))
+svuint64x4_t svld4_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u16)))
+svuint16x4_t svld4_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s8)))
+svint8x4_t svld4_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_f64)))
+svfloat64x4_t svld4_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_f32)))
+svfloat32x4_t svld4_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_f16)))
+svfloat16x4_t svld4_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s32)))
+svint32x4_t svld4_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s64)))
+svint64x4_t svld4_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s16)))
+svint16x4_t svld4_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u8)))
+svuint8x4_t svld4_vnum_u8(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u32)))
+svuint32x4_t svld4_vnum_u32(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u64)))
+svuint64x4_t svld4_vnum_u64(svbool_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u16)))
+svuint16x4_t svld4_vnum_u16(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s8)))
+svint8x4_t svld4_vnum_s8(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_f64)))
+svfloat64x4_t svld4_vnum_f64(svbool_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_f32)))
+svfloat32x4_t svld4_vnum_f32(svbool_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_f16)))
+svfloat16x4_t svld4_vnum_f16(svbool_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s32)))
+svint32x4_t svld4_vnum_s32(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s64)))
+svint64x4_t svld4_vnum_s64(svbool_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s16)))
+svint16x4_t svld4_vnum_s16(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u8)))
+svuint8_t svldnt1_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u32)))
+svuint32_t svldnt1_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u64)))
+svuint64_t svldnt1_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u16)))
+svuint16_t svldnt1_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s8)))
+svint8_t svldnt1_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f64)))
+svfloat64_t svldnt1_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f32)))
+svfloat32_t svldnt1_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f16)))
+svfloat16_t svldnt1_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s32)))
+svint32_t svldnt1_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s64)))
+svint64_t svldnt1_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s16)))
+svint16_t svldnt1_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u8)))
+svuint8_t svldnt1_vnum_u8(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u32)))
+svuint32_t svldnt1_vnum_u32(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u64)))
+svuint64_t svldnt1_vnum_u64(svbool_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u16)))
+svuint16_t svldnt1_vnum_u16(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s8)))
+svint8_t svldnt1_vnum_s8(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f64)))
+svfloat64_t svldnt1_vnum_f64(svbool_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f32)))
+svfloat32_t svldnt1_vnum_f32(svbool_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f16)))
+svfloat16_t svldnt1_vnum_f16(svbool_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s32)))
+svint32_t svldnt1_vnum_s32(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s64)))
+svint64_t svldnt1_vnum_s64(svbool_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s16)))
+svint16_t svldnt1_vnum_s16(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u8)))
+uint64_t svlen_u8(svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u32)))
+uint64_t svlen_u32(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u64)))
+uint64_t svlen_u64(svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u16)))
+uint64_t svlen_u16(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s8)))
+uint64_t svlen_s8(svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_f64)))
+uint64_t svlen_f64(svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_f32)))
+uint64_t svlen_f32(svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_f16)))
+uint64_t svlen_f16(svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s32)))
+uint64_t svlen_s32(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s64)))
+uint64_t svlen_s64(svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s16)))
+uint64_t svlen_s16(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u8_m)))
+svuint8_t svlsl_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u32_m)))
+svuint32_t svlsl_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u64_m)))
+svuint64_t svlsl_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u16_m)))
+svuint16_t svlsl_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s8_m)))
+svint8_t svlsl_n_s8_m(svbool_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s32_m)))
+svint32_t svlsl_n_s32_m(svbool_t, svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s64_m)))
+svint64_t svlsl_n_s64_m(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s16_m)))
+svint16_t svlsl_n_s16_m(svbool_t, svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u8_x)))
+svuint8_t svlsl_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u32_x)))
+svuint32_t svlsl_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u64_x)))
+svuint64_t svlsl_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u16_x)))
+svuint16_t svlsl_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s8_x)))
+svint8_t svlsl_n_s8_x(svbool_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s32_x)))
+svint32_t svlsl_n_s32_x(svbool_t, svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s64_x)))
+svint64_t svlsl_n_s64_x(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s16_x)))
+svint16_t svlsl_n_s16_x(svbool_t, svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u8_z)))
+svuint8_t svlsl_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u32_z)))
+svuint32_t svlsl_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u64_z)))
+svuint64_t svlsl_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u16_z)))
+svuint16_t svlsl_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s8_z)))
+svint8_t svlsl_n_s8_z(svbool_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s32_z)))
+svint32_t svlsl_n_s32_z(svbool_t, svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s64_z)))
+svint64_t svlsl_n_s64_z(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s16_z)))
+svint16_t svlsl_n_s16_z(svbool_t, svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u8_m)))
+svuint8_t svlsl_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u32_m)))
+svuint32_t svlsl_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u64_m)))
+svuint64_t svlsl_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u16_m)))
+svuint16_t svlsl_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s8_m)))
+svint8_t svlsl_s8_m(svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s32_m)))
+svint32_t svlsl_s32_m(svbool_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s64_m)))
+svint64_t svlsl_s64_m(svbool_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s16_m)))
+svint16_t svlsl_s16_m(svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u8_x)))
+svuint8_t svlsl_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u32_x)))
+svuint32_t svlsl_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u64_x)))
+svuint64_t svlsl_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u16_x)))
+svuint16_t svlsl_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s8_x)))
+svint8_t svlsl_s8_x(svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s32_x)))
+svint32_t svlsl_s32_x(svbool_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s64_x)))
+svint64_t svlsl_s64_x(svbool_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s16_x)))
+svint16_t svlsl_s16_x(svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u8_z)))
+svuint8_t svlsl_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u32_z)))
+svuint32_t svlsl_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u64_z)))
+svuint64_t svlsl_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u16_z)))
+svuint16_t svlsl_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s8_z)))
+svint8_t svlsl_s8_z(svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s32_z)))
+svint32_t svlsl_s32_z(svbool_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s64_z)))
+svint64_t svlsl_s64_z(svbool_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s16_z)))
+svint16_t svlsl_s16_z(svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u8_m)))
+svuint8_t svlsl_wide_n_u8_m(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u32_m)))
+svuint32_t svlsl_wide_n_u32_m(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u16_m)))
+svuint16_t svlsl_wide_n_u16_m(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s8_m)))
+svint8_t svlsl_wide_n_s8_m(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s32_m)))
+svint32_t svlsl_wide_n_s32_m(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s16_m)))
+svint16_t svlsl_wide_n_s16_m(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u8_x)))
+svuint8_t svlsl_wide_n_u8_x(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u32_x)))
+svuint32_t svlsl_wide_n_u32_x(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u16_x)))
+svuint16_t svlsl_wide_n_u16_x(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s8_x)))
+svint8_t svlsl_wide_n_s8_x(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s32_x)))
+svint32_t svlsl_wide_n_s32_x(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s16_x)))
+svint16_t svlsl_wide_n_s16_x(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u8_z)))
+svuint8_t svlsl_wide_n_u8_z(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u32_z)))
+svuint32_t svlsl_wide_n_u32_z(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u16_z)))
+svuint16_t svlsl_wide_n_u16_z(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s8_z)))
+svint8_t svlsl_wide_n_s8_z(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s32_z)))
+svint32_t svlsl_wide_n_s32_z(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s16_z)))
+svint16_t svlsl_wide_n_s16_z(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u8_m)))
+svuint8_t svlsl_wide_u8_m(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u32_m)))
+svuint32_t svlsl_wide_u32_m(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u16_m)))
+svuint16_t svlsl_wide_u16_m(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s8_m)))
+svint8_t svlsl_wide_s8_m(svbool_t, svint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s32_m)))
+svint32_t svlsl_wide_s32_m(svbool_t, svint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s16_m)))
+svint16_t svlsl_wide_s16_m(svbool_t, svint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u8_x)))
+svuint8_t svlsl_wide_u8_x(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u32_x)))
+svuint32_t svlsl_wide_u32_x(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u16_x)))
+svuint16_t svlsl_wide_u16_x(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s8_x)))
+svint8_t svlsl_wide_s8_x(svbool_t, svint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s32_x)))
+svint32_t svlsl_wide_s32_x(svbool_t, svint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s16_x)))
+svint16_t svlsl_wide_s16_x(svbool_t, svint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u8_z)))
+svuint8_t svlsl_wide_u8_z(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u32_z)))
+svuint32_t svlsl_wide_u32_z(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u16_z)))
+svuint16_t svlsl_wide_u16_z(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s8_z)))
+svint8_t svlsl_wide_s8_z(svbool_t, svint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s32_z)))
+svint32_t svlsl_wide_s32_z(svbool_t, svint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s16_z)))
+svint16_t svlsl_wide_s16_z(svbool_t, svint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u8_m)))
+svuint8_t svlsr_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u32_m)))
+svuint32_t svlsr_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u64_m)))
+svuint64_t svlsr_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u16_m)))
+svuint16_t svlsr_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u8_x)))
+svuint8_t svlsr_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u32_x)))
+svuint32_t svlsr_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u64_x)))
+svuint64_t svlsr_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u16_x)))
+svuint16_t svlsr_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u8_z)))
+svuint8_t svlsr_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u32_z)))
+svuint32_t svlsr_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u64_z)))
+svuint64_t svlsr_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u16_z)))
+svuint16_t svlsr_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u8_m)))
+svuint8_t svlsr_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u32_m)))
+svuint32_t svlsr_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u64_m)))
+svuint64_t svlsr_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u16_m)))
+svuint16_t svlsr_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u8_x)))
+svuint8_t svlsr_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u32_x)))
+svuint32_t svlsr_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u64_x)))
+svuint64_t svlsr_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u16_x)))
+svuint16_t svlsr_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u8_z)))
+svuint8_t svlsr_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u32_z)))
+svuint32_t svlsr_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u64_z)))
+svuint64_t svlsr_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u16_z)))
+svuint16_t svlsr_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u8_m)))
+svuint8_t svlsr_wide_n_u8_m(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u32_m)))
+svuint32_t svlsr_wide_n_u32_m(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u16_m)))
+svuint16_t svlsr_wide_n_u16_m(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u8_x)))
+svuint8_t svlsr_wide_n_u8_x(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u32_x)))
+svuint32_t svlsr_wide_n_u32_x(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u16_x)))
+svuint16_t svlsr_wide_n_u16_x(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u8_z)))
+svuint8_t svlsr_wide_n_u8_z(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u32_z)))
+svuint32_t svlsr_wide_n_u32_z(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u16_z)))
+svuint16_t svlsr_wide_n_u16_z(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u8_m)))
+svuint8_t svlsr_wide_u8_m(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u32_m)))
+svuint32_t svlsr_wide_u32_m(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u16_m)))
+svuint16_t svlsr_wide_u16_m(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u8_x)))
+svuint8_t svlsr_wide_u8_x(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u32_x)))
+svuint32_t svlsr_wide_u32_x(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u16_x)))
+svuint16_t svlsr_wide_u16_x(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u8_z)))
+svuint8_t svlsr_wide_u8_z(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u32_z)))
+svuint32_t svlsr_wide_u32_z(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u16_z)))
+svuint16_t svlsr_wide_u16_z(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f64_m)))
+svfloat64_t svmad_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f32_m)))
+svfloat32_t svmad_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f16_m)))
+svfloat16_t svmad_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f64_x)))
+svfloat64_t svmad_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f32_x)))
+svfloat32_t svmad_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f16_x)))
+svfloat16_t svmad_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f64_z)))
+svfloat64_t svmad_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f32_z)))
+svfloat32_t svmad_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f16_z)))
+svfloat16_t svmad_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u8_m)))
+svuint8_t svmad_n_u8_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u32_m)))
+svuint32_t svmad_n_u32_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u64_m)))
+svuint64_t svmad_n_u64_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u16_m)))
+svuint16_t svmad_n_u16_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s8_m)))
+svint8_t svmad_n_s8_m(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s32_m)))
+svint32_t svmad_n_s32_m(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s64_m)))
+svint64_t svmad_n_s64_m(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s16_m)))
+svint16_t svmad_n_s16_m(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u8_x)))
+svuint8_t svmad_n_u8_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u32_x)))
+svuint32_t svmad_n_u32_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u64_x)))
+svuint64_t svmad_n_u64_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u16_x)))
+svuint16_t svmad_n_u16_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s8_x)))
+svint8_t svmad_n_s8_x(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s32_x)))
+svint32_t svmad_n_s32_x(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s64_x)))
+svint64_t svmad_n_s64_x(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s16_x)))
+svint16_t svmad_n_s16_x(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u8_z)))
+svuint8_t svmad_n_u8_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u32_z)))
+svuint32_t svmad_n_u32_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u64_z)))
+svuint64_t svmad_n_u64_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u16_z)))
+svuint16_t svmad_n_u16_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s8_z)))
+svint8_t svmad_n_s8_z(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s32_z)))
+svint32_t svmad_n_s32_z(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s64_z)))
+svint64_t svmad_n_s64_z(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s16_z)))
+svint16_t svmad_n_s16_z(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f64_m)))
+svfloat64_t svmad_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f32_m)))
+svfloat32_t svmad_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f16_m)))
+svfloat16_t svmad_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f64_x)))
+svfloat64_t svmad_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f32_x)))
+svfloat32_t svmad_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f16_x)))
+svfloat16_t svmad_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f64_z)))
+svfloat64_t svmad_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f32_z)))
+svfloat32_t svmad_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f16_z)))
+svfloat16_t svmad_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u8_m)))
+svuint8_t svmad_u8_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u32_m)))
+svuint32_t svmad_u32_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u64_m)))
+svuint64_t svmad_u64_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u16_m)))
+svuint16_t svmad_u16_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s8_m)))
+svint8_t svmad_s8_m(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s32_m)))
+svint32_t svmad_s32_m(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s64_m)))
+svint64_t svmad_s64_m(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s16_m)))
+svint16_t svmad_s16_m(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u8_x)))
+svuint8_t svmad_u8_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u32_x)))
+svuint32_t svmad_u32_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u64_x)))
+svuint64_t svmad_u64_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u16_x)))
+svuint16_t svmad_u16_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s8_x)))
+svint8_t svmad_s8_x(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s32_x)))
+svint32_t svmad_s32_x(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s64_x)))
+svint64_t svmad_s64_x(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s16_x)))
+svint16_t svmad_s16_x(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u8_z)))
+svuint8_t svmad_u8_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u32_z)))
+svuint32_t svmad_u32_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u64_z)))
+svuint64_t svmad_u64_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u16_z)))
+svuint16_t svmad_u16_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s8_z)))
+svint8_t svmad_s8_z(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s32_z)))
+svint32_t svmad_s32_z(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s64_z)))
+svint64_t svmad_s64_z(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s16_z)))
+svint16_t svmad_s16_z(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f64_m)))
+svfloat64_t svmax_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f32_m)))
+svfloat32_t svmax_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f16_m)))
+svfloat16_t svmax_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f64_x)))
+svfloat64_t svmax_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f32_x)))
+svfloat32_t svmax_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f16_x)))
+svfloat16_t svmax_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f64_z)))
+svfloat64_t svmax_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f32_z)))
+svfloat32_t svmax_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f16_z)))
+svfloat16_t svmax_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s8_m)))
+svint8_t svmax_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s32_m)))
+svint32_t svmax_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s64_m)))
+svint64_t svmax_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s16_m)))
+svint16_t svmax_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s8_x)))
+svint8_t svmax_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s32_x)))
+svint32_t svmax_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s64_x)))
+svint64_t svmax_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s16_x)))
+svint16_t svmax_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s8_z)))
+svint8_t svmax_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s32_z)))
+svint32_t svmax_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s64_z)))
+svint64_t svmax_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s16_z)))
+svint16_t svmax_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u8_m)))
+svuint8_t svmax_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u32_m)))
+svuint32_t svmax_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u64_m)))
+svuint64_t svmax_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u16_m)))
+svuint16_t svmax_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u8_x)))
+svuint8_t svmax_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u32_x)))
+svuint32_t svmax_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u64_x)))
+svuint64_t svmax_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u16_x)))
+svuint16_t svmax_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u8_z)))
+svuint8_t svmax_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u32_z)))
+svuint32_t svmax_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u64_z)))
+svuint64_t svmax_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u16_z)))
+svuint16_t svmax_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_m)))
+svfloat64_t svmax_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_m)))
+svfloat32_t svmax_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_m)))
+svfloat16_t svmax_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_x)))
+svfloat64_t svmax_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_x)))
+svfloat32_t svmax_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_x)))
+svfloat16_t svmax_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_z)))
+svfloat64_t svmax_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_z)))
+svfloat32_t svmax_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_z)))
+svfloat16_t svmax_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_m)))
+svint8_t svmax_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_m)))
+svint32_t svmax_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_m)))
+svint64_t svmax_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_m)))
+svint16_t svmax_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_x)))
+svint8_t svmax_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_x)))
+svint32_t svmax_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_x)))
+svint64_t svmax_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_x)))
+svint16_t svmax_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_z)))
+svint8_t svmax_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_z)))
+svint32_t svmax_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_z)))
+svint64_t svmax_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_z)))
+svint16_t svmax_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_m)))
+svuint8_t svmax_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_m)))
+svuint32_t svmax_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_m)))
+svuint64_t svmax_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_m)))
+svuint16_t svmax_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_x)))
+svuint8_t svmax_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_x)))
+svuint32_t svmax_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_x)))
+svuint64_t svmax_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_x)))
+svuint16_t svmax_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_z)))
+svuint8_t svmax_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_z)))
+svuint32_t svmax_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_z)))
+svuint64_t svmax_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_z)))
+svuint16_t svmax_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f64_m)))
+svfloat64_t svmaxnm_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f32_m)))
+svfloat32_t svmaxnm_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f16_m)))
+svfloat16_t svmaxnm_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f64_x)))
+svfloat64_t svmaxnm_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f32_x)))
+svfloat32_t svmaxnm_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f16_x)))
+svfloat16_t svmaxnm_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f64_z)))
+svfloat64_t svmaxnm_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f32_z)))
+svfloat32_t svmaxnm_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f16_z)))
+svfloat16_t svmaxnm_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_m)))
+svfloat64_t svmaxnm_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_m)))
+svfloat32_t svmaxnm_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_m)))
+svfloat16_t svmaxnm_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_x)))
+svfloat64_t svmaxnm_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_x)))
+svfloat32_t svmaxnm_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x)))
+svfloat16_t svmaxnm_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_z)))
+svfloat64_t svmaxnm_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_z)))
+svfloat32_t svmaxnm_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_z)))
+svfloat16_t svmaxnm_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmv_f64)))
+float64_t svmaxnmv_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmv_f32)))
+float32_t svmaxnmv_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmv_f16)))
+float16_t svmaxnmv_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_f64)))
+float64_t svmaxv_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_f32)))
+float32_t svmaxv_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_f16)))
+float16_t svmaxv_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s8)))
+int8_t svmaxv_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s32)))
+int32_t svmaxv_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s64)))
+int64_t svmaxv_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s16)))
+int16_t svmaxv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u8)))
+uint8_t svmaxv_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u32)))
+uint32_t svmaxv_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u64)))
+uint64_t svmaxv_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u16)))
+uint16_t svmaxv_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f64_m)))
+svfloat64_t svmin_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f32_m)))
+svfloat32_t svmin_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f16_m)))
+svfloat16_t svmin_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f64_x)))
+svfloat64_t svmin_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f32_x)))
+svfloat32_t svmin_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f16_x)))
+svfloat16_t svmin_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f64_z)))
+svfloat64_t svmin_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f32_z)))
+svfloat32_t svmin_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f16_z)))
+svfloat16_t svmin_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s8_m)))
+svint8_t svmin_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s32_m)))
+svint32_t svmin_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s64_m)))
+svint64_t svmin_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s16_m)))
+svint16_t svmin_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s8_x)))
+svint8_t svmin_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s32_x)))
+svint32_t svmin_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s64_x)))
+svint64_t svmin_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s16_x)))
+svint16_t svmin_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s8_z)))
+svint8_t svmin_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s32_z)))
+svint32_t svmin_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s64_z)))
+svint64_t svmin_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s16_z)))
+svint16_t svmin_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u8_m)))
+svuint8_t svmin_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u32_m)))
+svuint32_t svmin_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u64_m)))
+svuint64_t svmin_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u16_m)))
+svuint16_t svmin_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u8_x)))
+svuint8_t svmin_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u32_x)))
+svuint32_t svmin_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u64_x)))
+svuint64_t svmin_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u16_x)))
+svuint16_t svmin_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u8_z)))
+svuint8_t svmin_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u32_z)))
+svuint32_t svmin_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u64_z)))
+svuint64_t svmin_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u16_z)))
+svuint16_t svmin_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_m)))
+svfloat64_t svmin_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_m)))
+svfloat32_t svmin_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_m)))
+svfloat16_t svmin_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_x)))
+svfloat64_t svmin_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_x)))
+svfloat32_t svmin_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_x)))
+svfloat16_t svmin_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_z)))
+svfloat64_t svmin_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_z)))
+svfloat32_t svmin_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_z)))
+svfloat16_t svmin_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_m)))
+svint8_t svmin_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_m)))
+svint32_t svmin_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_m)))
+svint64_t svmin_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_m)))
+svint16_t svmin_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_x)))
+svint8_t svmin_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_x)))
+svint32_t svmin_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_x)))
+svint64_t svmin_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_x)))
+svint16_t svmin_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_z)))
+svint8_t svmin_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_z)))
+svint32_t svmin_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_z)))
+svint64_t svmin_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_z)))
+svint16_t svmin_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_m)))
+svuint8_t svmin_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_m)))
+svuint32_t svmin_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_m)))
+svuint64_t svmin_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_m)))
+svuint16_t svmin_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_x)))
+svuint8_t svmin_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_x)))
+svuint32_t svmin_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_x)))
+svuint64_t svmin_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_x)))
+svuint16_t svmin_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_z)))
+svuint8_t svmin_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_z)))
+svuint32_t svmin_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_z)))
+svuint64_t svmin_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_z)))
+svuint16_t svmin_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f64_m)))
+svfloat64_t svminnm_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f32_m)))
+svfloat32_t svminnm_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f16_m)))
+svfloat16_t svminnm_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f64_x)))
+svfloat64_t svminnm_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f32_x)))
+svfloat32_t svminnm_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f16_x)))
+svfloat16_t svminnm_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f64_z)))
+svfloat64_t svminnm_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f32_z)))
+svfloat32_t svminnm_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f16_z)))
+svfloat16_t svminnm_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_m)))
+svfloat64_t svminnm_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_m)))
+svfloat32_t svminnm_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_m)))
+svfloat16_t svminnm_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_x)))
+svfloat64_t svminnm_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_x)))
+svfloat32_t svminnm_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_x)))
+svfloat16_t svminnm_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_z)))
+svfloat64_t svminnm_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_z)))
+svfloat32_t svminnm_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_z)))
+svfloat16_t svminnm_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmv_f64)))
+float64_t svminnmv_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmv_f32)))
+float32_t svminnmv_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmv_f16)))
+float16_t svminnmv_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_f64)))
+float64_t svminv_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_f32)))
+float32_t svminv_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_f16)))
+float16_t svminv_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s8)))
+int8_t svminv_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s32)))
+int32_t svminv_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s64)))
+int64_t svminv_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s16)))
+int16_t svminv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u8)))
+uint8_t svminv_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u32)))
+uint32_t svminv_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u64)))
+uint64_t svminv_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u16)))
+uint16_t svminv_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f64_m)))
+svfloat64_t svmla_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f32_m)))
+svfloat32_t svmla_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f16_m)))
+svfloat16_t svmla_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f64_x)))
+svfloat64_t svmla_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f32_x)))
+svfloat32_t svmla_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f16_x)))
+svfloat16_t svmla_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f64_z)))
+svfloat64_t svmla_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f32_z)))
+svfloat32_t svmla_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f16_z)))
+svfloat16_t svmla_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u8_m)))
+svuint8_t svmla_n_u8_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u32_m)))
+svuint32_t svmla_n_u32_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u64_m)))
+svuint64_t svmla_n_u64_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u16_m)))
+svuint16_t svmla_n_u16_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s8_m)))
+svint8_t svmla_n_s8_m(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s32_m)))
+svint32_t svmla_n_s32_m(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s64_m)))
+svint64_t svmla_n_s64_m(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s16_m)))
+svint16_t svmla_n_s16_m(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u8_x)))
+svuint8_t svmla_n_u8_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u32_x)))
+svuint32_t svmla_n_u32_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u64_x)))
+svuint64_t svmla_n_u64_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u16_x)))
+svuint16_t svmla_n_u16_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s8_x)))
+svint8_t svmla_n_s8_x(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s32_x)))
+svint32_t svmla_n_s32_x(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s64_x)))
+svint64_t svmla_n_s64_x(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s16_x)))
+svint16_t svmla_n_s16_x(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u8_z)))
+svuint8_t svmla_n_u8_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u32_z)))
+svuint32_t svmla_n_u32_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u64_z)))
+svuint64_t svmla_n_u64_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u16_z)))
+svuint16_t svmla_n_u16_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s8_z)))
+svint8_t svmla_n_s8_z(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s32_z)))
+svint32_t svmla_n_s32_z(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s64_z)))
+svint64_t svmla_n_s64_z(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s16_z)))
+svint16_t svmla_n_s16_z(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f64_m)))
+svfloat64_t svmla_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f32_m)))
+svfloat32_t svmla_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f16_m)))
+svfloat16_t svmla_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f64_x)))
+svfloat64_t svmla_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f32_x)))
+svfloat32_t svmla_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f16_x)))
+svfloat16_t svmla_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f64_z)))
+svfloat64_t svmla_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f32_z)))
+svfloat32_t svmla_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f16_z)))
+svfloat16_t svmla_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u8_m)))
+svuint8_t svmla_u8_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u32_m)))
+svuint32_t svmla_u32_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u64_m)))
+svuint64_t svmla_u64_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u16_m)))
+svuint16_t svmla_u16_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s8_m)))
+svint8_t svmla_s8_m(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s32_m)))
+svint32_t svmla_s32_m(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s64_m)))
+svint64_t svmla_s64_m(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s16_m)))
+svint16_t svmla_s16_m(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u8_x)))
+svuint8_t svmla_u8_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u32_x)))
+svuint32_t svmla_u32_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u64_x)))
+svuint64_t svmla_u64_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u16_x)))
+svuint16_t svmla_u16_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s8_x)))
+svint8_t svmla_s8_x(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s32_x)))
+svint32_t svmla_s32_x(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s64_x)))
+svint64_t svmla_s64_x(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s16_x)))
+svint16_t svmla_s16_x(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u8_z)))
+svuint8_t svmla_u8_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u32_z)))
+svuint32_t svmla_u32_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u64_z)))
+svuint64_t svmla_u64_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u16_z)))
+svuint16_t svmla_u16_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s8_z)))
+svint8_t svmla_s8_z(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s32_z)))
+svint32_t svmla_s32_z(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s64_z)))
+svint64_t svmla_s64_z(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s16_z)))
+svint16_t svmla_s16_z(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_f64)))
+svfloat64_t svmla_lane_f64(svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_f32)))
+svfloat32_t svmla_lane_f32(svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_f16)))
+svfloat16_t svmla_lane_f16(svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f64_m)))
+svfloat64_t svmls_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f32_m)))
+svfloat32_t svmls_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f16_m)))
+svfloat16_t svmls_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f64_x)))
+svfloat64_t svmls_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f32_x)))
+svfloat32_t svmls_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f16_x)))
+svfloat16_t svmls_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f64_z)))
+svfloat64_t svmls_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f32_z)))
+svfloat32_t svmls_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f16_z)))
+svfloat16_t svmls_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u8_m)))
+svuint8_t svmls_n_u8_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u32_m)))
+svuint32_t svmls_n_u32_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u64_m)))
+svuint64_t svmls_n_u64_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u16_m)))
+svuint16_t svmls_n_u16_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s8_m)))
+svint8_t svmls_n_s8_m(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s32_m)))
+svint32_t svmls_n_s32_m(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s64_m)))
+svint64_t svmls_n_s64_m(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s16_m)))
+svint16_t svmls_n_s16_m(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u8_x)))
+svuint8_t svmls_n_u8_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u32_x)))
+svuint32_t svmls_n_u32_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u64_x)))
+svuint64_t svmls_n_u64_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u16_x)))
+svuint16_t svmls_n_u16_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s8_x)))
+svint8_t svmls_n_s8_x(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s32_x)))
+svint32_t svmls_n_s32_x(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s64_x)))
+svint64_t svmls_n_s64_x(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s16_x)))
+svint16_t svmls_n_s16_x(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u8_z)))
+svuint8_t svmls_n_u8_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u32_z)))
+svuint32_t svmls_n_u32_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u64_z)))
+svuint64_t svmls_n_u64_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u16_z)))
+svuint16_t svmls_n_u16_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s8_z)))
+svint8_t svmls_n_s8_z(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s32_z)))
+svint32_t svmls_n_s32_z(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s64_z)))
+svint64_t svmls_n_s64_z(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s16_z)))
+svint16_t svmls_n_s16_z(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f64_m)))
+svfloat64_t svmls_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f32_m)))
+svfloat32_t svmls_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f16_m)))
+svfloat16_t svmls_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f64_x)))
+svfloat64_t svmls_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f32_x)))
+svfloat32_t svmls_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f16_x)))
+svfloat16_t svmls_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f64_z)))
+svfloat64_t svmls_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f32_z)))
+svfloat32_t svmls_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f16_z)))
+svfloat16_t svmls_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u8_m)))
+svuint8_t svmls_u8_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u32_m)))
+svuint32_t svmls_u32_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u64_m)))
+svuint64_t svmls_u64_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u16_m)))
+svuint16_t svmls_u16_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s8_m)))
+svint8_t svmls_s8_m(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s32_m)))
+svint32_t svmls_s32_m(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s64_m)))
+svint64_t svmls_s64_m(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s16_m)))
+svint16_t svmls_s16_m(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u8_x)))
+svuint8_t svmls_u8_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u32_x)))
+svuint32_t svmls_u32_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u64_x)))
+svuint64_t svmls_u64_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u16_x)))
+svuint16_t svmls_u16_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s8_x)))
+svint8_t svmls_s8_x(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s32_x)))
+svint32_t svmls_s32_x(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s64_x)))
+svint64_t svmls_s64_x(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s16_x)))
+svint16_t svmls_s16_x(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u8_z)))
+svuint8_t svmls_u8_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u32_z)))
+svuint32_t svmls_u32_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u64_z)))
+svuint64_t svmls_u64_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u16_z)))
+svuint16_t svmls_u16_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s8_z)))
+svint8_t svmls_s8_z(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s32_z)))
+svint32_t svmls_s32_z(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s64_z)))
+svint64_t svmls_s64_z(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s16_z)))
+svint16_t svmls_s16_z(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_f64)))
+svfloat64_t svmls_lane_f64(svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_f32)))
+svfloat32_t svmls_lane_f32(svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_f16)))
+svfloat16_t svmls_lane_f16(svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmov_b_z)))
+svbool_t svmov_b_z(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f64_m)))
+svfloat64_t svmsb_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f32_m)))
+svfloat32_t svmsb_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f16_m)))
+svfloat16_t svmsb_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f64_x)))
+svfloat64_t svmsb_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f32_x)))
+svfloat32_t svmsb_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f16_x)))
+svfloat16_t svmsb_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f64_z)))
+svfloat64_t svmsb_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f32_z)))
+svfloat32_t svmsb_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f16_z)))
+svfloat16_t svmsb_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u8_m)))
+svuint8_t svmsb_n_u8_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u32_m)))
+svuint32_t svmsb_n_u32_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u64_m)))
+svuint64_t svmsb_n_u64_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u16_m)))
+svuint16_t svmsb_n_u16_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s8_m)))
+svint8_t svmsb_n_s8_m(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s32_m)))
+svint32_t svmsb_n_s32_m(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s64_m)))
+svint64_t svmsb_n_s64_m(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s16_m)))
+svint16_t svmsb_n_s16_m(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u8_x)))
+svuint8_t svmsb_n_u8_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u32_x)))
+svuint32_t svmsb_n_u32_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u64_x)))
+svuint64_t svmsb_n_u64_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u16_x)))
+svuint16_t svmsb_n_u16_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s8_x)))
+svint8_t svmsb_n_s8_x(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s32_x)))
+svint32_t svmsb_n_s32_x(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s64_x)))
+svint64_t svmsb_n_s64_x(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s16_x)))
+svint16_t svmsb_n_s16_x(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u8_z)))
+svuint8_t svmsb_n_u8_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u32_z)))
+svuint32_t svmsb_n_u32_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u64_z)))
+svuint64_t svmsb_n_u64_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u16_z)))
+svuint16_t svmsb_n_u16_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s8_z)))
+svint8_t svmsb_n_s8_z(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s32_z)))
+svint32_t svmsb_n_s32_z(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s64_z)))
+svint64_t svmsb_n_s64_z(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s16_z)))
+svint16_t svmsb_n_s16_z(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f64_m)))
+svfloat64_t svmsb_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f32_m)))
+svfloat32_t svmsb_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f16_m)))
+svfloat16_t svmsb_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f64_x)))
+svfloat64_t svmsb_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f32_x)))
+svfloat32_t svmsb_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f16_x)))
+svfloat16_t svmsb_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f64_z)))
+svfloat64_t svmsb_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f32_z)))
+svfloat32_t svmsb_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f16_z)))
+svfloat16_t svmsb_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u8_m)))
+svuint8_t svmsb_u8_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u32_m)))
+svuint32_t svmsb_u32_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u64_m)))
+svuint64_t svmsb_u64_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u16_m)))
+svuint16_t svmsb_u16_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s8_m)))
+svint8_t svmsb_s8_m(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s32_m)))
+svint32_t svmsb_s32_m(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s64_m)))
+svint64_t svmsb_s64_m(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s16_m)))
+svint16_t svmsb_s16_m(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u8_x)))
+svuint8_t svmsb_u8_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u32_x)))
+svuint32_t svmsb_u32_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u64_x)))
+svuint64_t svmsb_u64_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u16_x)))
+svuint16_t svmsb_u16_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s8_x)))
+svint8_t svmsb_s8_x(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s32_x)))
+svint32_t svmsb_s32_x(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s64_x)))
+svint64_t svmsb_s64_x(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s16_x)))
+svint16_t svmsb_s16_x(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u8_z)))
+svuint8_t svmsb_u8_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u32_z)))
+svuint32_t svmsb_u32_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u64_z)))
+svuint64_t svmsb_u64_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u16_z)))
+svuint16_t svmsb_u16_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s8_z)))
+svint8_t svmsb_s8_z(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s32_z)))
+svint32_t svmsb_s32_z(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s64_z)))
+svint64_t svmsb_s64_z(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s16_z)))
+svint16_t svmsb_s16_z(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f64_m)))
+svfloat64_t svmul_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f32_m)))
+svfloat32_t svmul_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f16_m)))
+svfloat16_t svmul_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f64_x)))
+svfloat64_t svmul_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f32_x)))
+svfloat32_t svmul_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f16_x)))
+svfloat16_t svmul_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f64_z)))
+svfloat64_t svmul_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f32_z)))
+svfloat32_t svmul_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f16_z)))
+svfloat16_t svmul_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u8_m)))
+svuint8_t svmul_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u32_m)))
+svuint32_t svmul_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u64_m)))
+svuint64_t svmul_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u16_m)))
+svuint16_t svmul_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s8_m)))
+svint8_t svmul_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s32_m)))
+svint32_t svmul_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s64_m)))
+svint64_t svmul_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s16_m)))
+svint16_t svmul_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u8_x)))
+svuint8_t svmul_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u32_x)))
+svuint32_t svmul_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u64_x)))
+svuint64_t svmul_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u16_x)))
+svuint16_t svmul_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s8_x)))
+svint8_t svmul_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s32_x)))
+svint32_t svmul_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s64_x)))
+svint64_t svmul_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s16_x)))
+svint16_t svmul_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u8_z)))
+svuint8_t svmul_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u32_z)))
+svuint32_t svmul_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u64_z)))
+svuint64_t svmul_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u16_z)))
+svuint16_t svmul_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s8_z)))
+svint8_t svmul_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s32_z)))
+svint32_t svmul_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s64_z)))
+svint64_t svmul_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s16_z)))
+svint16_t svmul_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f64_m)))
+svfloat64_t svmul_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f32_m)))
+svfloat32_t svmul_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f16_m)))
+svfloat16_t svmul_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f64_x)))
+svfloat64_t svmul_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f32_x)))
+svfloat32_t svmul_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f16_x)))
+svfloat16_t svmul_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f64_z)))
+svfloat64_t svmul_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f32_z)))
+svfloat32_t svmul_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f16_z)))
+svfloat16_t svmul_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u8_m)))
+svuint8_t svmul_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u32_m)))
+svuint32_t svmul_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u64_m)))
+svuint64_t svmul_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u16_m)))
+svuint16_t svmul_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s8_m)))
+svint8_t svmul_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s32_m)))
+svint32_t svmul_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s64_m)))
+svint64_t svmul_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s16_m)))
+svint16_t svmul_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u8_x)))
+svuint8_t svmul_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u32_x)))
+svuint32_t svmul_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u64_x)))
+svuint64_t svmul_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u16_x)))
+svuint16_t svmul_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s8_x)))
+svint8_t svmul_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s32_x)))
+svint32_t svmul_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s64_x)))
+svint64_t svmul_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s16_x)))
+svint16_t svmul_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u8_z)))
+svuint8_t svmul_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u32_z)))
+svuint32_t svmul_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u64_z)))
+svuint64_t svmul_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u16_z)))
+svuint16_t svmul_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s8_z)))
+svint8_t svmul_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s32_z)))
+svint32_t svmul_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s64_z)))
+svint64_t svmul_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s16_z)))
+svint16_t svmul_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_f64)))
+svfloat64_t svmul_lane_f64(svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_f32)))
+svfloat32_t svmul_lane_f32(svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_f16)))
+svfloat16_t svmul_lane_f16(svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s8_m)))
+svint8_t svmulh_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s32_m)))
+svint32_t svmulh_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s64_m)))
+svint64_t svmulh_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s16_m)))
+svint16_t svmulh_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s8_x)))
+svint8_t svmulh_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s32_x)))
+svint32_t svmulh_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s64_x)))
+svint64_t svmulh_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s16_x)))
+svint16_t svmulh_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s8_z)))
+svint8_t svmulh_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s32_z)))
+svint32_t svmulh_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s64_z)))
+svint64_t svmulh_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s16_z)))
+svint16_t svmulh_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u8_m)))
+svuint8_t svmulh_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u32_m)))
+svuint32_t svmulh_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u64_m)))
+svuint64_t svmulh_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u16_m)))
+svuint16_t svmulh_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u8_x)))
+svuint8_t svmulh_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u32_x)))
+svuint32_t svmulh_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u64_x)))
+svuint64_t svmulh_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u16_x)))
+svuint16_t svmulh_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u8_z)))
+svuint8_t svmulh_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u32_z)))
+svuint32_t svmulh_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u64_z)))
+svuint64_t svmulh_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u16_z)))
+svuint16_t svmulh_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s8_m)))
+svint8_t svmulh_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s32_m)))
+svint32_t svmulh_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s64_m)))
+svint64_t svmulh_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s16_m)))
+svint16_t svmulh_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s8_x)))
+svint8_t svmulh_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s32_x)))
+svint32_t svmulh_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s64_x)))
+svint64_t svmulh_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s16_x)))
+svint16_t svmulh_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s8_z)))
+svint8_t svmulh_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s32_z)))
+svint32_t svmulh_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s64_z)))
+svint64_t svmulh_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s16_z)))
+svint16_t svmulh_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u8_m)))
+svuint8_t svmulh_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u32_m)))
+svuint32_t svmulh_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u64_m)))
+svuint64_t svmulh_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u16_m)))
+svuint16_t svmulh_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u8_x)))
+svuint8_t svmulh_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u32_x)))
+svuint32_t svmulh_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u64_x)))
+svuint64_t svmulh_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u16_x)))
+svuint16_t svmulh_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u8_z)))
+svuint8_t svmulh_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u32_z)))
+svuint32_t svmulh_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u64_z)))
+svuint64_t svmulh_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u16_z)))
+svuint16_t svmulh_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f64_m)))
+svfloat64_t svmulx_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f32_m)))
+svfloat32_t svmulx_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f16_m)))
+svfloat16_t svmulx_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f64_x)))
+svfloat64_t svmulx_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f32_x)))
+svfloat32_t svmulx_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f16_x)))
+svfloat16_t svmulx_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f64_z)))
+svfloat64_t svmulx_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f32_z)))
+svfloat32_t svmulx_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f16_z)))
+svfloat16_t svmulx_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f64_m)))
+svfloat64_t svmulx_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f32_m)))
+svfloat32_t svmulx_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f16_m)))
+svfloat16_t svmulx_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f64_x)))
+svfloat64_t svmulx_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f32_x)))
+svfloat32_t svmulx_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f16_x)))
+svfloat16_t svmulx_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f64_z)))
+svfloat64_t svmulx_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f32_z)))
+svfloat32_t svmulx_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f16_z)))
+svfloat16_t svmulx_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnand_b_z)))
+svbool_t svnand_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f64_m)))
+svfloat64_t svneg_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f32_m)))
+svfloat32_t svneg_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f16_m)))
+svfloat16_t svneg_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f64_x)))
+svfloat64_t svneg_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f32_x)))
+svfloat32_t svneg_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f16_x)))
+svfloat16_t svneg_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f64_z)))
+svfloat64_t svneg_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f32_z)))
+svfloat32_t svneg_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f16_z)))
+svfloat16_t svneg_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s8_m)))
+svint8_t svneg_s8_m(svint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s32_m)))
+svint32_t svneg_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s64_m)))
+svint64_t svneg_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s16_m)))
+svint16_t svneg_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s8_x)))
+svint8_t svneg_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s32_x)))
+svint32_t svneg_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s64_x)))
+svint64_t svneg_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s16_x)))
+svint16_t svneg_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s8_z)))
+svint8_t svneg_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s32_z)))
+svint32_t svneg_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s64_z)))
+svint64_t svneg_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s16_z)))
+svint16_t svneg_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f64_m)))
+svfloat64_t svnmad_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f32_m)))
+svfloat32_t svnmad_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f16_m)))
+svfloat16_t svnmad_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f64_x)))
+svfloat64_t svnmad_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f32_x)))
+svfloat32_t svnmad_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f16_x)))
+svfloat16_t svnmad_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f64_z)))
+svfloat64_t svnmad_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f32_z)))
+svfloat32_t svnmad_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f16_z)))
+svfloat16_t svnmad_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f64_m)))
+svfloat64_t svnmad_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f32_m)))
+svfloat32_t svnmad_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f16_m)))
+svfloat16_t svnmad_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f64_x)))
+svfloat64_t svnmad_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f32_x)))
+svfloat32_t svnmad_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f16_x)))
+svfloat16_t svnmad_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f64_z)))
+svfloat64_t svnmad_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f32_z)))
+svfloat32_t svnmad_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f16_z)))
+svfloat16_t svnmad_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f64_m)))
+svfloat64_t svnmla_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f32_m)))
+svfloat32_t svnmla_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f16_m)))
+svfloat16_t svnmla_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f64_x)))
+svfloat64_t svnmla_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f32_x)))
+svfloat32_t svnmla_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f16_x)))
+svfloat16_t svnmla_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f64_z)))
+svfloat64_t svnmla_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f32_z)))
+svfloat32_t svnmla_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f16_z)))
+svfloat16_t svnmla_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f64_m)))
+svfloat64_t svnmla_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f32_m)))
+svfloat32_t svnmla_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f16_m)))
+svfloat16_t svnmla_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f64_x)))
+svfloat64_t svnmla_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f32_x)))
+svfloat32_t svnmla_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f16_x)))
+svfloat16_t svnmla_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f64_z)))
+svfloat64_t svnmla_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f32_z)))
+svfloat32_t svnmla_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f16_z)))
+svfloat16_t svnmla_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f64_m)))
+svfloat64_t svnmls_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f32_m)))
+svfloat32_t svnmls_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f16_m)))
+svfloat16_t svnmls_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f64_x)))
+svfloat64_t svnmls_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f32_x)))
+svfloat32_t svnmls_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f16_x)))
+svfloat16_t svnmls_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f64_z)))
+svfloat64_t svnmls_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f32_z)))
+svfloat32_t svnmls_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f16_z)))
+svfloat16_t svnmls_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f64_m)))
+svfloat64_t svnmls_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f32_m)))
+svfloat32_t svnmls_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f16_m)))
+svfloat16_t svnmls_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f64_x)))
+svfloat64_t svnmls_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f32_x)))
+svfloat32_t svnmls_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f16_x)))
+svfloat16_t svnmls_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f64_z)))
+svfloat64_t svnmls_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f32_z)))
+svfloat32_t svnmls_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f16_z)))
+svfloat16_t svnmls_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f64_m)))
+svfloat64_t svnmsb_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f32_m)))
+svfloat32_t svnmsb_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f16_m)))
+svfloat16_t svnmsb_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f64_x)))
+svfloat64_t svnmsb_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f32_x)))
+svfloat32_t svnmsb_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f16_x)))
+svfloat16_t svnmsb_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f64_z)))
+svfloat64_t svnmsb_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f32_z)))
+svfloat32_t svnmsb_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f16_z)))
+svfloat16_t svnmsb_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f64_m)))
+svfloat64_t svnmsb_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f32_m)))
+svfloat32_t svnmsb_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f16_m)))
+svfloat16_t svnmsb_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f64_x)))
+svfloat64_t svnmsb_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f32_x)))
+svfloat32_t svnmsb_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f16_x)))
+svfloat16_t svnmsb_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f64_z)))
+svfloat64_t svnmsb_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f32_z)))
+svfloat32_t svnmsb_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f16_z)))
+svfloat16_t svnmsb_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnor_b_z)))
+svbool_t svnor_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_b_z)))
+svbool_t svnot_b_z(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u8_m)))
+svuint8_t svnot_u8_m(svuint8_t, svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u32_m)))
+svuint32_t svnot_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u64_m)))
+svuint64_t svnot_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u16_m)))
+svuint16_t svnot_u16_m(svuint16_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s8_m)))
+svint8_t svnot_s8_m(svint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s32_m)))
+svint32_t svnot_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s64_m)))
+svint64_t svnot_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s16_m)))
+svint16_t svnot_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u8_x)))
+svuint8_t svnot_u8_x(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u32_x)))
+svuint32_t svnot_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u64_x)))
+svuint64_t svnot_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u16_x)))
+svuint16_t svnot_u16_x(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s8_x)))
+svint8_t svnot_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s32_x)))
+svint32_t svnot_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s64_x)))
+svint64_t svnot_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s16_x)))
+svint16_t svnot_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u8_z)))
+svuint8_t svnot_u8_z(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u32_z)))
+svuint32_t svnot_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u64_z)))
+svuint64_t svnot_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u16_z)))
+svuint16_t svnot_u16_z(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s8_z)))
+svint8_t svnot_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s32_z)))
+svint32_t svnot_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s64_z)))
+svint64_t svnot_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s16_z)))
+svint16_t svnot_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorn_b_z)))
+svbool_t svorn_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_b_z)))
+svbool_t svorr_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u8_m)))
+svuint8_t svorr_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u32_m)))
+svuint32_t svorr_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u64_m)))
+svuint64_t svorr_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u16_m)))
+svuint16_t svorr_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s8_m)))
+svint8_t svorr_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s32_m)))
+svint32_t svorr_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s64_m)))
+svint64_t svorr_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s16_m)))
+svint16_t svorr_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u8_x)))
+svuint8_t svorr_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u32_x)))
+svuint32_t svorr_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u64_x)))
+svuint64_t svorr_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u16_x)))
+svuint16_t svorr_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s8_x)))
+svint8_t svorr_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s32_x)))
+svint32_t svorr_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s64_x)))
+svint64_t svorr_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s16_x)))
+svint16_t svorr_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u8_z)))
+svuint8_t svorr_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u32_z)))
+svuint32_t svorr_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u64_z)))
+svuint64_t svorr_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u16_z)))
+svuint16_t svorr_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s8_z)))
+svint8_t svorr_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s32_z)))
+svint32_t svorr_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s64_z)))
+svint64_t svorr_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s16_z)))
+svint16_t svorr_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u8_m)))
+svuint8_t svorr_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u32_m)))
+svuint32_t svorr_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u64_m)))
+svuint64_t svorr_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u16_m)))
+svuint16_t svorr_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s8_m)))
+svint8_t svorr_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s32_m)))
+svint32_t svorr_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s64_m)))
+svint64_t svorr_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s16_m)))
+svint16_t svorr_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u8_x)))
+svuint8_t svorr_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u32_x)))
+svuint32_t svorr_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u64_x)))
+svuint64_t svorr_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u16_x)))
+svuint16_t svorr_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s8_x)))
+svint8_t svorr_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s32_x)))
+svint32_t svorr_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s64_x)))
+svint64_t svorr_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s16_x)))
+svint16_t svorr_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u8_z)))
+svuint8_t svorr_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u32_z)))
+svuint32_t svorr_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u64_z)))
+svuint64_t svorr_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u16_z)))
+svuint16_t svorr_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s8_z)))
+svint8_t svorr_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s32_z)))
+svint32_t svorr_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s64_z)))
+svint64_t svorr_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s16_z)))
+svint16_t svorr_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u8)))
+uint8_t svorv_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u32)))
+uint32_t svorv_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u64)))
+uint64_t svorv_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u16)))
+uint16_t svorv_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s8)))
+int8_t svorv_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s32)))
+int32_t svorv_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s64)))
+int64_t svorv_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s16)))
+int16_t svorv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpfalse_b)))
+svbool_t svpfalse_b(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpfirst_b)))
+svbool_t svpfirst_b(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpnext_b8)))
+svbool_t svpnext_b8(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpnext_b32)))
+svbool_t svpnext_b32(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpnext_b64)))
+svbool_t svpnext_b64(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpnext_b16)))
+svbool_t svpnext_b16(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb)))
+void svprfb(svbool_t, void const *, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_vnum)))
+void svprfb_vnum(svbool_t, void const *, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd)))
+void svprfd(svbool_t, void const *, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_vnum)))
+void svprfd_vnum(svbool_t, void const *, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh)))
+void svprfh(svbool_t, void const *, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_vnum)))
+void svprfh_vnum(svbool_t, void const *, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw)))
+void svprfw(svbool_t, void const *, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_vnum)))
+void svprfw_vnum(svbool_t, void const *, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptest_any)))
+bool svptest_any(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptest_first)))
+bool svptest_first(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptest_last)))
+bool svptest_last(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_pat_b8)))
+svbool_t svptrue_pat_b8(enum svpattern);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_pat_b32)))
+svbool_t svptrue_pat_b32(enum svpattern);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_pat_b64)))
+svbool_t svptrue_pat_b64(enum svpattern);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_pat_b16)))
+svbool_t svptrue_pat_b16(enum svpattern);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_b8)))
+svbool_t svptrue_b8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_b32)))
+svbool_t svptrue_b32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_b64)))
+svbool_t svptrue_b64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_b16)))
+svbool_t svptrue_b16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8)))
+svint8_t svqadd_n_s8(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32)))
+svint32_t svqadd_n_s32(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64)))
+svint64_t svqadd_n_s64(svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16)))
+svint16_t svqadd_n_s16(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8)))
+svuint8_t svqadd_n_u8(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32)))
+svuint32_t svqadd_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64)))
+svuint64_t svqadd_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16)))
+svuint16_t svqadd_n_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8)))
+svint8_t svqadd_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32)))
+svint32_t svqadd_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64)))
+svint64_t svqadd_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16)))
+svint16_t svqadd_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8)))
+svuint8_t svqadd_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32)))
+svuint32_t svqadd_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64)))
+svuint64_t svqadd_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16)))
+svuint16_t svqadd_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_s32)))
+int32_t svqdecb_n_s32(int32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_s64)))
+int64_t svqdecb_n_s64(int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_u32)))
+uint32_t svqdecb_n_u32(uint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_u64)))
+uint64_t svqdecb_n_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_s32)))
+int32_t svqdecb_pat_n_s32(int32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_s64)))
+int64_t svqdecb_pat_n_s64(int64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_u32)))
+uint32_t svqdecb_pat_n_u32(uint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_u64)))
+uint64_t svqdecb_pat_n_u64(uint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_s32)))
+int32_t svqdecd_n_s32(int32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_s64)))
+int64_t svqdecd_n_s64(int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_u32)))
+uint32_t svqdecd_n_u32(uint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_u64)))
+uint64_t svqdecd_n_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_s64)))
+svint64_t svqdecd_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_u64)))
+svuint64_t svqdecd_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_s32)))
+int32_t svqdecd_pat_n_s32(int32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_s64)))
+int64_t svqdecd_pat_n_s64(int64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_u32)))
+uint32_t svqdecd_pat_n_u32(uint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_u64)))
+uint64_t svqdecd_pat_n_u64(uint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_s64)))
+svint64_t svqdecd_pat_s64(svint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_u64)))
+svuint64_t svqdecd_pat_u64(svuint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_s32)))
+int32_t svqdech_n_s32(int32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_s64)))
+int64_t svqdech_n_s64(int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_u32)))
+uint32_t svqdech_n_u32(uint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_u64)))
+uint64_t svqdech_n_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_s16)))
+svint16_t svqdech_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_u16)))
+svuint16_t svqdech_u16(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_s32)))
+int32_t svqdech_pat_n_s32(int32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_s64)))
+int64_t svqdech_pat_n_s64(int64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_u32)))
+uint32_t svqdech_pat_n_u32(uint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_u64)))
+uint64_t svqdech_pat_n_u64(uint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_s16)))
+svint16_t svqdech_pat_s16(svint16_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_u16)))
+svuint16_t svqdech_pat_u16(svuint16_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b8)))
+int32_t svqdecp_n_s32_b8(int32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b32)))
+int32_t svqdecp_n_s32_b32(int32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b64)))
+int32_t svqdecp_n_s32_b64(int32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b16)))
+int32_t svqdecp_n_s32_b16(int32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b8)))
+int64_t svqdecp_n_s64_b8(int64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b32)))
+int64_t svqdecp_n_s64_b32(int64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b64)))
+int64_t svqdecp_n_s64_b64(int64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b16)))
+int64_t svqdecp_n_s64_b16(int64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b8)))
+uint32_t svqdecp_n_u32_b8(uint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b32)))
+uint32_t svqdecp_n_u32_b32(uint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b64)))
+uint32_t svqdecp_n_u32_b64(uint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b16)))
+uint32_t svqdecp_n_u32_b16(uint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b8)))
+uint64_t svqdecp_n_u64_b8(uint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b32)))
+uint64_t svqdecp_n_u64_b32(uint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b64)))
+uint64_t svqdecp_n_u64_b64(uint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b16)))
+uint64_t svqdecp_n_u64_b16(uint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_s32)))
+svint32_t svqdecp_s32(svint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_s64)))
+svint64_t svqdecp_s64(svint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_s16)))
+svint16_t svqdecp_s16(svint16_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_u32)))
+svuint32_t svqdecp_u32(svuint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_u64)))
+svuint64_t svqdecp_u64(svuint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_u16)))
+svuint16_t svqdecp_u16(svuint16_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_s32)))
+int32_t svqdecw_n_s32(int32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_s64)))
+int64_t svqdecw_n_s64(int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_u32)))
+uint32_t svqdecw_n_u32(uint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_u64)))
+uint64_t svqdecw_n_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_s32)))
+svint32_t svqdecw_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_u32)))
+svuint32_t svqdecw_u32(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_s32)))
+int32_t svqdecw_pat_n_s32(int32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_s64)))
+int64_t svqdecw_pat_n_s64(int64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_u32)))
+uint32_t svqdecw_pat_n_u32(uint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_u64)))
+uint64_t svqdecw_pat_n_u64(uint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_s32)))
+svint32_t svqdecw_pat_s32(svint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_u32)))
+svuint32_t svqdecw_pat_u32(svuint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_s32)))
+int32_t svqincb_n_s32(int32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_s64)))
+int64_t svqincb_n_s64(int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_u32)))
+uint32_t svqincb_n_u32(uint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_u64)))
+uint64_t svqincb_n_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_s32)))
+int32_t svqincb_pat_n_s32(int32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_s64)))
+int64_t svqincb_pat_n_s64(int64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_u32)))
+uint32_t svqincb_pat_n_u32(uint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_u64)))
+uint64_t svqincb_pat_n_u64(uint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_s32)))
+int32_t svqincd_n_s32(int32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_s64)))
+int64_t svqincd_n_s64(int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_u32)))
+uint32_t svqincd_n_u32(uint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_u64)))
+uint64_t svqincd_n_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_s64)))
+svint64_t svqincd_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_u64)))
+svuint64_t svqincd_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_s32)))
+int32_t svqincd_pat_n_s32(int32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_s64)))
+int64_t svqincd_pat_n_s64(int64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_u32)))
+uint32_t svqincd_pat_n_u32(uint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_u64)))
+uint64_t svqincd_pat_n_u64(uint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_s64)))
+svint64_t svqincd_pat_s64(svint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_u64)))
+svuint64_t svqincd_pat_u64(svuint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_s32)))
+int32_t svqinch_n_s32(int32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_s64)))
+int64_t svqinch_n_s64(int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_u32)))
+uint32_t svqinch_n_u32(uint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_u64)))
+uint64_t svqinch_n_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_s16)))
+svint16_t svqinch_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_u16)))
+svuint16_t svqinch_u16(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_s32)))
+int32_t svqinch_pat_n_s32(int32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_s64)))
+int64_t svqinch_pat_n_s64(int64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_u32)))
+uint32_t svqinch_pat_n_u32(uint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_u64)))
+uint64_t svqinch_pat_n_u64(uint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_s16)))
+svint16_t svqinch_pat_s16(svint16_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_u16)))
+svuint16_t svqinch_pat_u16(svuint16_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b8)))
+int32_t svqincp_n_s32_b8(int32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b32)))
+int32_t svqincp_n_s32_b32(int32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b64)))
+int32_t svqincp_n_s32_b64(int32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b16)))
+int32_t svqincp_n_s32_b16(int32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b8)))
+int64_t svqincp_n_s64_b8(int64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b32)))
+int64_t svqincp_n_s64_b32(int64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b64)))
+int64_t svqincp_n_s64_b64(int64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b16)))
+int64_t svqincp_n_s64_b16(int64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b8)))
+uint32_t svqincp_n_u32_b8(uint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b32)))
+uint32_t svqincp_n_u32_b32(uint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b64)))
+uint32_t svqincp_n_u32_b64(uint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b16)))
+uint32_t svqincp_n_u32_b16(uint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b8)))
+uint64_t svqincp_n_u64_b8(uint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b32)))
+uint64_t svqincp_n_u64_b32(uint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b64)))
+uint64_t svqincp_n_u64_b64(uint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b16)))
+uint64_t svqincp_n_u64_b16(uint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_s32)))
+svint32_t svqincp_s32(svint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_s64)))
+svint64_t svqincp_s64(svint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_s16)))
+svint16_t svqincp_s16(svint16_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_u32)))
+svuint32_t svqincp_u32(svuint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_u64)))
+svuint64_t svqincp_u64(svuint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_u16)))
+svuint16_t svqincp_u16(svuint16_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_s32)))
+int32_t svqincw_n_s32(int32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_s64)))
+int64_t svqincw_n_s64(int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_u32)))
+uint32_t svqincw_n_u32(uint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_u64)))
+uint64_t svqincw_n_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_s32)))
+svint32_t svqincw_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_u32)))
+svuint32_t svqincw_u32(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_s32)))
+int32_t svqincw_pat_n_s32(int32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_s64)))
+int64_t svqincw_pat_n_s64(int64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_u32)))
+uint32_t svqincw_pat_n_u32(uint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_u64)))
+uint64_t svqincw_pat_n_u64(uint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_s32)))
+svint32_t svqincw_pat_s32(svint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_u32)))
+svuint32_t svqincw_pat_u32(svuint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8)))
+svint8_t svqsub_n_s8(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32)))
+svint32_t svqsub_n_s32(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64)))
+svint64_t svqsub_n_s64(svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16)))
+svint16_t svqsub_n_s16(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8)))
+svuint8_t svqsub_n_u8(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32)))
+svuint32_t svqsub_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64)))
+svuint64_t svqsub_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16)))
+svuint16_t svqsub_n_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8)))
+svint8_t svqsub_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32)))
+svint32_t svqsub_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64)))
+svint64_t svqsub_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16)))
+svint16_t svqsub_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8)))
+svuint8_t svqsub_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32)))
+svuint32_t svqsub_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64)))
+svuint64_t svqsub_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16)))
+svuint16_t svqsub_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u8_m)))
+svuint8_t svrbit_u8_m(svuint8_t, svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u32_m)))
+svuint32_t svrbit_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u64_m)))
+svuint64_t svrbit_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u16_m)))
+svuint16_t svrbit_u16_m(svuint16_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s8_m)))
+svint8_t svrbit_s8_m(svint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s32_m)))
+svint32_t svrbit_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s64_m)))
+svint64_t svrbit_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s16_m)))
+svint16_t svrbit_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u8_x)))
+svuint8_t svrbit_u8_x(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u32_x)))
+svuint32_t svrbit_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u64_x)))
+svuint64_t svrbit_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u16_x)))
+svuint16_t svrbit_u16_x(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s8_x)))
+svint8_t svrbit_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s32_x)))
+svint32_t svrbit_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s64_x)))
+svint64_t svrbit_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s16_x)))
+svint16_t svrbit_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u8_z)))
+svuint8_t svrbit_u8_z(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u32_z)))
+svuint32_t svrbit_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u64_z)))
+svuint64_t svrbit_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u16_z)))
+svuint16_t svrbit_u16_z(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s8_z)))
+svint8_t svrbit_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s32_z)))
+svint32_t svrbit_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s64_z)))
+svint64_t svrbit_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s16_z)))
+svint16_t svrbit_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_f64)))
+svfloat64_t svrecpe_f64(svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_f32)))
+svfloat32_t svrecpe_f32(svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_f16)))
+svfloat16_t svrecpe_f16(svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecps_f64)))
+svfloat64_t svrecps_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecps_f32)))
+svfloat32_t svrecps_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecps_f16)))
+svfloat16_t svrecps_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f64_m)))
+svfloat64_t svrecpx_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f32_m)))
+svfloat32_t svrecpx_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f16_m)))
+svfloat16_t svrecpx_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f64_x)))
+svfloat64_t svrecpx_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f32_x)))
+svfloat32_t svrecpx_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f16_x)))
+svfloat16_t svrecpx_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f64_z)))
+svfloat64_t svrecpx_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f32_z)))
+svfloat32_t svrecpx_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f16_z)))
+svfloat16_t svrecpx_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u8)))
+svuint8_t svrev_u8(svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u32)))
+svuint32_t svrev_u32(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u64)))
+svuint64_t svrev_u64(svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u16)))
+svuint16_t svrev_u16(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s8)))
+svint8_t svrev_s8(svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_f64)))
+svfloat64_t svrev_f64(svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_f32)))
+svfloat32_t svrev_f32(svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_f16)))
+svfloat16_t svrev_f16(svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s32)))
+svint32_t svrev_s32(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s64)))
+svint64_t svrev_s64(svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s16)))
+svint16_t svrev_s16(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_b16)))
+svbool_t svrev_b16(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_b32)))
+svbool_t svrev_b32(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_b64)))
+svbool_t svrev_b64(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_b8)))
+svbool_t svrev_b8(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u32_m)))
+svuint32_t svrevb_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u64_m)))
+svuint64_t svrevb_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u16_m)))
+svuint16_t svrevb_u16_m(svuint16_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s32_m)))
+svint32_t svrevb_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s64_m)))
+svint64_t svrevb_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s16_m)))
+svint16_t svrevb_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u32_x)))
+svuint32_t svrevb_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u64_x)))
+svuint64_t svrevb_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u16_x)))
+svuint16_t svrevb_u16_x(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s32_x)))
+svint32_t svrevb_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s64_x)))
+svint64_t svrevb_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s16_x)))
+svint16_t svrevb_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u32_z)))
+svuint32_t svrevb_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u64_z)))
+svuint64_t svrevb_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u16_z)))
+svuint16_t svrevb_u16_z(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s32_z)))
+svint32_t svrevb_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s64_z)))
+svint64_t svrevb_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s16_z)))
+svint16_t svrevb_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_m)))
+svuint32_t svrevh_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u64_m)))
+svuint64_t svrevh_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s32_m)))
+svint32_t svrevh_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s64_m)))
+svint64_t svrevh_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_x)))
+svuint32_t svrevh_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u64_x)))
+svuint64_t svrevh_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s32_x)))
+svint32_t svrevh_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s64_x)))
+svint64_t svrevh_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_z)))
+svuint32_t svrevh_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u64_z)))
+svuint64_t svrevh_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s32_z)))
+svint32_t svrevh_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s64_z)))
+svint64_t svrevh_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_m)))
+svuint64_t svrevw_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_s64_m)))
+svint64_t svrevw_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_x)))
+svuint64_t svrevw_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_s64_x)))
+svint64_t svrevw_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_z)))
+svuint64_t svrevw_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_s64_z)))
+svint64_t svrevw_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f64_m)))
+svfloat64_t svrinta_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_m)))
+svfloat32_t svrinta_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f16_m)))
+svfloat16_t svrinta_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f64_x)))
+svfloat64_t svrinta_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_x)))
+svfloat32_t svrinta_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f16_x)))
+svfloat16_t svrinta_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f64_z)))
+svfloat64_t svrinta_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_z)))
+svfloat32_t svrinta_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f16_z)))
+svfloat16_t svrinta_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f64_m)))
+svfloat64_t svrinti_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f32_m)))
+svfloat32_t svrinti_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f16_m)))
+svfloat16_t svrinti_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f64_x)))
+svfloat64_t svrinti_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f32_x)))
+svfloat32_t svrinti_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f16_x)))
+svfloat16_t svrinti_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f64_z)))
+svfloat64_t svrinti_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f32_z)))
+svfloat32_t svrinti_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f16_z)))
+svfloat16_t svrinti_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f64_m)))
+svfloat64_t svrintm_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_m)))
+svfloat32_t svrintm_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f16_m)))
+svfloat16_t svrintm_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f64_x)))
+svfloat64_t svrintm_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_x)))
+svfloat32_t svrintm_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f16_x)))
+svfloat16_t svrintm_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f64_z)))
+svfloat64_t svrintm_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_z)))
+svfloat32_t svrintm_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f16_z)))
+svfloat16_t svrintm_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f64_m)))
+svfloat64_t svrintn_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_m)))
+svfloat32_t svrintn_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f16_m)))
+svfloat16_t svrintn_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f64_x)))
+svfloat64_t svrintn_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_x)))
+svfloat32_t svrintn_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f16_x)))
+svfloat16_t svrintn_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f64_z)))
+svfloat64_t svrintn_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_z)))
+svfloat32_t svrintn_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f16_z)))
+svfloat16_t svrintn_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f64_m)))
+svfloat64_t svrintp_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_m)))
+svfloat32_t svrintp_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f16_m)))
+svfloat16_t svrintp_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f64_x)))
+svfloat64_t svrintp_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_x)))
+svfloat32_t svrintp_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f16_x)))
+svfloat16_t svrintp_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f64_z)))
+svfloat64_t svrintp_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_z)))
+svfloat32_t svrintp_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f16_z)))
+svfloat16_t svrintp_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f64_m)))
+svfloat64_t svrintx_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f32_m)))
+svfloat32_t svrintx_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f16_m)))
+svfloat16_t svrintx_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f64_x)))
+svfloat64_t svrintx_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f32_x)))
+svfloat32_t svrintx_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f16_x)))
+svfloat16_t svrintx_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f64_z)))
+svfloat64_t svrintx_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f32_z)))
+svfloat32_t svrintx_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f16_z)))
+svfloat16_t svrintx_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f64_m)))
+svfloat64_t svrintz_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f32_m)))
+svfloat32_t svrintz_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f16_m)))
+svfloat16_t svrintz_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f64_x)))
+svfloat64_t svrintz_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f32_x)))
+svfloat32_t svrintz_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f16_x)))
+svfloat16_t svrintz_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f64_z)))
+svfloat64_t svrintz_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f32_z)))
+svfloat32_t svrintz_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f16_z)))
+svfloat16_t svrintz_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_f64)))
+svfloat64_t svrsqrte_f64(svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_f32)))
+svfloat32_t svrsqrte_f32(svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_f16)))
+svfloat16_t svrsqrte_f16(svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrts_f64)))
+svfloat64_t svrsqrts_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrts_f32)))
+svfloat32_t svrsqrts_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrts_f16)))
+svfloat16_t svrsqrts_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f64_m)))
+svfloat64_t svscale_n_f64_m(svbool_t, svfloat64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f32_m)))
+svfloat32_t svscale_n_f32_m(svbool_t, svfloat32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f16_m)))
+svfloat16_t svscale_n_f16_m(svbool_t, svfloat16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f64_x)))
+svfloat64_t svscale_n_f64_x(svbool_t, svfloat64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f32_x)))
+svfloat32_t svscale_n_f32_x(svbool_t, svfloat32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f16_x)))
+svfloat16_t svscale_n_f16_x(svbool_t, svfloat16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f64_z)))
+svfloat64_t svscale_n_f64_z(svbool_t, svfloat64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f32_z)))
+svfloat32_t svscale_n_f32_z(svbool_t, svfloat32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f16_z)))
+svfloat16_t svscale_n_f16_z(svbool_t, svfloat16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f64_m)))
+svfloat64_t svscale_f64_m(svbool_t, svfloat64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f32_m)))
+svfloat32_t svscale_f32_m(svbool_t, svfloat32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f16_m)))
+svfloat16_t svscale_f16_m(svbool_t, svfloat16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f64_x)))
+svfloat64_t svscale_f64_x(svbool_t, svfloat64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f32_x)))
+svfloat32_t svscale_f32_x(svbool_t, svfloat32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f16_x)))
+svfloat16_t svscale_f16_x(svbool_t, svfloat16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f64_z)))
+svfloat64_t svscale_f64_z(svbool_t, svfloat64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f32_z)))
+svfloat32_t svscale_f32_z(svbool_t, svfloat32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f16_z)))
+svfloat16_t svscale_f16_z(svbool_t, svfloat16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_b)))
+svbool_t svsel_b(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8)))
+svuint8_t svsel_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u32)))
+svuint32_t svsel_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u64)))
+svuint64_t svsel_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u16)))
+svuint16_t svsel_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s8)))
+svint8_t svsel_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f64)))
+svfloat64_t svsel_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f32)))
+svfloat32_t svsel_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16)))
+svfloat16_t svsel_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s32)))
+svint32_t svsel_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s64)))
+svint64_t svsel_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s16)))
+svint16_t svsel_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u8)))
+svuint8x2_t svset2_u8(svuint8x2_t, uint64_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u32)))
+svuint32x2_t svset2_u32(svuint32x2_t, uint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u64)))
+svuint64x2_t svset2_u64(svuint64x2_t, uint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u16)))
+svuint16x2_t svset2_u16(svuint16x2_t, uint64_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s8)))
+svint8x2_t svset2_s8(svint8x2_t, uint64_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_f64)))
+svfloat64x2_t svset2_f64(svfloat64x2_t, uint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_f32)))
+svfloat32x2_t svset2_f32(svfloat32x2_t, uint64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_f16)))
+svfloat16x2_t svset2_f16(svfloat16x2_t, uint64_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s32)))
+svint32x2_t svset2_s32(svint32x2_t, uint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s64)))
+svint64x2_t svset2_s64(svint64x2_t, uint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s16)))
+svint16x2_t svset2_s16(svint16x2_t, uint64_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u8)))
+svuint8x3_t svset3_u8(svuint8x3_t, uint64_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u32)))
+svuint32x3_t svset3_u32(svuint32x3_t, uint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u64)))
+svuint64x3_t svset3_u64(svuint64x3_t, uint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u16)))
+svuint16x3_t svset3_u16(svuint16x3_t, uint64_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s8)))
+svint8x3_t svset3_s8(svint8x3_t, uint64_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_f64)))
+svfloat64x3_t svset3_f64(svfloat64x3_t, uint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_f32)))
+svfloat32x3_t svset3_f32(svfloat32x3_t, uint64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_f16)))
+svfloat16x3_t svset3_f16(svfloat16x3_t, uint64_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s32)))
+svint32x3_t svset3_s32(svint32x3_t, uint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s64)))
+svint64x3_t svset3_s64(svint64x3_t, uint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s16)))
+svint16x3_t svset3_s16(svint16x3_t, uint64_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u8)))
+svuint8x4_t svset4_u8(svuint8x4_t, uint64_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u32)))
+svuint32x4_t svset4_u32(svuint32x4_t, uint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u64)))
+svuint64x4_t svset4_u64(svuint64x4_t, uint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u16)))
+svuint16x4_t svset4_u16(svuint16x4_t, uint64_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s8)))
+svint8x4_t svset4_s8(svint8x4_t, uint64_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_f64)))
+svfloat64x4_t svset4_f64(svfloat64x4_t, uint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_f32)))
+svfloat32x4_t svset4_f32(svfloat32x4_t, uint64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_f16)))
+svfloat16x4_t svset4_f16(svfloat16x4_t, uint64_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s32)))
+svint32x4_t svset4_s32(svint32x4_t, uint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s64)))
+svint64x4_t svset4_s64(svint64x4_t, uint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s16)))
+svint16x4_t svset4_s16(svint16x4_t, uint64_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u8)))
+svuint8_t svsplice_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u32)))
+svuint32_t svsplice_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u64)))
+svuint64_t svsplice_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u16)))
+svuint16_t svsplice_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s8)))
+svint8_t svsplice_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_f64)))
+svfloat64_t svsplice_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_f32)))
+svfloat32_t svsplice_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_f16)))
+svfloat16_t svsplice_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s32)))
+svint32_t svsplice_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s64)))
+svint64_t svsplice_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s16)))
+svint16_t svsplice_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f64_m)))
+svfloat64_t svsqrt_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f32_m)))
+svfloat32_t svsqrt_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f16_m)))
+svfloat16_t svsqrt_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f64_x)))
+svfloat64_t svsqrt_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f32_x)))
+svfloat32_t svsqrt_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f16_x)))
+svfloat16_t svsqrt_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f64_z)))
+svfloat64_t svsqrt_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f32_z)))
+svfloat32_t svsqrt_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f16_z)))
+svfloat16_t svsqrt_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u8)))
+void svst1_u8(svbool_t, uint8_t *, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u32)))
+void svst1_u32(svbool_t, uint32_t *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u64)))
+void svst1_u64(svbool_t, uint64_t *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u16)))
+void svst1_u16(svbool_t, uint16_t *, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s8)))
+void svst1_s8(svbool_t, int8_t *, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f64)))
+void svst1_f64(svbool_t, float64_t *, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f32)))
+void svst1_f32(svbool_t, float32_t *, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f16)))
+void svst1_f16(svbool_t, float16_t *, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s32)))
+void svst1_s32(svbool_t, int32_t *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s64)))
+void svst1_s64(svbool_t, int64_t *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s16)))
+void svst1_s16(svbool_t, int16_t *, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u8)))
+void svst1_vnum_u8(svbool_t, uint8_t *, int64_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u32)))
+void svst1_vnum_u32(svbool_t, uint32_t *, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u64)))
+void svst1_vnum_u64(svbool_t, uint64_t *, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u16)))
+void svst1_vnum_u16(svbool_t, uint16_t *, int64_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s8)))
+void svst1_vnum_s8(svbool_t, int8_t *, int64_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f64)))
+void svst1_vnum_f64(svbool_t, float64_t *, int64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f32)))
+void svst1_vnum_f32(svbool_t, float32_t *, int64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f16)))
+void svst1_vnum_f16(svbool_t, float16_t *, int64_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s32)))
+void svst1_vnum_s32(svbool_t, int32_t *, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s64)))
+void svst1_vnum_s64(svbool_t, int64_t *, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s16)))
+void svst1_vnum_s16(svbool_t, int16_t *, int64_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_s32)))
+void svst1b_s32(svbool_t, int8_t *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_s64)))
+void svst1b_s64(svbool_t, int8_t *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_s16)))
+void svst1b_s16(svbool_t, int8_t *, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_u32)))
+void svst1b_u32(svbool_t, uint8_t *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_u64)))
+void svst1b_u64(svbool_t, uint8_t *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_u16)))
+void svst1b_u16(svbool_t, uint8_t *, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_s32)))
+void svst1b_vnum_s32(svbool_t, int8_t *, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_s64)))
+void svst1b_vnum_s64(svbool_t, int8_t *, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_s16)))
+void svst1b_vnum_s16(svbool_t, int8_t *, int64_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_u32)))
+void svst1b_vnum_u32(svbool_t, uint8_t *, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_u64)))
+void svst1b_vnum_u64(svbool_t, uint8_t *, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_u16)))
+void svst1b_vnum_u16(svbool_t, uint8_t *, int64_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_s32)))
+void svst1h_s32(svbool_t, int16_t *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_s64)))
+void svst1h_s64(svbool_t, int16_t *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_u32)))
+void svst1h_u32(svbool_t, uint16_t *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_u64)))
+void svst1h_u64(svbool_t, uint16_t *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_s32)))
+void svst1h_vnum_s32(svbool_t, int16_t *, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_s64)))
+void svst1h_vnum_s64(svbool_t, int16_t *, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_u32)))
+void svst1h_vnum_u32(svbool_t, uint16_t *, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_u64)))
+void svst1h_vnum_u64(svbool_t, uint16_t *, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_s64)))
+void svst1w_s64(svbool_t, int32_t *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_u64)))
+void svst1w_u64(svbool_t, uint32_t *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_vnum_s64)))
+void svst1w_vnum_s64(svbool_t, int32_t *, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_vnum_u64)))
+void svst1w_vnum_u64(svbool_t, uint32_t *, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u8)))
+void svst2_u8(svbool_t, uint8_t *, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u32)))
+void svst2_u32(svbool_t, uint32_t *, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u64)))
+void svst2_u64(svbool_t, uint64_t *, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u16)))
+void svst2_u16(svbool_t, uint16_t *, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s8)))
+void svst2_s8(svbool_t, int8_t *, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_f64)))
+void svst2_f64(svbool_t, float64_t *, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_f32)))
+void svst2_f32(svbool_t, float32_t *, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_f16)))
+void svst2_f16(svbool_t, float16_t *, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s32)))
+void svst2_s32(svbool_t, int32_t *, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s64)))
+void svst2_s64(svbool_t, int64_t *, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s16)))
+void svst2_s16(svbool_t, int16_t *, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u8)))
+void svst2_vnum_u8(svbool_t, uint8_t *, int64_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u32)))
+void svst2_vnum_u32(svbool_t, uint32_t *, int64_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u64)))
+void svst2_vnum_u64(svbool_t, uint64_t *, int64_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u16)))
+void svst2_vnum_u16(svbool_t, uint16_t *, int64_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s8)))
+void svst2_vnum_s8(svbool_t, int8_t *, int64_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_f64)))
+void svst2_vnum_f64(svbool_t, float64_t *, int64_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_f32)))
+void svst2_vnum_f32(svbool_t, float32_t *, int64_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_f16)))
+void svst2_vnum_f16(svbool_t, float16_t *, int64_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s32)))
+void svst2_vnum_s32(svbool_t, int32_t *, int64_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s64)))
+void svst2_vnum_s64(svbool_t, int64_t *, int64_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s16)))
+void svst2_vnum_s16(svbool_t, int16_t *, int64_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u8)))
+void svst3_u8(svbool_t, uint8_t *, svuint8x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u32)))
+void svst3_u32(svbool_t, uint32_t *, svuint32x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u64)))
+void svst3_u64(svbool_t, uint64_t *, svuint64x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u16)))
+void svst3_u16(svbool_t, uint16_t *, svuint16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s8)))
+void svst3_s8(svbool_t, int8_t *, svint8x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_f64)))
+void svst3_f64(svbool_t, float64_t *, svfloat64x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_f32)))
+void svst3_f32(svbool_t, float32_t *, svfloat32x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_f16)))
+void svst3_f16(svbool_t, float16_t *, svfloat16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s32)))
+void svst3_s32(svbool_t, int32_t *, svint32x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s64)))
+void svst3_s64(svbool_t, int64_t *, svint64x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s16)))
+void svst3_s16(svbool_t, int16_t *, svint16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u8)))
+void svst3_vnum_u8(svbool_t, uint8_t *, int64_t, svuint8x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u32)))
+void svst3_vnum_u32(svbool_t, uint32_t *, int64_t, svuint32x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u64)))
+void svst3_vnum_u64(svbool_t, uint64_t *, int64_t, svuint64x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u16)))
+void svst3_vnum_u16(svbool_t, uint16_t *, int64_t, svuint16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s8)))
+void svst3_vnum_s8(svbool_t, int8_t *, int64_t, svint8x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_f64)))
+void svst3_vnum_f64(svbool_t, float64_t *, int64_t, svfloat64x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_f32)))
+void svst3_vnum_f32(svbool_t, float32_t *, int64_t, svfloat32x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_f16)))
+void svst3_vnum_f16(svbool_t, float16_t *, int64_t, svfloat16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s32)))
+void svst3_vnum_s32(svbool_t, int32_t *, int64_t, svint32x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s64)))
+void svst3_vnum_s64(svbool_t, int64_t *, int64_t, svint64x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s16)))
+void svst3_vnum_s16(svbool_t, int16_t *, int64_t, svint16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u8)))
+void svst4_u8(svbool_t, uint8_t *, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u32)))
+void svst4_u32(svbool_t, uint32_t *, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u64)))
+void svst4_u64(svbool_t, uint64_t *, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u16)))
+void svst4_u16(svbool_t, uint16_t *, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s8)))
+void svst4_s8(svbool_t, int8_t *, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_f64)))
+void svst4_f64(svbool_t, float64_t *, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_f32)))
+void svst4_f32(svbool_t, float32_t *, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_f16)))
+void svst4_f16(svbool_t, float16_t *, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s32)))
+void svst4_s32(svbool_t, int32_t *, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s64)))
+void svst4_s64(svbool_t, int64_t *, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s16)))
+void svst4_s16(svbool_t, int16_t *, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u8)))
+void svst4_vnum_u8(svbool_t, uint8_t *, int64_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u32)))
+void svst4_vnum_u32(svbool_t, uint32_t *, int64_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u64)))
+void svst4_vnum_u64(svbool_t, uint64_t *, int64_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u16)))
+void svst4_vnum_u16(svbool_t, uint16_t *, int64_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s8)))
+void svst4_vnum_s8(svbool_t, int8_t *, int64_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_f64)))
+void svst4_vnum_f64(svbool_t, float64_t *, int64_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_f32)))
+void svst4_vnum_f32(svbool_t, float32_t *, int64_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_f16)))
+void svst4_vnum_f16(svbool_t, float16_t *, int64_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s32)))
+void svst4_vnum_s32(svbool_t, int32_t *, int64_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s64)))
+void svst4_vnum_s64(svbool_t, int64_t *, int64_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s16)))
+void svst4_vnum_s16(svbool_t, int16_t *, int64_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u8)))
+void svstnt1_u8(svbool_t, uint8_t *, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u32)))
+void svstnt1_u32(svbool_t, uint32_t *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u64)))
+void svstnt1_u64(svbool_t, uint64_t *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u16)))
+void svstnt1_u16(svbool_t, uint16_t *, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s8)))
+void svstnt1_s8(svbool_t, int8_t *, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f64)))
+void svstnt1_f64(svbool_t, float64_t *, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f32)))
+void svstnt1_f32(svbool_t, float32_t *, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f16)))
+void svstnt1_f16(svbool_t, float16_t *, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s32)))
+void svstnt1_s32(svbool_t, int32_t *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s64)))
+void svstnt1_s64(svbool_t, int64_t *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s16)))
+void svstnt1_s16(svbool_t, int16_t *, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u8)))
+void svstnt1_vnum_u8(svbool_t, uint8_t *, int64_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u32)))
+void svstnt1_vnum_u32(svbool_t, uint32_t *, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u64)))
+void svstnt1_vnum_u64(svbool_t, uint64_t *, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u16)))
+void svstnt1_vnum_u16(svbool_t, uint16_t *, int64_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s8)))
+void svstnt1_vnum_s8(svbool_t, int8_t *, int64_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f64)))
+void svstnt1_vnum_f64(svbool_t, float64_t *, int64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f32)))
+void svstnt1_vnum_f32(svbool_t, float32_t *, int64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f16)))
+void svstnt1_vnum_f16(svbool_t, float16_t *, int64_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s32)))
+void svstnt1_vnum_s32(svbool_t, int32_t *, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s64)))
+void svstnt1_vnum_s64(svbool_t, int64_t *, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s16)))
+void svstnt1_vnum_s16(svbool_t, int16_t *, int64_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f64_m)))
+svfloat64_t svsub_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f32_m)))
+svfloat32_t svsub_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f16_m)))
+svfloat16_t svsub_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f64_x)))
+svfloat64_t svsub_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f32_x)))
+svfloat32_t svsub_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f16_x)))
+svfloat16_t svsub_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f64_z)))
+svfloat64_t svsub_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f32_z)))
+svfloat32_t svsub_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f16_z)))
+svfloat16_t svsub_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u8_m)))
+svuint8_t svsub_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u32_m)))
+svuint32_t svsub_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u64_m)))
+svuint64_t svsub_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u16_m)))
+svuint16_t svsub_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s8_m)))
+svint8_t svsub_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s32_m)))
+svint32_t svsub_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s64_m)))
+svint64_t svsub_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s16_m)))
+svint16_t svsub_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u8_x)))
+svuint8_t svsub_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u32_x)))
+svuint32_t svsub_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u64_x)))
+svuint64_t svsub_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u16_x)))
+svuint16_t svsub_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s8_x)))
+svint8_t svsub_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s32_x)))
+svint32_t svsub_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s64_x)))
+svint64_t svsub_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s16_x)))
+svint16_t svsub_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u8_z)))
+svuint8_t svsub_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u32_z)))
+svuint32_t svsub_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u64_z)))
+svuint64_t svsub_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u16_z)))
+svuint16_t svsub_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s8_z)))
+svint8_t svsub_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s32_z)))
+svint32_t svsub_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s64_z)))
+svint64_t svsub_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s16_z)))
+svint16_t svsub_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f64_m)))
+svfloat64_t svsub_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f32_m)))
+svfloat32_t svsub_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f16_m)))
+svfloat16_t svsub_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f64_x)))
+svfloat64_t svsub_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f32_x)))
+svfloat32_t svsub_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f16_x)))
+svfloat16_t svsub_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f64_z)))
+svfloat64_t svsub_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f32_z)))
+svfloat32_t svsub_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f16_z)))
+svfloat16_t svsub_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u8_m)))
+svuint8_t svsub_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u32_m)))
+svuint32_t svsub_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u64_m)))
+svuint64_t svsub_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u16_m)))
+svuint16_t svsub_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s8_m)))
+svint8_t svsub_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s32_m)))
+svint32_t svsub_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s64_m)))
+svint64_t svsub_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s16_m)))
+svint16_t svsub_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u8_x)))
+svuint8_t svsub_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u32_x)))
+svuint32_t svsub_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u64_x)))
+svuint64_t svsub_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u16_x)))
+svuint16_t svsub_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s8_x)))
+svint8_t svsub_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s32_x)))
+svint32_t svsub_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s64_x)))
+svint64_t svsub_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s16_x)))
+svint16_t svsub_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u8_z)))
+svuint8_t svsub_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u32_z)))
+svuint32_t svsub_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u64_z)))
+svuint64_t svsub_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u16_z)))
+svuint16_t svsub_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s8_z)))
+svint8_t svsub_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s32_z)))
+svint32_t svsub_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s64_z)))
+svint64_t svsub_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s16_z)))
+svint16_t svsub_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f64_m)))
+svfloat64_t svsubr_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f32_m)))
+svfloat32_t svsubr_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f16_m)))
+svfloat16_t svsubr_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f64_x)))
+svfloat64_t svsubr_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f32_x)))
+svfloat32_t svsubr_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f16_x)))
+svfloat16_t svsubr_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f64_z)))
+svfloat64_t svsubr_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f32_z)))
+svfloat32_t svsubr_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f16_z)))
+svfloat16_t svsubr_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u8_m)))
+svuint8_t svsubr_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u32_m)))
+svuint32_t svsubr_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u64_m)))
+svuint64_t svsubr_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u16_m)))
+svuint16_t svsubr_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s8_m)))
+svint8_t svsubr_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s32_m)))
+svint32_t svsubr_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s64_m)))
+svint64_t svsubr_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s16_m)))
+svint16_t svsubr_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u8_x)))
+svuint8_t svsubr_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u32_x)))
+svuint32_t svsubr_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u64_x)))
+svuint64_t svsubr_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u16_x)))
+svuint16_t svsubr_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s8_x)))
+svint8_t svsubr_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s32_x)))
+svint32_t svsubr_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s64_x)))
+svint64_t svsubr_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s16_x)))
+svint16_t svsubr_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u8_z)))
+svuint8_t svsubr_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u32_z)))
+svuint32_t svsubr_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u64_z)))
+svuint64_t svsubr_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u16_z)))
+svuint16_t svsubr_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s8_z)))
+svint8_t svsubr_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s32_z)))
+svint32_t svsubr_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s64_z)))
+svint64_t svsubr_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s16_z)))
+svint16_t svsubr_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f64_m)))
+svfloat64_t svsubr_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f32_m)))
+svfloat32_t svsubr_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f16_m)))
+svfloat16_t svsubr_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f64_x)))
+svfloat64_t svsubr_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f32_x)))
+svfloat32_t svsubr_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f16_x)))
+svfloat16_t svsubr_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f64_z)))
+svfloat64_t svsubr_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f32_z)))
+svfloat32_t svsubr_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f16_z)))
+svfloat16_t svsubr_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u8_m)))
+svuint8_t svsubr_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u32_m)))
+svuint32_t svsubr_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u64_m)))
+svuint64_t svsubr_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u16_m)))
+svuint16_t svsubr_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s8_m)))
+svint8_t svsubr_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s32_m)))
+svint32_t svsubr_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s64_m)))
+svint64_t svsubr_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s16_m)))
+svint16_t svsubr_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u8_x)))
+svuint8_t svsubr_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u32_x)))
+svuint32_t svsubr_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u64_x)))
+svuint64_t svsubr_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u16_x)))
+svuint16_t svsubr_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s8_x)))
+svint8_t svsubr_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s32_x)))
+svint32_t svsubr_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s64_x)))
+svint64_t svsubr_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s16_x)))
+svint16_t svsubr_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u8_z)))
+svuint8_t svsubr_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u32_z)))
+svuint32_t svsubr_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u64_z)))
+svuint64_t svsubr_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u16_z)))
+svuint16_t svsubr_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s8_z)))
+svint8_t svsubr_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s32_z)))
+svint32_t svsubr_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s64_z)))
+svint64_t svsubr_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s16_z)))
+svint16_t svsubr_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u8)))
+svuint8_t svtbl_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u32)))
+svuint32_t svtbl_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u64)))
+svuint64_t svtbl_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u16)))
+svuint16_t svtbl_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s8)))
+svint8_t svtbl_s8(svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_f64)))
+svfloat64_t svtbl_f64(svfloat64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_f32)))
+svfloat32_t svtbl_f32(svfloat32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_f16)))
+svfloat16_t svtbl_f16(svfloat16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s32)))
+svint32_t svtbl_s32(svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s64)))
+svint64_t svtbl_s64(svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s16)))
+svint16_t svtbl_s16(svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u8)))
+svuint8_t svtrn1_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u32)))
+svuint32_t svtrn1_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u64)))
+svuint64_t svtrn1_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u16)))
+svuint16_t svtrn1_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s8)))
+svint8_t svtrn1_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_f64)))
+svfloat64_t svtrn1_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_f32)))
+svfloat32_t svtrn1_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_f16)))
+svfloat16_t svtrn1_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s32)))
+svint32_t svtrn1_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s64)))
+svint64_t svtrn1_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s16)))
+svint16_t svtrn1_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_b16)))
+svbool_t svtrn1_b16(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_b32)))
+svbool_t svtrn1_b32(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_b64)))
+svbool_t svtrn1_b64(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_b8)))
+svbool_t svtrn1_b8(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u8)))
+svuint8_t svtrn2_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u32)))
+svuint32_t svtrn2_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u64)))
+svuint64_t svtrn2_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u16)))
+svuint16_t svtrn2_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s8)))
+svint8_t svtrn2_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_f64)))
+svfloat64_t svtrn2_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_f32)))
+svfloat32_t svtrn2_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_f16)))
+svfloat16_t svtrn2_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s32)))
+svint32_t svtrn2_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s64)))
+svint64_t svtrn2_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s16)))
+svint16_t svtrn2_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_b16)))
+svbool_t svtrn2_b16(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_b32)))
+svbool_t svtrn2_b32(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_b64)))
+svbool_t svtrn2_b64(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_b8)))
+svbool_t svtrn2_b8(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_u8)))
+svuint8x2_t svundef2_u8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_u32)))
+svuint32x2_t svundef2_u32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_u64)))
+svuint64x2_t svundef2_u64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_u16)))
+svuint16x2_t svundef2_u16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_s8)))
+svint8x2_t svundef2_s8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_f64)))
+svfloat64x2_t svundef2_f64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_f32)))
+svfloat32x2_t svundef2_f32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_f16)))
+svfloat16x2_t svundef2_f16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_s32)))
+svint32x2_t svundef2_s32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_s64)))
+svint64x2_t svundef2_s64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_s16)))
+svint16x2_t svundef2_s16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_u8)))
+svuint8x3_t svundef3_u8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_u32)))
+svuint32x3_t svundef3_u32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_u64)))
+svuint64x3_t svundef3_u64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_u16)))
+svuint16x3_t svundef3_u16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_s8)))
+svint8x3_t svundef3_s8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_f64)))
+svfloat64x3_t svundef3_f64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_f32)))
+svfloat32x3_t svundef3_f32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_f16)))
+svfloat16x3_t svundef3_f16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_s32)))
+svint32x3_t svundef3_s32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_s64)))
+svint64x3_t svundef3_s64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_s16)))
+svint16x3_t svundef3_s16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_u8)))
+svuint8x4_t svundef4_u8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_u32)))
+svuint32x4_t svundef4_u32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_u64)))
+svuint64x4_t svundef4_u64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_u16)))
+svuint16x4_t svundef4_u16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_s8)))
+svint8x4_t svundef4_s8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_f64)))
+svfloat64x4_t svundef4_f64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_f32)))
+svfloat32x4_t svundef4_f32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_f16)))
+svfloat16x4_t svundef4_f16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_s32)))
+svint32x4_t svundef4_s32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_s64)))
+svint64x4_t svundef4_s64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_s16)))
+svint16x4_t svundef4_s16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_u8)))
+svuint8_t svundef_u8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_u32)))
+svuint32_t svundef_u32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_u64)))
+svuint64_t svundef_u64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_u16)))
+svuint16_t svundef_u16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_s8)))
+svint8_t svundef_s8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_f64)))
+svfloat64_t svundef_f64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_f32)))
+svfloat32_t svundef_f32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_f16)))
+svfloat16_t svundef_f16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_s32)))
+svint32_t svundef_s32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_s64)))
+svint64_t svundef_s64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_s16)))
+svint16_t svundef_s16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_b)))
+svbool_t svunpkhi_b(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_s32)))
+svint32_t svunpkhi_s32(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_s64)))
+svint64_t svunpkhi_s64(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_s16)))
+svint16_t svunpkhi_s16(svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_u32)))
+svuint32_t svunpkhi_u32(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_u64)))
+svuint64_t svunpkhi_u64(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_u16)))
+svuint16_t svunpkhi_u16(svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_b)))
+svbool_t svunpklo_b(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_s32)))
+svint32_t svunpklo_s32(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_s64)))
+svint64_t svunpklo_s64(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_s16)))
+svint16_t svunpklo_s16(svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_u32)))
+svuint32_t svunpklo_u32(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_u64)))
+svuint64_t svunpklo_u64(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_u16)))
+svuint16_t svunpklo_u16(svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u8)))
+svuint8_t svuzp1_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u32)))
+svuint32_t svuzp1_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u64)))
+svuint64_t svuzp1_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u16)))
+svuint16_t svuzp1_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s8)))
+svint8_t svuzp1_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_f64)))
+svfloat64_t svuzp1_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_f32)))
+svfloat32_t svuzp1_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_f16)))
+svfloat16_t svuzp1_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s32)))
+svint32_t svuzp1_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s64)))
+svint64_t svuzp1_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s16)))
+svint16_t svuzp1_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_b16)))
+svbool_t svuzp1_b16(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_b32)))
+svbool_t svuzp1_b32(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_b64)))
+svbool_t svuzp1_b64(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_b8)))
+svbool_t svuzp1_b8(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u8)))
+svuint8_t svuzp2_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u32)))
+svuint32_t svuzp2_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u64)))
+svuint64_t svuzp2_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u16)))
+svuint16_t svuzp2_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s8)))
+svint8_t svuzp2_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_f64)))
+svfloat64_t svuzp2_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_f32)))
+svfloat32_t svuzp2_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_f16)))
+svfloat16_t svuzp2_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s32)))
+svint32_t svuzp2_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s64)))
+svint64_t svuzp2_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s16)))
+svint16_t svuzp2_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_b16)))
+svbool_t svuzp2_b16(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_b32)))
+svbool_t svuzp2_b32(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_b64)))
+svbool_t svuzp2_b64(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_b8)))
+svbool_t svuzp2_b8(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_s32)))
+svbool_t svwhilele_b8_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_s32)))
+svbool_t svwhilele_b32_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_s32)))
+svbool_t svwhilele_b64_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_s32)))
+svbool_t svwhilele_b16_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_s64)))
+svbool_t svwhilele_b8_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_s64)))
+svbool_t svwhilele_b32_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_s64)))
+svbool_t svwhilele_b64_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_s64)))
+svbool_t svwhilele_b16_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_u32)))
+svbool_t svwhilele_b8_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_u32)))
+svbool_t svwhilele_b32_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_u32)))
+svbool_t svwhilele_b64_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_u32)))
+svbool_t svwhilele_b16_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_u64)))
+svbool_t svwhilele_b8_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_u64)))
+svbool_t svwhilele_b32_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_u64)))
+svbool_t svwhilele_b64_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_u64)))
+svbool_t svwhilele_b16_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_u32)))
+svbool_t svwhilelt_b8_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_u32)))
+svbool_t svwhilelt_b32_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_u32)))
+svbool_t svwhilelt_b64_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_u32)))
+svbool_t svwhilelt_b16_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_u64)))
+svbool_t svwhilelt_b8_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_u64)))
+svbool_t svwhilelt_b32_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_u64)))
+svbool_t svwhilelt_b64_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_u64)))
+svbool_t svwhilelt_b16_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_s32)))
+svbool_t svwhilelt_b8_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_s32)))
+svbool_t svwhilelt_b32_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_s32)))
+svbool_t svwhilelt_b64_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_s32)))
+svbool_t svwhilelt_b16_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_s64)))
+svbool_t svwhilelt_b8_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_s64)))
+svbool_t svwhilelt_b32_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_s64)))
+svbool_t svwhilelt_b64_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_s64)))
+svbool_t svwhilelt_b16_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u8)))
+svuint8_t svzip1_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u32)))
+svuint32_t svzip1_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u64)))
+svuint64_t svzip1_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u16)))
+svuint16_t svzip1_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s8)))
+svint8_t svzip1_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_f64)))
+svfloat64_t svzip1_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_f32)))
+svfloat32_t svzip1_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_f16)))
+svfloat16_t svzip1_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s32)))
+svint32_t svzip1_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s64)))
+svint64_t svzip1_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s16)))
+svint16_t svzip1_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_b16)))
+svbool_t svzip1_b16(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_b32)))
+svbool_t svzip1_b32(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_b64)))
+svbool_t svzip1_b64(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_b8)))
+svbool_t svzip1_b8(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u8)))
+svuint8_t svzip2_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u32)))
+svuint32_t svzip2_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u64)))
+svuint64_t svzip2_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u16)))
+svuint16_t svzip2_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s8)))
+svint8_t svzip2_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_f64)))
+svfloat64_t svzip2_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_f32)))
+svfloat32_t svzip2_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_f16)))
+svfloat16_t svzip2_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s32)))
+svint32_t svzip2_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s64)))
+svint64_t svzip2_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s16)))
+svint16_t svzip2_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_b16)))
+svbool_t svzip2_b16(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_b32)))
+svbool_t svzip2_b32(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_b64)))
+svbool_t svzip2_b64(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_b8)))
+svbool_t svzip2_b8(svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f64_m)))
+svfloat64_t svabd_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f32_m)))
+svfloat32_t svabd_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f16_m)))
+svfloat16_t svabd_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f64_x)))
+svfloat64_t svabd_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f32_x)))
+svfloat32_t svabd_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f16_x)))
+svfloat16_t svabd_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f64_z)))
+svfloat64_t svabd_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f32_z)))
+svfloat32_t svabd_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f16_z)))
+svfloat16_t svabd_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s8_m)))
+svint8_t svabd_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s32_m)))
+svint32_t svabd_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s64_m)))
+svint64_t svabd_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s16_m)))
+svint16_t svabd_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s8_x)))
+svint8_t svabd_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s32_x)))
+svint32_t svabd_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s64_x)))
+svint64_t svabd_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s16_x)))
+svint16_t svabd_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s8_z)))
+svint8_t svabd_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s32_z)))
+svint32_t svabd_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s64_z)))
+svint64_t svabd_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s16_z)))
+svint16_t svabd_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u8_m)))
+svuint8_t svabd_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u32_m)))
+svuint32_t svabd_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u64_m)))
+svuint64_t svabd_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u16_m)))
+svuint16_t svabd_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u8_x)))
+svuint8_t svabd_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u32_x)))
+svuint32_t svabd_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u64_x)))
+svuint64_t svabd_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u16_x)))
+svuint16_t svabd_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u8_z)))
+svuint8_t svabd_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u32_z)))
+svuint32_t svabd_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u64_z)))
+svuint64_t svabd_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u16_z)))
+svuint16_t svabd_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f64_m)))
+svfloat64_t svabd_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f32_m)))
+svfloat32_t svabd_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f16_m)))
+svfloat16_t svabd_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f64_x)))
+svfloat64_t svabd_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f32_x)))
+svfloat32_t svabd_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f16_x)))
+svfloat16_t svabd_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f64_z)))
+svfloat64_t svabd_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f32_z)))
+svfloat32_t svabd_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f16_z)))
+svfloat16_t svabd_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s8_m)))
+svint8_t svabd_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s32_m)))
+svint32_t svabd_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s64_m)))
+svint64_t svabd_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s16_m)))
+svint16_t svabd_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s8_x)))
+svint8_t svabd_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s32_x)))
+svint32_t svabd_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s64_x)))
+svint64_t svabd_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s16_x)))
+svint16_t svabd_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s8_z)))
+svint8_t svabd_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s32_z)))
+svint32_t svabd_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s64_z)))
+svint64_t svabd_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s16_z)))
+svint16_t svabd_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u8_m)))
+svuint8_t svabd_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u32_m)))
+svuint32_t svabd_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u64_m)))
+svuint64_t svabd_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u16_m)))
+svuint16_t svabd_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u8_x)))
+svuint8_t svabd_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u32_x)))
+svuint32_t svabd_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u64_x)))
+svuint64_t svabd_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u16_x)))
+svuint16_t svabd_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u8_z)))
+svuint8_t svabd_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u32_z)))
+svuint32_t svabd_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u64_z)))
+svuint64_t svabd_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u16_z)))
+svuint16_t svabd_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f64_m)))
+svfloat64_t svabs_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f32_m)))
+svfloat32_t svabs_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f16_m)))
+svfloat16_t svabs_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f64_x)))
+svfloat64_t svabs_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f32_x)))
+svfloat32_t svabs_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f16_x)))
+svfloat16_t svabs_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f64_z)))
+svfloat64_t svabs_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f32_z)))
+svfloat32_t svabs_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f16_z)))
+svfloat16_t svabs_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s8_m)))
+svint8_t svabs_m(svint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s32_m)))
+svint32_t svabs_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s64_m)))
+svint64_t svabs_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s16_m)))
+svint16_t svabs_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s8_x)))
+svint8_t svabs_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s32_x)))
+svint32_t svabs_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s64_x)))
+svint64_t svabs_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s16_x)))
+svint16_t svabs_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s8_z)))
+svint8_t svabs_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s32_z)))
+svint32_t svabs_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s64_z)))
+svint64_t svabs_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s16_z)))
+svint16_t svabs_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_n_f64)))
+svbool_t svacge(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_n_f32)))
+svbool_t svacge(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_n_f16)))
+svbool_t svacge(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_f64)))
+svbool_t svacge(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_f32)))
+svbool_t svacge(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_f16)))
+svbool_t svacge(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_n_f64)))
+svbool_t svacgt(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_n_f32)))
+svbool_t svacgt(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_n_f16)))
+svbool_t svacgt(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_f64)))
+svbool_t svacgt(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_f32)))
+svbool_t svacgt(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_f16)))
+svbool_t svacgt(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_n_f64)))
+svbool_t svacle(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_n_f32)))
+svbool_t svacle(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_n_f16)))
+svbool_t svacle(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_f64)))
+svbool_t svacle(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_f32)))
+svbool_t svacle(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_f16)))
+svbool_t svacle(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_n_f64)))
+svbool_t svaclt(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_n_f32)))
+svbool_t svaclt(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_n_f16)))
+svbool_t svaclt(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_f64)))
+svbool_t svaclt(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_f32)))
+svbool_t svaclt(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_f16)))
+svbool_t svaclt(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f64_m)))
+svfloat64_t svadd_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f32_m)))
+svfloat32_t svadd_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f16_m)))
+svfloat16_t svadd_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f64_x)))
+svfloat64_t svadd_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f32_x)))
+svfloat32_t svadd_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f16_x)))
+svfloat16_t svadd_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f64_z)))
+svfloat64_t svadd_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f32_z)))
+svfloat32_t svadd_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f16_z)))
+svfloat16_t svadd_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u8_m)))
+svuint8_t svadd_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u32_m)))
+svuint32_t svadd_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u64_m)))
+svuint64_t svadd_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u16_m)))
+svuint16_t svadd_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s8_m)))
+svint8_t svadd_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s32_m)))
+svint32_t svadd_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s64_m)))
+svint64_t svadd_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s16_m)))
+svint16_t svadd_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u8_x)))
+svuint8_t svadd_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u32_x)))
+svuint32_t svadd_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u64_x)))
+svuint64_t svadd_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u16_x)))
+svuint16_t svadd_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s8_x)))
+svint8_t svadd_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s32_x)))
+svint32_t svadd_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s64_x)))
+svint64_t svadd_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s16_x)))
+svint16_t svadd_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u8_z)))
+svuint8_t svadd_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u32_z)))
+svuint32_t svadd_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u64_z)))
+svuint64_t svadd_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u16_z)))
+svuint16_t svadd_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s8_z)))
+svint8_t svadd_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s32_z)))
+svint32_t svadd_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s64_z)))
+svint64_t svadd_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s16_z)))
+svint16_t svadd_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f64_m)))
+svfloat64_t svadd_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f32_m)))
+svfloat32_t svadd_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f16_m)))
+svfloat16_t svadd_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f64_x)))
+svfloat64_t svadd_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f32_x)))
+svfloat32_t svadd_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f16_x)))
+svfloat16_t svadd_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f64_z)))
+svfloat64_t svadd_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f32_z)))
+svfloat32_t svadd_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f16_z)))
+svfloat16_t svadd_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u8_m)))
+svuint8_t svadd_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u32_m)))
+svuint32_t svadd_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u64_m)))
+svuint64_t svadd_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u16_m)))
+svuint16_t svadd_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s8_m)))
+svint8_t svadd_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s32_m)))
+svint32_t svadd_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s64_m)))
+svint64_t svadd_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s16_m)))
+svint16_t svadd_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u8_x)))
+svuint8_t svadd_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u32_x)))
+svuint32_t svadd_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u64_x)))
+svuint64_t svadd_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u16_x)))
+svuint16_t svadd_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s8_x)))
+svint8_t svadd_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s32_x)))
+svint32_t svadd_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s64_x)))
+svint64_t svadd_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s16_x)))
+svint16_t svadd_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u8_z)))
+svuint8_t svadd_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u32_z)))
+svuint32_t svadd_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u64_z)))
+svuint64_t svadd_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u16_z)))
+svuint16_t svadd_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s8_z)))
+svint8_t svadd_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s32_z)))
+svint32_t svadd_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s64_z)))
+svint64_t svadd_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s16_z)))
+svint16_t svadd_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadda_f64)))
+float64_t svadda(svbool_t, float64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadda_f32)))
+float32_t svadda(svbool_t, float32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadda_f16)))
+float16_t svadda(svbool_t, float16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s8)))
+int64_t svaddv(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s32)))
+int64_t svaddv(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s64)))
+int64_t svaddv(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s16)))
+int64_t svaddv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u8)))
+uint64_t svaddv(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u32)))
+uint64_t svaddv(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u64)))
+uint64_t svaddv(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u16)))
+uint64_t svaddv(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_f64)))
+float64_t svaddv(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_f32)))
+float32_t svaddv(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_f16)))
+float16_t svaddv(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_b_z)))
+svbool_t svand_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u8_m)))
+svuint8_t svand_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u32_m)))
+svuint32_t svand_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u64_m)))
+svuint64_t svand_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u16_m)))
+svuint16_t svand_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s8_m)))
+svint8_t svand_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s32_m)))
+svint32_t svand_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s64_m)))
+svint64_t svand_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s16_m)))
+svint16_t svand_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u8_x)))
+svuint8_t svand_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u32_x)))
+svuint32_t svand_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u64_x)))
+svuint64_t svand_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u16_x)))
+svuint16_t svand_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s8_x)))
+svint8_t svand_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s32_x)))
+svint32_t svand_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s64_x)))
+svint64_t svand_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s16_x)))
+svint16_t svand_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u8_z)))
+svuint8_t svand_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u32_z)))
+svuint32_t svand_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u64_z)))
+svuint64_t svand_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u16_z)))
+svuint16_t svand_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s8_z)))
+svint8_t svand_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s32_z)))
+svint32_t svand_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s64_z)))
+svint64_t svand_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s16_z)))
+svint16_t svand_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u8_m)))
+svuint8_t svand_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u32_m)))
+svuint32_t svand_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u64_m)))
+svuint64_t svand_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u16_m)))
+svuint16_t svand_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s8_m)))
+svint8_t svand_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s32_m)))
+svint32_t svand_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s64_m)))
+svint64_t svand_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s16_m)))
+svint16_t svand_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u8_x)))
+svuint8_t svand_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u32_x)))
+svuint32_t svand_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u64_x)))
+svuint64_t svand_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u16_x)))
+svuint16_t svand_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s8_x)))
+svint8_t svand_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s32_x)))
+svint32_t svand_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s64_x)))
+svint64_t svand_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s16_x)))
+svint16_t svand_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u8_z)))
+svuint8_t svand_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u32_z)))
+svuint32_t svand_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u64_z)))
+svuint64_t svand_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u16_z)))
+svuint16_t svand_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s8_z)))
+svint8_t svand_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s32_z)))
+svint32_t svand_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s64_z)))
+svint64_t svand_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s16_z)))
+svint16_t svand_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u8)))
+uint8_t svandv(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u32)))
+uint32_t svandv(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u64)))
+uint64_t svandv(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u16)))
+uint16_t svandv(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s8)))
+int8_t svandv(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s32)))
+int32_t svandv(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s64)))
+int64_t svandv(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s16)))
+int16_t svandv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s8_m)))
+svint8_t svasr_m(svbool_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s32_m)))
+svint32_t svasr_m(svbool_t, svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s64_m)))
+svint64_t svasr_m(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s16_m)))
+svint16_t svasr_m(svbool_t, svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s8_x)))
+svint8_t svasr_x(svbool_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s32_x)))
+svint32_t svasr_x(svbool_t, svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s64_x)))
+svint64_t svasr_x(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s16_x)))
+svint16_t svasr_x(svbool_t, svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s8_z)))
+svint8_t svasr_z(svbool_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s32_z)))
+svint32_t svasr_z(svbool_t, svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s64_z)))
+svint64_t svasr_z(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s16_z)))
+svint16_t svasr_z(svbool_t, svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s8_m)))
+svint8_t svasr_m(svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s32_m)))
+svint32_t svasr_m(svbool_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s64_m)))
+svint64_t svasr_m(svbool_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s16_m)))
+svint16_t svasr_m(svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s8_x)))
+svint8_t svasr_x(svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s32_x)))
+svint32_t svasr_x(svbool_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s64_x)))
+svint64_t svasr_x(svbool_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s16_x)))
+svint16_t svasr_x(svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s8_z)))
+svint8_t svasr_z(svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s32_z)))
+svint32_t svasr_z(svbool_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s64_z)))
+svint64_t svasr_z(svbool_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s16_z)))
+svint16_t svasr_z(svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s8_m)))
+svint8_t svasr_wide_m(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s32_m)))
+svint32_t svasr_wide_m(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s16_m)))
+svint16_t svasr_wide_m(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s8_x)))
+svint8_t svasr_wide_x(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s32_x)))
+svint32_t svasr_wide_x(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s16_x)))
+svint16_t svasr_wide_x(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s8_z)))
+svint8_t svasr_wide_z(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s32_z)))
+svint32_t svasr_wide_z(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s16_z)))
+svint16_t svasr_wide_z(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s8_m)))
+svint8_t svasr_wide_m(svbool_t, svint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s32_m)))
+svint32_t svasr_wide_m(svbool_t, svint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s16_m)))
+svint16_t svasr_wide_m(svbool_t, svint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s8_x)))
+svint8_t svasr_wide_x(svbool_t, svint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s32_x)))
+svint32_t svasr_wide_x(svbool_t, svint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s16_x)))
+svint16_t svasr_wide_x(svbool_t, svint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s8_z)))
+svint8_t svasr_wide_z(svbool_t, svint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s32_z)))
+svint32_t svasr_wide_z(svbool_t, svint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s16_z)))
+svint16_t svasr_wide_z(svbool_t, svint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s8_m)))
+svint8_t svasrd_m(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s32_m)))
+svint32_t svasrd_m(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s64_m)))
+svint64_t svasrd_m(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s16_m)))
+svint16_t svasrd_m(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s8_x)))
+svint8_t svasrd_x(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s32_x)))
+svint32_t svasrd_x(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s64_x)))
+svint64_t svasrd_x(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s16_x)))
+svint16_t svasrd_x(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s8_z)))
+svint8_t svasrd_z(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s32_z)))
+svint32_t svasrd_z(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s64_z)))
+svint64_t svasrd_z(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s16_z)))
+svint16_t svasrd_z(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_b_z)))
+svbool_t svbic_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u8_m)))
+svuint8_t svbic_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u32_m)))
+svuint32_t svbic_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u64_m)))
+svuint64_t svbic_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u16_m)))
+svuint16_t svbic_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s8_m)))
+svint8_t svbic_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s32_m)))
+svint32_t svbic_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s64_m)))
+svint64_t svbic_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s16_m)))
+svint16_t svbic_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u8_x)))
+svuint8_t svbic_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u32_x)))
+svuint32_t svbic_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u64_x)))
+svuint64_t svbic_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u16_x)))
+svuint16_t svbic_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s8_x)))
+svint8_t svbic_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s32_x)))
+svint32_t svbic_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s64_x)))
+svint64_t svbic_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s16_x)))
+svint16_t svbic_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u8_z)))
+svuint8_t svbic_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u32_z)))
+svuint32_t svbic_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u64_z)))
+svuint64_t svbic_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u16_z)))
+svuint16_t svbic_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s8_z)))
+svint8_t svbic_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s32_z)))
+svint32_t svbic_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s64_z)))
+svint64_t svbic_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s16_z)))
+svint16_t svbic_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u8_m)))
+svuint8_t svbic_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u32_m)))
+svuint32_t svbic_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u64_m)))
+svuint64_t svbic_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u16_m)))
+svuint16_t svbic_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s8_m)))
+svint8_t svbic_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s32_m)))
+svint32_t svbic_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s64_m)))
+svint64_t svbic_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s16_m)))
+svint16_t svbic_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u8_x)))
+svuint8_t svbic_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u32_x)))
+svuint32_t svbic_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u64_x)))
+svuint64_t svbic_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u16_x)))
+svuint16_t svbic_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s8_x)))
+svint8_t svbic_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s32_x)))
+svint32_t svbic_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s64_x)))
+svint64_t svbic_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s16_x)))
+svint16_t svbic_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u8_z)))
+svuint8_t svbic_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u32_z)))
+svuint32_t svbic_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u64_z)))
+svuint64_t svbic_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u16_z)))
+svuint16_t svbic_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s8_z)))
+svint8_t svbic_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s32_z)))
+svint32_t svbic_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s64_z)))
+svint64_t svbic_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s16_z)))
+svint16_t svbic_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrka_b_m)))
+svbool_t svbrka_m(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrka_b_z)))
+svbool_t svbrka_z(svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkb_b_m)))
+svbool_t svbrkb_m(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkb_b_z)))
+svbool_t svbrkb_z(svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkn_b_z)))
+svbool_t svbrkn_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkpa_b_z)))
+svbool_t svbrkpa_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkpb_b_z)))
+svbool_t svbrkpb_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f64_m)))
+svfloat64_t svcadd_m(svbool_t, svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f32_m)))
+svfloat32_t svcadd_m(svbool_t, svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f16_m)))
+svfloat16_t svcadd_m(svbool_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f64_x)))
+svfloat64_t svcadd_x(svbool_t, svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f32_x)))
+svfloat32_t svcadd_x(svbool_t, svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f16_x)))
+svfloat16_t svcadd_x(svbool_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f64_z)))
+svfloat64_t svcadd_z(svbool_t, svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f32_z)))
+svfloat32_t svcadd_z(svbool_t, svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f16_z)))
+svfloat16_t svcadd_z(svbool_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u8)))
+uint8_t svclasta(svbool_t, uint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u32)))
+uint32_t svclasta(svbool_t, uint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u64)))
+uint64_t svclasta(svbool_t, uint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u16)))
+uint16_t svclasta(svbool_t, uint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s8)))
+int8_t svclasta(svbool_t, int8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_f64)))
+float64_t svclasta(svbool_t, float64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_f32)))
+float32_t svclasta(svbool_t, float32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_f16)))
+float16_t svclasta(svbool_t, float16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s32)))
+int32_t svclasta(svbool_t, int32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s64)))
+int64_t svclasta(svbool_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s16)))
+int16_t svclasta(svbool_t, int16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u8)))
+svuint8_t svclasta(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u32)))
+svuint32_t svclasta(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u64)))
+svuint64_t svclasta(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u16)))
+svuint16_t svclasta(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s8)))
+svint8_t svclasta(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_f64)))
+svfloat64_t svclasta(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_f32)))
+svfloat32_t svclasta(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_f16)))
+svfloat16_t svclasta(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s32)))
+svint32_t svclasta(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s64)))
+svint64_t svclasta(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s16)))
+svint16_t svclasta(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u8)))
+uint8_t svclastb(svbool_t, uint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u32)))
+uint32_t svclastb(svbool_t, uint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u64)))
+uint64_t svclastb(svbool_t, uint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u16)))
+uint16_t svclastb(svbool_t, uint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s8)))
+int8_t svclastb(svbool_t, int8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_f64)))
+float64_t svclastb(svbool_t, float64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_f32)))
+float32_t svclastb(svbool_t, float32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_f16)))
+float16_t svclastb(svbool_t, float16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s32)))
+int32_t svclastb(svbool_t, int32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s64)))
+int64_t svclastb(svbool_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s16)))
+int16_t svclastb(svbool_t, int16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u8)))
+svuint8_t svclastb(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u32)))
+svuint32_t svclastb(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u64)))
+svuint64_t svclastb(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u16)))
+svuint16_t svclastb(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s8)))
+svint8_t svclastb(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_f64)))
+svfloat64_t svclastb(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_f32)))
+svfloat32_t svclastb(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_f16)))
+svfloat16_t svclastb(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s32)))
+svint32_t svclastb(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s64)))
+svint64_t svclastb(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s16)))
+svint16_t svclastb(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s8_m)))
+svuint8_t svcls_m(svuint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s32_m)))
+svuint32_t svcls_m(svuint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s64_m)))
+svuint64_t svcls_m(svuint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s16_m)))
+svuint16_t svcls_m(svuint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s8_x)))
+svuint8_t svcls_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s32_x)))
+svuint32_t svcls_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s64_x)))
+svuint64_t svcls_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s16_x)))
+svuint16_t svcls_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s8_z)))
+svuint8_t svcls_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s32_z)))
+svuint32_t svcls_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s64_z)))
+svuint64_t svcls_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s16_z)))
+svuint16_t svcls_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u8_m)))
+svuint8_t svclz_m(svuint8_t, svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u32_m)))
+svuint32_t svclz_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u64_m)))
+svuint64_t svclz_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u16_m)))
+svuint16_t svclz_m(svuint16_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s8_m)))
+svuint8_t svclz_m(svuint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s32_m)))
+svuint32_t svclz_m(svuint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s64_m)))
+svuint64_t svclz_m(svuint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s16_m)))
+svuint16_t svclz_m(svuint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u8_x)))
+svuint8_t svclz_x(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u32_x)))
+svuint32_t svclz_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u64_x)))
+svuint64_t svclz_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u16_x)))
+svuint16_t svclz_x(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s8_x)))
+svuint8_t svclz_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s32_x)))
+svuint32_t svclz_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s64_x)))
+svuint64_t svclz_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s16_x)))
+svuint16_t svclz_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u8_z)))
+svuint8_t svclz_z(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u32_z)))
+svuint32_t svclz_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u64_z)))
+svuint64_t svclz_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u16_z)))
+svuint16_t svclz_z(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s8_z)))
+svuint8_t svclz_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s32_z)))
+svuint32_t svclz_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s64_z)))
+svuint64_t svclz_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s16_z)))
+svuint16_t svclz_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f64_m)))
+svfloat64_t svcmla_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f32_m)))
+svfloat32_t svcmla_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f16_m)))
+svfloat16_t svcmla_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f64_x)))
+svfloat64_t svcmla_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f32_x)))
+svfloat32_t svcmla_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f16_x)))
+svfloat16_t svcmla_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f64_z)))
+svfloat64_t svcmla_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f32_z)))
+svfloat32_t svcmla_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f16_z)))
+svfloat16_t svcmla_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_f32)))
+svfloat32_t svcmla_lane(svfloat32_t, svfloat32_t, svfloat32_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_f16)))
+svfloat16_t svcmla_lane(svfloat16_t, svfloat16_t, svfloat16_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_f64)))
+svbool_t svcmpeq(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_f32)))
+svbool_t svcmpeq(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_f16)))
+svbool_t svcmpeq(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u8)))
+svbool_t svcmpeq(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u32)))
+svbool_t svcmpeq(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u64)))
+svbool_t svcmpeq(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u16)))
+svbool_t svcmpeq(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s8)))
+svbool_t svcmpeq(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s32)))
+svbool_t svcmpeq(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s64)))
+svbool_t svcmpeq(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s16)))
+svbool_t svcmpeq(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u8)))
+svbool_t svcmpeq(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u32)))
+svbool_t svcmpeq(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u64)))
+svbool_t svcmpeq(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u16)))
+svbool_t svcmpeq(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s8)))
+svbool_t svcmpeq(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s32)))
+svbool_t svcmpeq(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s64)))
+svbool_t svcmpeq(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s16)))
+svbool_t svcmpeq(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_f64)))
+svbool_t svcmpeq(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_f32)))
+svbool_t svcmpeq(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_f16)))
+svbool_t svcmpeq(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_n_s8)))
+svbool_t svcmpeq_wide(svbool_t, svint8_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_n_s32)))
+svbool_t svcmpeq_wide(svbool_t, svint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_n_s16)))
+svbool_t svcmpeq_wide(svbool_t, svint16_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_s8)))
+svbool_t svcmpeq_wide(svbool_t, svint8_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_s32)))
+svbool_t svcmpeq_wide(svbool_t, svint32_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_s16)))
+svbool_t svcmpeq_wide(svbool_t, svint16_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_f64)))
+svbool_t svcmpge(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_f32)))
+svbool_t svcmpge(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_f16)))
+svbool_t svcmpge(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s8)))
+svbool_t svcmpge(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s32)))
+svbool_t svcmpge(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s64)))
+svbool_t svcmpge(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s16)))
+svbool_t svcmpge(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u8)))
+svbool_t svcmpge(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u32)))
+svbool_t svcmpge(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u64)))
+svbool_t svcmpge(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u16)))
+svbool_t svcmpge(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s8)))
+svbool_t svcmpge(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s32)))
+svbool_t svcmpge(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s64)))
+svbool_t svcmpge(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s16)))
+svbool_t svcmpge(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_f64)))
+svbool_t svcmpge(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_f32)))
+svbool_t svcmpge(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_f16)))
+svbool_t svcmpge(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u8)))
+svbool_t svcmpge(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u32)))
+svbool_t svcmpge(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u64)))
+svbool_t svcmpge(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u16)))
+svbool_t svcmpge(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_s8)))
+svbool_t svcmpge_wide(svbool_t, svint8_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_s32)))
+svbool_t svcmpge_wide(svbool_t, svint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_s16)))
+svbool_t svcmpge_wide(svbool_t, svint16_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_u8)))
+svbool_t svcmpge_wide(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_u32)))
+svbool_t svcmpge_wide(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_u16)))
+svbool_t svcmpge_wide(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_s8)))
+svbool_t svcmpge_wide(svbool_t, svint8_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_s32)))
+svbool_t svcmpge_wide(svbool_t, svint32_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_s16)))
+svbool_t svcmpge_wide(svbool_t, svint16_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_u8)))
+svbool_t svcmpge_wide(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_u32)))
+svbool_t svcmpge_wide(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_u16)))
+svbool_t svcmpge_wide(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_f64)))
+svbool_t svcmpgt(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_f32)))
+svbool_t svcmpgt(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_f16)))
+svbool_t svcmpgt(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s8)))
+svbool_t svcmpgt(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s32)))
+svbool_t svcmpgt(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s64)))
+svbool_t svcmpgt(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s16)))
+svbool_t svcmpgt(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u8)))
+svbool_t svcmpgt(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u32)))
+svbool_t svcmpgt(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u64)))
+svbool_t svcmpgt(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u16)))
+svbool_t svcmpgt(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s8)))
+svbool_t svcmpgt(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s32)))
+svbool_t svcmpgt(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s64)))
+svbool_t svcmpgt(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s16)))
+svbool_t svcmpgt(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_f64)))
+svbool_t svcmpgt(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_f32)))
+svbool_t svcmpgt(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_f16)))
+svbool_t svcmpgt(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u8)))
+svbool_t svcmpgt(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u32)))
+svbool_t svcmpgt(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u64)))
+svbool_t svcmpgt(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u16)))
+svbool_t svcmpgt(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_s8)))
+svbool_t svcmpgt_wide(svbool_t, svint8_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_s32)))
+svbool_t svcmpgt_wide(svbool_t, svint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_s16)))
+svbool_t svcmpgt_wide(svbool_t, svint16_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_u8)))
+svbool_t svcmpgt_wide(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_u32)))
+svbool_t svcmpgt_wide(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_u16)))
+svbool_t svcmpgt_wide(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_s8)))
+svbool_t svcmpgt_wide(svbool_t, svint8_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_s32)))
+svbool_t svcmpgt_wide(svbool_t, svint32_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_s16)))
+svbool_t svcmpgt_wide(svbool_t, svint16_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_u8)))
+svbool_t svcmpgt_wide(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_u32)))
+svbool_t svcmpgt_wide(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_u16)))
+svbool_t svcmpgt_wide(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_f64)))
+svbool_t svcmple(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_f32)))
+svbool_t svcmple(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_f16)))
+svbool_t svcmple(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s8)))
+svbool_t svcmple(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s32)))
+svbool_t svcmple(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s64)))
+svbool_t svcmple(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s16)))
+svbool_t svcmple(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u8)))
+svbool_t svcmple(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u32)))
+svbool_t svcmple(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u64)))
+svbool_t svcmple(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u16)))
+svbool_t svcmple(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s8)))
+svbool_t svcmple(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s32)))
+svbool_t svcmple(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s64)))
+svbool_t svcmple(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s16)))
+svbool_t svcmple(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_f64)))
+svbool_t svcmple(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_f32)))
+svbool_t svcmple(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_f16)))
+svbool_t svcmple(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u8)))
+svbool_t svcmple(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u32)))
+svbool_t svcmple(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u64)))
+svbool_t svcmple(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u16)))
+svbool_t svcmple(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_s8)))
+svbool_t svcmple_wide(svbool_t, svint8_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_s32)))
+svbool_t svcmple_wide(svbool_t, svint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_s16)))
+svbool_t svcmple_wide(svbool_t, svint16_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_u8)))
+svbool_t svcmple_wide(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_u32)))
+svbool_t svcmple_wide(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_u16)))
+svbool_t svcmple_wide(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_s8)))
+svbool_t svcmple_wide(svbool_t, svint8_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_s32)))
+svbool_t svcmple_wide(svbool_t, svint32_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_s16)))
+svbool_t svcmple_wide(svbool_t, svint16_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_u8)))
+svbool_t svcmple_wide(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_u32)))
+svbool_t svcmple_wide(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_u16)))
+svbool_t svcmple_wide(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u8)))
+svbool_t svcmplt(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u32)))
+svbool_t svcmplt(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u64)))
+svbool_t svcmplt(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u16)))
+svbool_t svcmplt(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_f64)))
+svbool_t svcmplt(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_f32)))
+svbool_t svcmplt(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_f16)))
+svbool_t svcmplt(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s8)))
+svbool_t svcmplt(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s32)))
+svbool_t svcmplt(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s64)))
+svbool_t svcmplt(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s16)))
+svbool_t svcmplt(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u8)))
+svbool_t svcmplt(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u32)))
+svbool_t svcmplt(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u64)))
+svbool_t svcmplt(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u16)))
+svbool_t svcmplt(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s8)))
+svbool_t svcmplt(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s32)))
+svbool_t svcmplt(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s64)))
+svbool_t svcmplt(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s16)))
+svbool_t svcmplt(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f64)))
+svbool_t svcmplt(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f32)))
+svbool_t svcmplt(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f16)))
+svbool_t svcmplt(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_u8)))
+svbool_t svcmplt_wide(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_u32)))
+svbool_t svcmplt_wide(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_u16)))
+svbool_t svcmplt_wide(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_s8)))
+svbool_t svcmplt_wide(svbool_t, svint8_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_s32)))
+svbool_t svcmplt_wide(svbool_t, svint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_s16)))
+svbool_t svcmplt_wide(svbool_t, svint16_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_u8)))
+svbool_t svcmplt_wide(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_u32)))
+svbool_t svcmplt_wide(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_u16)))
+svbool_t svcmplt_wide(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_s8)))
+svbool_t svcmplt_wide(svbool_t, svint8_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_s32)))
+svbool_t svcmplt_wide(svbool_t, svint32_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_s16)))
+svbool_t svcmplt_wide(svbool_t, svint16_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_f64)))
+svbool_t svcmpne(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_f32)))
+svbool_t svcmpne(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_f16)))
+svbool_t svcmpne(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u8)))
+svbool_t svcmpne(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u32)))
+svbool_t svcmpne(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u64)))
+svbool_t svcmpne(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u16)))
+svbool_t svcmpne(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s8)))
+svbool_t svcmpne(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s32)))
+svbool_t svcmpne(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s64)))
+svbool_t svcmpne(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s16)))
+svbool_t svcmpne(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u8)))
+svbool_t svcmpne(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u32)))
+svbool_t svcmpne(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u64)))
+svbool_t svcmpne(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u16)))
+svbool_t svcmpne(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s8)))
+svbool_t svcmpne(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s32)))
+svbool_t svcmpne(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s64)))
+svbool_t svcmpne(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s16)))
+svbool_t svcmpne(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_f64)))
+svbool_t svcmpne(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_f32)))
+svbool_t svcmpne(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_f16)))
+svbool_t svcmpne(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_n_s8)))
+svbool_t svcmpne_wide(svbool_t, svint8_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_n_s32)))
+svbool_t svcmpne_wide(svbool_t, svint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_n_s16)))
+svbool_t svcmpne_wide(svbool_t, svint16_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_s8)))
+svbool_t svcmpne_wide(svbool_t, svint8_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_s32)))
+svbool_t svcmpne_wide(svbool_t, svint32_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_s16)))
+svbool_t svcmpne_wide(svbool_t, svint16_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_n_f64)))
+svbool_t svcmpuo(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_n_f32)))
+svbool_t svcmpuo(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_n_f16)))
+svbool_t svcmpuo(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_f64)))
+svbool_t svcmpuo(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_f32)))
+svbool_t svcmpuo(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_f16)))
+svbool_t svcmpuo(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u8_m)))
+svuint8_t svcnot_m(svuint8_t, svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u32_m)))
+svuint32_t svcnot_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u64_m)))
+svuint64_t svcnot_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u16_m)))
+svuint16_t svcnot_m(svuint16_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s8_m)))
+svint8_t svcnot_m(svint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s32_m)))
+svint32_t svcnot_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s64_m)))
+svint64_t svcnot_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s16_m)))
+svint16_t svcnot_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u8_x)))
+svuint8_t svcnot_x(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u32_x)))
+svuint32_t svcnot_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u64_x)))
+svuint64_t svcnot_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u16_x)))
+svuint16_t svcnot_x(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s8_x)))
+svint8_t svcnot_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s32_x)))
+svint32_t svcnot_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s64_x)))
+svint64_t svcnot_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s16_x)))
+svint16_t svcnot_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u8_z)))
+svuint8_t svcnot_z(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u32_z)))
+svuint32_t svcnot_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u64_z)))
+svuint64_t svcnot_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u16_z)))
+svuint16_t svcnot_z(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s8_z)))
+svint8_t svcnot_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s32_z)))
+svint32_t svcnot_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s64_z)))
+svint64_t svcnot_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s16_z)))
+svint16_t svcnot_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u8_m)))
+svuint8_t svcnt_m(svuint8_t, svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u32_m)))
+svuint32_t svcnt_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u64_m)))
+svuint64_t svcnt_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u16_m)))
+svuint16_t svcnt_m(svuint16_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s8_m)))
+svuint8_t svcnt_m(svuint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f64_m)))
+svuint64_t svcnt_m(svuint64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f32_m)))
+svuint32_t svcnt_m(svuint32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f16_m)))
+svuint16_t svcnt_m(svuint16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s32_m)))
+svuint32_t svcnt_m(svuint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s64_m)))
+svuint64_t svcnt_m(svuint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s16_m)))
+svuint16_t svcnt_m(svuint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u8_x)))
+svuint8_t svcnt_x(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u32_x)))
+svuint32_t svcnt_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u64_x)))
+svuint64_t svcnt_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u16_x)))
+svuint16_t svcnt_x(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s8_x)))
+svuint8_t svcnt_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f64_x)))
+svuint64_t svcnt_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f32_x)))
+svuint32_t svcnt_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f16_x)))
+svuint16_t svcnt_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s32_x)))
+svuint32_t svcnt_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s64_x)))
+svuint64_t svcnt_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s16_x)))
+svuint16_t svcnt_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u8_z)))
+svuint8_t svcnt_z(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u32_z)))
+svuint32_t svcnt_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u64_z)))
+svuint64_t svcnt_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u16_z)))
+svuint16_t svcnt_z(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s8_z)))
+svuint8_t svcnt_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f64_z)))
+svuint64_t svcnt_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f32_z)))
+svuint32_t svcnt_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f16_z)))
+svuint16_t svcnt_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s32_z)))
+svuint32_t svcnt_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s64_z)))
+svuint64_t svcnt_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s16_z)))
+svuint16_t svcnt_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u8)))
+svuint8x2_t svcreate2(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u32)))
+svuint32x2_t svcreate2(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u64)))
+svuint64x2_t svcreate2(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u16)))
+svuint16x2_t svcreate2(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s8)))
+svint8x2_t svcreate2(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_f64)))
+svfloat64x2_t svcreate2(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_f32)))
+svfloat32x2_t svcreate2(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_f16)))
+svfloat16x2_t svcreate2(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s32)))
+svint32x2_t svcreate2(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s64)))
+svint64x2_t svcreate2(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s16)))
+svint16x2_t svcreate2(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u8)))
+svuint8x3_t svcreate3(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u32)))
+svuint32x3_t svcreate3(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u64)))
+svuint64x3_t svcreate3(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u16)))
+svuint16x3_t svcreate3(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s8)))
+svint8x3_t svcreate3(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_f64)))
+svfloat64x3_t svcreate3(svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_f32)))
+svfloat32x3_t svcreate3(svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_f16)))
+svfloat16x3_t svcreate3(svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s32)))
+svint32x3_t svcreate3(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s64)))
+svint64x3_t svcreate3(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s16)))
+svint16x3_t svcreate3(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u8)))
+svuint8x4_t svcreate4(svuint8_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u32)))
+svuint32x4_t svcreate4(svuint32_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u64)))
+svuint64x4_t svcreate4(svuint64_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u16)))
+svuint16x4_t svcreate4(svuint16_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s8)))
+svint8x4_t svcreate4(svint8_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_f64)))
+svfloat64x4_t svcreate4(svfloat64_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_f32)))
+svfloat32x4_t svcreate4(svfloat32_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_f16)))
+svfloat16x4_t svcreate4(svfloat16_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s32)))
+svint32x4_t svcreate4(svint32_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s64)))
+svint64x4_t svcreate4(svint64_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s16)))
+svint16x4_t svcreate4(svint16_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_m)))
+svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_x)))
+svfloat16_t svcvt_f16_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_z)))
+svfloat16_t svcvt_f16_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f64_m)))
+svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f64_x)))
+svfloat16_t svcvt_f16_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f64_z)))
+svfloat16_t svcvt_f16_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s16_m)))
+svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s16_x)))
+svfloat16_t svcvt_f16_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s16_z)))
+svfloat16_t svcvt_f16_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s32_m)))
+svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s32_x)))
+svfloat16_t svcvt_f16_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s32_z)))
+svfloat16_t svcvt_f16_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s64_m)))
+svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s64_x)))
+svfloat16_t svcvt_f16_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s64_z)))
+svfloat16_t svcvt_f16_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u16_m)))
+svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u16_x)))
+svfloat16_t svcvt_f16_x(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u16_z)))
+svfloat16_t svcvt_f16_z(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u32_m)))
+svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u32_x)))
+svfloat16_t svcvt_f16_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u32_z)))
+svfloat16_t svcvt_f16_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u64_m)))
+svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u64_x)))
+svfloat16_t svcvt_f16_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u64_z)))
+svfloat16_t svcvt_f16_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_m)))
+svfloat32_t svcvt_f32_m(svfloat32_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_x)))
+svfloat32_t svcvt_f32_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_z)))
+svfloat32_t svcvt_f32_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f64_m)))
+svfloat32_t svcvt_f32_m(svfloat32_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f64_x)))
+svfloat32_t svcvt_f32_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f64_z)))
+svfloat32_t svcvt_f32_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_m)))
+svfloat32_t svcvt_f32_m(svfloat32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_x)))
+svfloat32_t svcvt_f32_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_z)))
+svfloat32_t svcvt_f32_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s64_m)))
+svfloat32_t svcvt_f32_m(svfloat32_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s64_x)))
+svfloat32_t svcvt_f32_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s64_z)))
+svfloat32_t svcvt_f32_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_m)))
+svfloat32_t svcvt_f32_m(svfloat32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_x)))
+svfloat32_t svcvt_f32_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_z)))
+svfloat32_t svcvt_f32_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u64_m)))
+svfloat32_t svcvt_f32_m(svfloat32_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u64_x)))
+svfloat32_t svcvt_f32_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u64_z)))
+svfloat32_t svcvt_f32_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f16_m)))
+svfloat64_t svcvt_f64_m(svfloat64_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f16_x)))
+svfloat64_t svcvt_f64_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f16_z)))
+svfloat64_t svcvt_f64_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f32_m)))
+svfloat64_t svcvt_f64_m(svfloat64_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f32_x)))
+svfloat64_t svcvt_f64_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f32_z)))
+svfloat64_t svcvt_f64_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s32_m)))
+svfloat64_t svcvt_f64_m(svfloat64_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s32_x)))
+svfloat64_t svcvt_f64_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s32_z)))
+svfloat64_t svcvt_f64_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s64_m)))
+svfloat64_t svcvt_f64_m(svfloat64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s64_x)))
+svfloat64_t svcvt_f64_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s64_z)))
+svfloat64_t svcvt_f64_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u32_m)))
+svfloat64_t svcvt_f64_m(svfloat64_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u32_x)))
+svfloat64_t svcvt_f64_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u32_z)))
+svfloat64_t svcvt_f64_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u64_m)))
+svfloat64_t svcvt_f64_m(svfloat64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u64_x)))
+svfloat64_t svcvt_f64_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u64_z)))
+svfloat64_t svcvt_f64_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s16_f16_m)))
+svint16_t svcvt_s16_m(svint16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s16_f16_x)))
+svint16_t svcvt_s16_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s16_f16_z)))
+svint16_t svcvt_s16_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f16_m)))
+svint32_t svcvt_s32_m(svint32_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f16_x)))
+svint32_t svcvt_s32_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f16_z)))
+svint32_t svcvt_s32_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_m)))
+svint32_t svcvt_s32_m(svint32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_x)))
+svint32_t svcvt_s32_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_z)))
+svint32_t svcvt_s32_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f64_m)))
+svint32_t svcvt_s32_m(svint32_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f64_x)))
+svint32_t svcvt_s32_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f64_z)))
+svint32_t svcvt_s32_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f16_m)))
+svint64_t svcvt_s64_m(svint64_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f16_x)))
+svint64_t svcvt_s64_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f16_z)))
+svint64_t svcvt_s64_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f32_m)))
+svint64_t svcvt_s64_m(svint64_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f32_x)))
+svint64_t svcvt_s64_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f32_z)))
+svint64_t svcvt_s64_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f64_m)))
+svint64_t svcvt_s64_m(svint64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f64_x)))
+svint64_t svcvt_s64_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f64_z)))
+svint64_t svcvt_s64_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u16_f16_m)))
+svuint16_t svcvt_u16_m(svuint16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u16_f16_x)))
+svuint16_t svcvt_u16_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u16_f16_z)))
+svuint16_t svcvt_u16_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f16_m)))
+svuint32_t svcvt_u32_m(svuint32_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f16_x)))
+svuint32_t svcvt_u32_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f16_z)))
+svuint32_t svcvt_u32_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_m)))
+svuint32_t svcvt_u32_m(svuint32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_x)))
+svuint32_t svcvt_u32_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_z)))
+svuint32_t svcvt_u32_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f64_m)))
+svuint32_t svcvt_u32_m(svuint32_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f64_x)))
+svuint32_t svcvt_u32_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f64_z)))
+svuint32_t svcvt_u32_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f16_m)))
+svuint64_t svcvt_u64_m(svuint64_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f16_x)))
+svuint64_t svcvt_u64_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f16_z)))
+svuint64_t svcvt_u64_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f32_m)))
+svuint64_t svcvt_u64_m(svuint64_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f32_x)))
+svuint64_t svcvt_u64_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f32_z)))
+svuint64_t svcvt_u64_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f64_m)))
+svuint64_t svcvt_u64_m(svuint64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f64_x)))
+svuint64_t svcvt_u64_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f64_z)))
+svuint64_t svcvt_u64_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f64_m)))
+svfloat64_t svdiv_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f32_m)))
+svfloat32_t svdiv_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f16_m)))
+svfloat16_t svdiv_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f64_x)))
+svfloat64_t svdiv_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f32_x)))
+svfloat32_t svdiv_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f16_x)))
+svfloat16_t svdiv_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f64_z)))
+svfloat64_t svdiv_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f32_z)))
+svfloat32_t svdiv_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f16_z)))
+svfloat16_t svdiv_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s32_m)))
+svint32_t svdiv_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s64_m)))
+svint64_t svdiv_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s32_x)))
+svint32_t svdiv_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s64_x)))
+svint64_t svdiv_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s32_z)))
+svint32_t svdiv_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s64_z)))
+svint64_t svdiv_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u32_m)))
+svuint32_t svdiv_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u64_m)))
+svuint64_t svdiv_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u32_x)))
+svuint32_t svdiv_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u64_x)))
+svuint64_t svdiv_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u32_z)))
+svuint32_t svdiv_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u64_z)))
+svuint64_t svdiv_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f64_m)))
+svfloat64_t svdiv_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f32_m)))
+svfloat32_t svdiv_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f16_m)))
+svfloat16_t svdiv_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f64_x)))
+svfloat64_t svdiv_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f32_x)))
+svfloat32_t svdiv_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f16_x)))
+svfloat16_t svdiv_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f64_z)))
+svfloat64_t svdiv_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f32_z)))
+svfloat32_t svdiv_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f16_z)))
+svfloat16_t svdiv_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s32_m)))
+svint32_t svdiv_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s64_m)))
+svint64_t svdiv_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s32_x)))
+svint32_t svdiv_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s64_x)))
+svint64_t svdiv_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s32_z)))
+svint32_t svdiv_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s64_z)))
+svint64_t svdiv_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u32_m)))
+svuint32_t svdiv_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u64_m)))
+svuint64_t svdiv_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u32_x)))
+svuint32_t svdiv_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u64_x)))
+svuint64_t svdiv_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u32_z)))
+svuint32_t svdiv_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u64_z)))
+svuint64_t svdiv_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f64_m)))
+svfloat64_t svdivr_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f32_m)))
+svfloat32_t svdivr_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f16_m)))
+svfloat16_t svdivr_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f64_x)))
+svfloat64_t svdivr_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f32_x)))
+svfloat32_t svdivr_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f16_x)))
+svfloat16_t svdivr_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f64_z)))
+svfloat64_t svdivr_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f32_z)))
+svfloat32_t svdivr_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f16_z)))
+svfloat16_t svdivr_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s32_m)))
+svint32_t svdivr_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s64_m)))
+svint64_t svdivr_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s32_x)))
+svint32_t svdivr_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s64_x)))
+svint64_t svdivr_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s32_z)))
+svint32_t svdivr_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s64_z)))
+svint64_t svdivr_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u32_m)))
+svuint32_t svdivr_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u64_m)))
+svuint64_t svdivr_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u32_x)))
+svuint32_t svdivr_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u64_x)))
+svuint64_t svdivr_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u32_z)))
+svuint32_t svdivr_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u64_z)))
+svuint64_t svdivr_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f64_m)))
+svfloat64_t svdivr_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f32_m)))
+svfloat32_t svdivr_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f16_m)))
+svfloat16_t svdivr_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f64_x)))
+svfloat64_t svdivr_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f32_x)))
+svfloat32_t svdivr_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f16_x)))
+svfloat16_t svdivr_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f64_z)))
+svfloat64_t svdivr_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f32_z)))
+svfloat32_t svdivr_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f16_z)))
+svfloat16_t svdivr_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s32_m)))
+svint32_t svdivr_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s64_m)))
+svint64_t svdivr_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s32_x)))
+svint32_t svdivr_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s64_x)))
+svint64_t svdivr_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s32_z)))
+svint32_t svdivr_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s64_z)))
+svint64_t svdivr_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u32_m)))
+svuint32_t svdivr_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u64_m)))
+svuint64_t svdivr_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u32_x)))
+svuint32_t svdivr_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u64_x)))
+svuint64_t svdivr_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u32_z)))
+svuint32_t svdivr_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u64_z)))
+svuint64_t svdivr_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_s32)))
+svint32_t svdot(svint32_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_s64)))
+svint64_t svdot(svint64_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_u32)))
+svuint32_t svdot(svuint32_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_u64)))
+svuint64_t svdot(svuint64_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_s32)))
+svint32_t svdot(svint32_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_s64)))
+svint64_t svdot(svint64_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_u32)))
+svuint32_t svdot(svuint32_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_u64)))
+svuint64_t svdot(svuint64_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_s32)))
+svint32_t svdot_lane(svint32_t, svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_s64)))
+svint64_t svdot_lane(svint64_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_u32)))
+svuint32_t svdot_lane(svuint32_t, svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_u64)))
+svuint64_t svdot_lane(svuint64_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8)))
+svuint8_t svdup_u8(uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32)))
+svuint32_t svdup_u32(uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64)))
+svuint64_t svdup_u64(uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16)))
+svuint16_t svdup_u16(uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8)))
+svint8_t svdup_s8(int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64)))
+svfloat64_t svdup_f64(float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32)))
+svfloat32_t svdup_f32(float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16)))
+svfloat16_t svdup_f16(float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32)))
+svint32_t svdup_s32(int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64)))
+svint64_t svdup_s64(int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16)))
+svint16_t svdup_s16(int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8_m)))
+svuint8_t svdup_u8_m(svuint8_t, svbool_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32_m)))
+svuint32_t svdup_u32_m(svuint32_t, svbool_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64_m)))
+svuint64_t svdup_u64_m(svuint64_t, svbool_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16_m)))
+svuint16_t svdup_u16_m(svuint16_t, svbool_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8_m)))
+svint8_t svdup_s8_m(svint8_t, svbool_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64_m)))
+svfloat64_t svdup_f64_m(svfloat64_t, svbool_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32_m)))
+svfloat32_t svdup_f32_m(svfloat32_t, svbool_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16_m)))
+svfloat16_t svdup_f16_m(svfloat16_t, svbool_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32_m)))
+svint32_t svdup_s32_m(svint32_t, svbool_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64_m)))
+svint64_t svdup_s64_m(svint64_t, svbool_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16_m)))
+svint16_t svdup_s16_m(svint16_t, svbool_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b8)))
+svbool_t svdup_b8(bool);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b32)))
+svbool_t svdup_b32(bool);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b64)))
+svbool_t svdup_b64(bool);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b16)))
+svbool_t svdup_b16(bool);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8_x)))
+svuint8_t svdup_u8_x(svbool_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32_x)))
+svuint32_t svdup_u32_x(svbool_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64_x)))
+svuint64_t svdup_u64_x(svbool_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16_x)))
+svuint16_t svdup_u16_x(svbool_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8_x)))
+svint8_t svdup_s8_x(svbool_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64_x)))
+svfloat64_t svdup_f64_x(svbool_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32_x)))
+svfloat32_t svdup_f32_x(svbool_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16_x)))
+svfloat16_t svdup_f16_x(svbool_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32_x)))
+svint32_t svdup_s32_x(svbool_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64_x)))
+svint64_t svdup_s64_x(svbool_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16_x)))
+svint16_t svdup_s16_x(svbool_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8_z)))
+svuint8_t svdup_u8_z(svbool_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32_z)))
+svuint32_t svdup_u32_z(svbool_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64_z)))
+svuint64_t svdup_u64_z(svbool_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16_z)))
+svuint16_t svdup_u16_z(svbool_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8_z)))
+svint8_t svdup_s8_z(svbool_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64_z)))
+svfloat64_t svdup_f64_z(svbool_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32_z)))
+svfloat32_t svdup_f32_z(svbool_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16_z)))
+svfloat16_t svdup_f16_z(svbool_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32_z)))
+svint32_t svdup_s32_z(svbool_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64_z)))
+svint64_t svdup_s64_z(svbool_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16_z)))
+svint16_t svdup_s16_z(svbool_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u8)))
+svuint8_t svdup_lane(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u32)))
+svuint32_t svdup_lane(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u64)))
+svuint64_t svdup_lane(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u16)))
+svuint16_t svdup_lane(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s8)))
+svint8_t svdup_lane(svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_f64)))
+svfloat64_t svdup_lane(svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_f32)))
+svfloat32_t svdup_lane(svfloat32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_f16)))
+svfloat16_t svdup_lane(svfloat16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s32)))
+svint32_t svdup_lane(svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s64)))
+svint64_t svdup_lane(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s16)))
+svint16_t svdup_lane(svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u8)))
+svuint8_t svdupq_u8(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s8)))
+svint8_t svdupq_s8(int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u16)))
+svuint16_t svdupq_u16(uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_f16)))
+svfloat16_t svdupq_f16(float16_t, float16_t, float16_t, float16_t, float16_t, float16_t, float16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s16)))
+svint16_t svdupq_s16(int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u32)))
+svuint32_t svdupq_u32(uint32_t, uint32_t, uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_f32)))
+svfloat32_t svdupq_f32(float32_t, float32_t, float32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s32)))
+svint32_t svdupq_s32(int32_t, int32_t, int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u64)))
+svuint64_t svdupq_u64(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_f64)))
+svfloat64_t svdupq_f64(float64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s64)))
+svint64_t svdupq_s64(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b8)))
+svbool_t svdupq_b8(bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b16)))
+svbool_t svdupq_b16(bool, bool, bool, bool, bool, bool, bool, bool);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b32)))
+svbool_t svdupq_b32(bool, bool, bool, bool);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b64)))
+svbool_t svdupq_b64(bool, bool);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u8)))
+svuint8_t svdupq_lane(svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u32)))
+svuint32_t svdupq_lane(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u64)))
+svuint64_t svdupq_lane(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u16)))
+svuint16_t svdupq_lane(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s8)))
+svint8_t svdupq_lane(svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_f64)))
+svfloat64_t svdupq_lane(svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_f32)))
+svfloat32_t svdupq_lane(svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_f16)))
+svfloat16_t svdupq_lane(svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s32)))
+svint32_t svdupq_lane(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s64)))
+svint64_t svdupq_lane(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s16)))
+svint16_t svdupq_lane(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_b_z)))
+svbool_t sveor_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u8_m)))
+svuint8_t sveor_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u32_m)))
+svuint32_t sveor_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u64_m)))
+svuint64_t sveor_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u16_m)))
+svuint16_t sveor_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s8_m)))
+svint8_t sveor_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s32_m)))
+svint32_t sveor_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s64_m)))
+svint64_t sveor_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s16_m)))
+svint16_t sveor_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u8_x)))
+svuint8_t sveor_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u32_x)))
+svuint32_t sveor_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u64_x)))
+svuint64_t sveor_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u16_x)))
+svuint16_t sveor_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s8_x)))
+svint8_t sveor_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s32_x)))
+svint32_t sveor_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s64_x)))
+svint64_t sveor_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s16_x)))
+svint16_t sveor_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u8_z)))
+svuint8_t sveor_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u32_z)))
+svuint32_t sveor_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u64_z)))
+svuint64_t sveor_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u16_z)))
+svuint16_t sveor_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s8_z)))
+svint8_t sveor_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s32_z)))
+svint32_t sveor_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s64_z)))
+svint64_t sveor_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s16_z)))
+svint16_t sveor_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u8_m)))
+svuint8_t sveor_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u32_m)))
+svuint32_t sveor_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u64_m)))
+svuint64_t sveor_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u16_m)))
+svuint16_t sveor_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s8_m)))
+svint8_t sveor_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s32_m)))
+svint32_t sveor_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s64_m)))
+svint64_t sveor_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s16_m)))
+svint16_t sveor_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u8_x)))
+svuint8_t sveor_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u32_x)))
+svuint32_t sveor_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u64_x)))
+svuint64_t sveor_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u16_x)))
+svuint16_t sveor_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s8_x)))
+svint8_t sveor_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s32_x)))
+svint32_t sveor_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s64_x)))
+svint64_t sveor_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s16_x)))
+svint16_t sveor_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u8_z)))
+svuint8_t sveor_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u32_z)))
+svuint32_t sveor_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u64_z)))
+svuint64_t sveor_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u16_z)))
+svuint16_t sveor_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s8_z)))
+svint8_t sveor_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s32_z)))
+svint32_t sveor_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s64_z)))
+svint64_t sveor_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s16_z)))
+svint16_t sveor_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u8)))
+uint8_t sveorv(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u32)))
+uint32_t sveorv(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u64)))
+uint64_t sveorv(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u16)))
+uint16_t sveorv(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s8)))
+int8_t sveorv(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s32)))
+int32_t sveorv(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s64)))
+int64_t sveorv(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s16)))
+int16_t sveorv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u8)))
+svuint8_t svext(svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u32)))
+svuint32_t svext(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u64)))
+svuint64_t svext(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u16)))
+svuint16_t svext(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s8)))
+svint8_t svext(svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_f64)))
+svfloat64_t svext(svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_f32)))
+svfloat32_t svext(svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_f16)))
+svfloat16_t svext(svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s32)))
+svint32_t svext(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s64)))
+svint64_t svext(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s16)))
+svint16_t svext(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s32_m)))
+svint32_t svextb_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s64_m)))
+svint64_t svextb_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s16_m)))
+svint16_t svextb_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s32_x)))
+svint32_t svextb_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s64_x)))
+svint64_t svextb_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s16_x)))
+svint16_t svextb_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s32_z)))
+svint32_t svextb_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s64_z)))
+svint64_t svextb_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s16_z)))
+svint16_t svextb_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u32_m)))
+svuint32_t svextb_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u64_m)))
+svuint64_t svextb_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u16_m)))
+svuint16_t svextb_m(svuint16_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u32_x)))
+svuint32_t svextb_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u64_x)))
+svuint64_t svextb_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u16_x)))
+svuint16_t svextb_x(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u32_z)))
+svuint32_t svextb_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u64_z)))
+svuint64_t svextb_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u16_z)))
+svuint16_t svextb_z(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s32_m)))
+svint32_t svexth_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s64_m)))
+svint64_t svexth_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s32_x)))
+svint32_t svexth_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s64_x)))
+svint64_t svexth_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s32_z)))
+svint32_t svexth_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s64_z)))
+svint64_t svexth_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u32_m)))
+svuint32_t svexth_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u64_m)))
+svuint64_t svexth_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u32_x)))
+svuint32_t svexth_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u64_x)))
+svuint64_t svexth_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u32_z)))
+svuint32_t svexth_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u64_z)))
+svuint64_t svexth_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_s64_m)))
+svint64_t svextw_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_s64_x)))
+svint64_t svextw_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_s64_z)))
+svint64_t svextw_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_u64_m)))
+svuint64_t svextw_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_u64_x)))
+svuint64_t svextw_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_u64_z)))
+svuint64_t svextw_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u8)))
+svuint8_t svget2(svuint8x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u32)))
+svuint32_t svget2(svuint32x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u64)))
+svuint64_t svget2(svuint64x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u16)))
+svuint16_t svget2(svuint16x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s8)))
+svint8_t svget2(svint8x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_f64)))
+svfloat64_t svget2(svfloat64x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_f32)))
+svfloat32_t svget2(svfloat32x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_f16)))
+svfloat16_t svget2(svfloat16x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s32)))
+svint32_t svget2(svint32x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s64)))
+svint64_t svget2(svint64x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s16)))
+svint16_t svget2(svint16x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u8)))
+svuint8_t svget3(svuint8x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u32)))
+svuint32_t svget3(svuint32x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u64)))
+svuint64_t svget3(svuint64x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u16)))
+svuint16_t svget3(svuint16x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s8)))
+svint8_t svget3(svint8x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_f64)))
+svfloat64_t svget3(svfloat64x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_f32)))
+svfloat32_t svget3(svfloat32x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_f16)))
+svfloat16_t svget3(svfloat16x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s32)))
+svint32_t svget3(svint32x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s64)))
+svint64_t svget3(svint64x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s16)))
+svint16_t svget3(svint16x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u8)))
+svuint8_t svget4(svuint8x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u32)))
+svuint32_t svget4(svuint32x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u64)))
+svuint64_t svget4(svuint64x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u16)))
+svuint16_t svget4(svuint16x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s8)))
+svint8_t svget4(svint8x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_f64)))
+svfloat64_t svget4(svfloat64x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_f32)))
+svfloat32_t svget4(svfloat32x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_f16)))
+svfloat16_t svget4(svfloat16x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s32)))
+svint32_t svget4(svint32x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s64)))
+svint64_t svget4(svint64x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s16)))
+svint16_t svget4(svint16x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u8)))
+svuint8_t svinsr(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u32)))
+svuint32_t svinsr(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u64)))
+svuint64_t svinsr(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u16)))
+svuint16_t svinsr(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s8)))
+svint8_t svinsr(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_f64)))
+svfloat64_t svinsr(svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_f32)))
+svfloat32_t svinsr(svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_f16)))
+svfloat16_t svinsr(svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s32)))
+svint32_t svinsr(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s64)))
+svint64_t svinsr(svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s16)))
+svint16_t svinsr(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u8)))
+uint8_t svlasta(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u32)))
+uint32_t svlasta(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u64)))
+uint64_t svlasta(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u16)))
+uint16_t svlasta(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s8)))
+int8_t svlasta(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_f64)))
+float64_t svlasta(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_f32)))
+float32_t svlasta(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_f16)))
+float16_t svlasta(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s32)))
+int32_t svlasta(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s64)))
+int64_t svlasta(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s16)))
+int16_t svlasta(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u8)))
+uint8_t svlastb(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u32)))
+uint32_t svlastb(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u64)))
+uint64_t svlastb(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u16)))
+uint16_t svlastb(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s8)))
+int8_t svlastb(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_f64)))
+float64_t svlastb(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_f32)))
+float32_t svlastb(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_f16)))
+float16_t svlastb(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s32)))
+int32_t svlastb(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s64)))
+int64_t svlastb(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s16)))
+int16_t svlastb(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u8)))
+svuint8_t svld1(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u32)))
+svuint32_t svld1(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u64)))
+svuint64_t svld1(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u16)))
+svuint16_t svld1(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s8)))
+svint8_t svld1(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f64)))
+svfloat64_t svld1(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f32)))
+svfloat32_t svld1(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f16)))
+svfloat16_t svld1(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s32)))
+svint32_t svld1(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s64)))
+svint64_t svld1(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s16)))
+svint16_t svld1(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u8)))
+svuint8_t svld1_vnum(svbool_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u32)))
+svuint32_t svld1_vnum(svbool_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u64)))
+svuint64_t svld1_vnum(svbool_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u16)))
+svuint16_t svld1_vnum(svbool_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s8)))
+svint8_t svld1_vnum(svbool_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f64)))
+svfloat64_t svld1_vnum(svbool_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f32)))
+svfloat32_t svld1_vnum(svbool_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f16)))
+svfloat16_t svld1_vnum(svbool_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s32)))
+svint32_t svld1_vnum(svbool_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s64)))
+svint64_t svld1_vnum(svbool_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s16)))
+svint16_t svld1_vnum(svbool_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u8)))
+svuint8_t svld1rq(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u32)))
+svuint32_t svld1rq(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u64)))
+svuint64_t svld1rq(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u16)))
+svuint16_t svld1rq(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s8)))
+svint8_t svld1rq(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_f64)))
+svfloat64_t svld1rq(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_f32)))
+svfloat32_t svld1rq(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_f16)))
+svfloat16_t svld1rq(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s32)))
+svint32_t svld1rq(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s64)))
+svint64_t svld1rq(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s16)))
+svint16_t svld1rq(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u8)))
+svuint8x2_t svld2(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u32)))
+svuint32x2_t svld2(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u64)))
+svuint64x2_t svld2(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u16)))
+svuint16x2_t svld2(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s8)))
+svint8x2_t svld2(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_f64)))
+svfloat64x2_t svld2(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_f32)))
+svfloat32x2_t svld2(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_f16)))
+svfloat16x2_t svld2(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s32)))
+svint32x2_t svld2(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s64)))
+svint64x2_t svld2(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s16)))
+svint16x2_t svld2(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u8)))
+svuint8x2_t svld2_vnum(svbool_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u32)))
+svuint32x2_t svld2_vnum(svbool_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u64)))
+svuint64x2_t svld2_vnum(svbool_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u16)))
+svuint16x2_t svld2_vnum(svbool_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s8)))
+svint8x2_t svld2_vnum(svbool_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_f64)))
+svfloat64x2_t svld2_vnum(svbool_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_f32)))
+svfloat32x2_t svld2_vnum(svbool_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_f16)))
+svfloat16x2_t svld2_vnum(svbool_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s32)))
+svint32x2_t svld2_vnum(svbool_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s64)))
+svint64x2_t svld2_vnum(svbool_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s16)))
+svint16x2_t svld2_vnum(svbool_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u8)))
+svuint8x3_t svld3(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u32)))
+svuint32x3_t svld3(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u64)))
+svuint64x3_t svld3(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u16)))
+svuint16x3_t svld3(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s8)))
+svint8x3_t svld3(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_f64)))
+svfloat64x3_t svld3(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_f32)))
+svfloat32x3_t svld3(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_f16)))
+svfloat16x3_t svld3(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s32)))
+svint32x3_t svld3(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s64)))
+svint64x3_t svld3(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s16)))
+svint16x3_t svld3(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u8)))
+svuint8x3_t svld3_vnum(svbool_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u32)))
+svuint32x3_t svld3_vnum(svbool_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u64)))
+svuint64x3_t svld3_vnum(svbool_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u16)))
+svuint16x3_t svld3_vnum(svbool_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s8)))
+svint8x3_t svld3_vnum(svbool_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_f64)))
+svfloat64x3_t svld3_vnum(svbool_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_f32)))
+svfloat32x3_t svld3_vnum(svbool_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_f16)))
+svfloat16x3_t svld3_vnum(svbool_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s32)))
+svint32x3_t svld3_vnum(svbool_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s64)))
+svint64x3_t svld3_vnum(svbool_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s16)))
+svint16x3_t svld3_vnum(svbool_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u8)))
+svuint8x4_t svld4(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u32)))
+svuint32x4_t svld4(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u64)))
+svuint64x4_t svld4(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u16)))
+svuint16x4_t svld4(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s8)))
+svint8x4_t svld4(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_f64)))
+svfloat64x4_t svld4(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_f32)))
+svfloat32x4_t svld4(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_f16)))
+svfloat16x4_t svld4(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s32)))
+svint32x4_t svld4(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s64)))
+svint64x4_t svld4(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s16)))
+svint16x4_t svld4(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u8)))
+svuint8x4_t svld4_vnum(svbool_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u32)))
+svuint32x4_t svld4_vnum(svbool_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u64)))
+svuint64x4_t svld4_vnum(svbool_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u16)))
+svuint16x4_t svld4_vnum(svbool_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s8)))
+svint8x4_t svld4_vnum(svbool_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_f64)))
+svfloat64x4_t svld4_vnum(svbool_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_f32)))
+svfloat32x4_t svld4_vnum(svbool_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_f16)))
+svfloat16x4_t svld4_vnum(svbool_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s32)))
+svint32x4_t svld4_vnum(svbool_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s64)))
+svint64x4_t svld4_vnum(svbool_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s16)))
+svint16x4_t svld4_vnum(svbool_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u8)))
+svuint8_t svldnt1(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u32)))
+svuint32_t svldnt1(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u64)))
+svuint64_t svldnt1(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u16)))
+svuint16_t svldnt1(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s8)))
+svint8_t svldnt1(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f64)))
+svfloat64_t svldnt1(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f32)))
+svfloat32_t svldnt1(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f16)))
+svfloat16_t svldnt1(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s32)))
+svint32_t svldnt1(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s64)))
+svint64_t svldnt1(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s16)))
+svint16_t svldnt1(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u8)))
+svuint8_t svldnt1_vnum(svbool_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u32)))
+svuint32_t svldnt1_vnum(svbool_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u64)))
+svuint64_t svldnt1_vnum(svbool_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u16)))
+svuint16_t svldnt1_vnum(svbool_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s8)))
+svint8_t svldnt1_vnum(svbool_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f64)))
+svfloat64_t svldnt1_vnum(svbool_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f32)))
+svfloat32_t svldnt1_vnum(svbool_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f16)))
+svfloat16_t svldnt1_vnum(svbool_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s32)))
+svint32_t svldnt1_vnum(svbool_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s64)))
+svint64_t svldnt1_vnum(svbool_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s16)))
+svint16_t svldnt1_vnum(svbool_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u8)))
+uint64_t svlen(svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u32)))
+uint64_t svlen(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u64)))
+uint64_t svlen(svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u16)))
+uint64_t svlen(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s8)))
+uint64_t svlen(svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_f64)))
+uint64_t svlen(svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_f32)))
+uint64_t svlen(svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_f16)))
+uint64_t svlen(svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s32)))
+uint64_t svlen(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s64)))
+uint64_t svlen(svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s16)))
+uint64_t svlen(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u8_m)))
+svuint8_t svlsl_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u32_m)))
+svuint32_t svlsl_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u64_m)))
+svuint64_t svlsl_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u16_m)))
+svuint16_t svlsl_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s8_m)))
+svint8_t svlsl_m(svbool_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s32_m)))
+svint32_t svlsl_m(svbool_t, svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s64_m)))
+svint64_t svlsl_m(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s16_m)))
+svint16_t svlsl_m(svbool_t, svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u8_x)))
+svuint8_t svlsl_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u32_x)))
+svuint32_t svlsl_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u64_x)))
+svuint64_t svlsl_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u16_x)))
+svuint16_t svlsl_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s8_x)))
+svint8_t svlsl_x(svbool_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s32_x)))
+svint32_t svlsl_x(svbool_t, svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s64_x)))
+svint64_t svlsl_x(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s16_x)))
+svint16_t svlsl_x(svbool_t, svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u8_z)))
+svuint8_t svlsl_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u32_z)))
+svuint32_t svlsl_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u64_z)))
+svuint64_t svlsl_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u16_z)))
+svuint16_t svlsl_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s8_z)))
+svint8_t svlsl_z(svbool_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s32_z)))
+svint32_t svlsl_z(svbool_t, svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s64_z)))
+svint64_t svlsl_z(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s16_z)))
+svint16_t svlsl_z(svbool_t, svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u8_m)))
+svuint8_t svlsl_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u32_m)))
+svuint32_t svlsl_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u64_m)))
+svuint64_t svlsl_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u16_m)))
+svuint16_t svlsl_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s8_m)))
+svint8_t svlsl_m(svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s32_m)))
+svint32_t svlsl_m(svbool_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s64_m)))
+svint64_t svlsl_m(svbool_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s16_m)))
+svint16_t svlsl_m(svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u8_x)))
+svuint8_t svlsl_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u32_x)))
+svuint32_t svlsl_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u64_x)))
+svuint64_t svlsl_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u16_x)))
+svuint16_t svlsl_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s8_x)))
+svint8_t svlsl_x(svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s32_x)))
+svint32_t svlsl_x(svbool_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s64_x)))
+svint64_t svlsl_x(svbool_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s16_x)))
+svint16_t svlsl_x(svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u8_z)))
+svuint8_t svlsl_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u32_z)))
+svuint32_t svlsl_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u64_z)))
+svuint64_t svlsl_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u16_z)))
+svuint16_t svlsl_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s8_z)))
+svint8_t svlsl_z(svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s32_z)))
+svint32_t svlsl_z(svbool_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s64_z)))
+svint64_t svlsl_z(svbool_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s16_z)))
+svint16_t svlsl_z(svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u8_m)))
+svuint8_t svlsl_wide_m(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u32_m)))
+svuint32_t svlsl_wide_m(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u16_m)))
+svuint16_t svlsl_wide_m(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s8_m)))
+svint8_t svlsl_wide_m(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s32_m)))
+svint32_t svlsl_wide_m(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s16_m)))
+svint16_t svlsl_wide_m(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u8_x)))
+svuint8_t svlsl_wide_x(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u32_x)))
+svuint32_t svlsl_wide_x(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u16_x)))
+svuint16_t svlsl_wide_x(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s8_x)))
+svint8_t svlsl_wide_x(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s32_x)))
+svint32_t svlsl_wide_x(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s16_x)))
+svint16_t svlsl_wide_x(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u8_z)))
+svuint8_t svlsl_wide_z(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u32_z)))
+svuint32_t svlsl_wide_z(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u16_z)))
+svuint16_t svlsl_wide_z(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s8_z)))
+svint8_t svlsl_wide_z(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s32_z)))
+svint32_t svlsl_wide_z(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s16_z)))
+svint16_t svlsl_wide_z(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u8_m)))
+svuint8_t svlsl_wide_m(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u32_m)))
+svuint32_t svlsl_wide_m(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u16_m)))
+svuint16_t svlsl_wide_m(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s8_m)))
+svint8_t svlsl_wide_m(svbool_t, svint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s32_m)))
+svint32_t svlsl_wide_m(svbool_t, svint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s16_m)))
+svint16_t svlsl_wide_m(svbool_t, svint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u8_x)))
+svuint8_t svlsl_wide_x(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u32_x)))
+svuint32_t svlsl_wide_x(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u16_x)))
+svuint16_t svlsl_wide_x(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s8_x)))
+svint8_t svlsl_wide_x(svbool_t, svint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s32_x)))
+svint32_t svlsl_wide_x(svbool_t, svint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s16_x)))
+svint16_t svlsl_wide_x(svbool_t, svint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u8_z)))
+svuint8_t svlsl_wide_z(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u32_z)))
+svuint32_t svlsl_wide_z(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u16_z)))
+svuint16_t svlsl_wide_z(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s8_z)))
+svint8_t svlsl_wide_z(svbool_t, svint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s32_z)))
+svint32_t svlsl_wide_z(svbool_t, svint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s16_z)))
+svint16_t svlsl_wide_z(svbool_t, svint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u8_m)))
+svuint8_t svlsr_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u32_m)))
+svuint32_t svlsr_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u64_m)))
+svuint64_t svlsr_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u16_m)))
+svuint16_t svlsr_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u8_x)))
+svuint8_t svlsr_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u32_x)))
+svuint32_t svlsr_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u64_x)))
+svuint64_t svlsr_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u16_x)))
+svuint16_t svlsr_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u8_z)))
+svuint8_t svlsr_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u32_z)))
+svuint32_t svlsr_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u64_z)))
+svuint64_t svlsr_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u16_z)))
+svuint16_t svlsr_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u8_m)))
+svuint8_t svlsr_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u32_m)))
+svuint32_t svlsr_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u64_m)))
+svuint64_t svlsr_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u16_m)))
+svuint16_t svlsr_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u8_x)))
+svuint8_t svlsr_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u32_x)))
+svuint32_t svlsr_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u64_x)))
+svuint64_t svlsr_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u16_x)))
+svuint16_t svlsr_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u8_z)))
+svuint8_t svlsr_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u32_z)))
+svuint32_t svlsr_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u64_z)))
+svuint64_t svlsr_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u16_z)))
+svuint16_t svlsr_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u8_m)))
+svuint8_t svlsr_wide_m(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u32_m)))
+svuint32_t svlsr_wide_m(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u16_m)))
+svuint16_t svlsr_wide_m(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u8_x)))
+svuint8_t svlsr_wide_x(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u32_x)))
+svuint32_t svlsr_wide_x(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u16_x)))
+svuint16_t svlsr_wide_x(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u8_z)))
+svuint8_t svlsr_wide_z(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u32_z)))
+svuint32_t svlsr_wide_z(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u16_z)))
+svuint16_t svlsr_wide_z(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u8_m)))
+svuint8_t svlsr_wide_m(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u32_m)))
+svuint32_t svlsr_wide_m(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u16_m)))
+svuint16_t svlsr_wide_m(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u8_x)))
+svuint8_t svlsr_wide_x(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u32_x)))
+svuint32_t svlsr_wide_x(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u16_x)))
+svuint16_t svlsr_wide_x(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u8_z)))
+svuint8_t svlsr_wide_z(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u32_z)))
+svuint32_t svlsr_wide_z(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u16_z)))
+svuint16_t svlsr_wide_z(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f64_m)))
+svfloat64_t svmad_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f32_m)))
+svfloat32_t svmad_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f16_m)))
+svfloat16_t svmad_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f64_x)))
+svfloat64_t svmad_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f32_x)))
+svfloat32_t svmad_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f16_x)))
+svfloat16_t svmad_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f64_z)))
+svfloat64_t svmad_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f32_z)))
+svfloat32_t svmad_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f16_z)))
+svfloat16_t svmad_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u8_m)))
+svuint8_t svmad_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u32_m)))
+svuint32_t svmad_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u64_m)))
+svuint64_t svmad_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u16_m)))
+svuint16_t svmad_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s8_m)))
+svint8_t svmad_m(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s32_m)))
+svint32_t svmad_m(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s64_m)))
+svint64_t svmad_m(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s16_m)))
+svint16_t svmad_m(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u8_x)))
+svuint8_t svmad_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u32_x)))
+svuint32_t svmad_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u64_x)))
+svuint64_t svmad_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u16_x)))
+svuint16_t svmad_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s8_x)))
+svint8_t svmad_x(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s32_x)))
+svint32_t svmad_x(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s64_x)))
+svint64_t svmad_x(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s16_x)))
+svint16_t svmad_x(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u8_z)))
+svuint8_t svmad_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u32_z)))
+svuint32_t svmad_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u64_z)))
+svuint64_t svmad_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u16_z)))
+svuint16_t svmad_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s8_z)))
+svint8_t svmad_z(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s32_z)))
+svint32_t svmad_z(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s64_z)))
+svint64_t svmad_z(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s16_z)))
+svint16_t svmad_z(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f64_m)))
+svfloat64_t svmad_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f32_m)))
+svfloat32_t svmad_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f16_m)))
+svfloat16_t svmad_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f64_x)))
+svfloat64_t svmad_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f32_x)))
+svfloat32_t svmad_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f16_x)))
+svfloat16_t svmad_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f64_z)))
+svfloat64_t svmad_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f32_z)))
+svfloat32_t svmad_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f16_z)))
+svfloat16_t svmad_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u8_m)))
+svuint8_t svmad_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u32_m)))
+svuint32_t svmad_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u64_m)))
+svuint64_t svmad_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u16_m)))
+svuint16_t svmad_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s8_m)))
+svint8_t svmad_m(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s32_m)))
+svint32_t svmad_m(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s64_m)))
+svint64_t svmad_m(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s16_m)))
+svint16_t svmad_m(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u8_x)))
+svuint8_t svmad_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u32_x)))
+svuint32_t svmad_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u64_x)))
+svuint64_t svmad_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u16_x)))
+svuint16_t svmad_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s8_x)))
+svint8_t svmad_x(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s32_x)))
+svint32_t svmad_x(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s64_x)))
+svint64_t svmad_x(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s16_x)))
+svint16_t svmad_x(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u8_z)))
+svuint8_t svmad_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u32_z)))
+svuint32_t svmad_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u64_z)))
+svuint64_t svmad_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u16_z)))
+svuint16_t svmad_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s8_z)))
+svint8_t svmad_z(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s32_z)))
+svint32_t svmad_z(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s64_z)))
+svint64_t svmad_z(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s16_z)))
+svint16_t svmad_z(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f64_m)))
+svfloat64_t svmax_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f32_m)))
+svfloat32_t svmax_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f16_m)))
+svfloat16_t svmax_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f64_x)))
+svfloat64_t svmax_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f32_x)))
+svfloat32_t svmax_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f16_x)))
+svfloat16_t svmax_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f64_z)))
+svfloat64_t svmax_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f32_z)))
+svfloat32_t svmax_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f16_z)))
+svfloat16_t svmax_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s8_m)))
+svint8_t svmax_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s32_m)))
+svint32_t svmax_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s64_m)))
+svint64_t svmax_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s16_m)))
+svint16_t svmax_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s8_x)))
+svint8_t svmax_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s32_x)))
+svint32_t svmax_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s64_x)))
+svint64_t svmax_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s16_x)))
+svint16_t svmax_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s8_z)))
+svint8_t svmax_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s32_z)))
+svint32_t svmax_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s64_z)))
+svint64_t svmax_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s16_z)))
+svint16_t svmax_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u8_m)))
+svuint8_t svmax_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u32_m)))
+svuint32_t svmax_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u64_m)))
+svuint64_t svmax_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u16_m)))
+svuint16_t svmax_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u8_x)))
+svuint8_t svmax_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u32_x)))
+svuint32_t svmax_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u64_x)))
+svuint64_t svmax_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u16_x)))
+svuint16_t svmax_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u8_z)))
+svuint8_t svmax_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u32_z)))
+svuint32_t svmax_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u64_z)))
+svuint64_t svmax_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u16_z)))
+svuint16_t svmax_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_m)))
+svfloat64_t svmax_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_m)))
+svfloat32_t svmax_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_m)))
+svfloat16_t svmax_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_x)))
+svfloat64_t svmax_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_x)))
+svfloat32_t svmax_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_x)))
+svfloat16_t svmax_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_z)))
+svfloat64_t svmax_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_z)))
+svfloat32_t svmax_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_z)))
+svfloat16_t svmax_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_m)))
+svint8_t svmax_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_m)))
+svint32_t svmax_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_m)))
+svint64_t svmax_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_m)))
+svint16_t svmax_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_x)))
+svint8_t svmax_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_x)))
+svint32_t svmax_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_x)))
+svint64_t svmax_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_x)))
+svint16_t svmax_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_z)))
+svint8_t svmax_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_z)))
+svint32_t svmax_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_z)))
+svint64_t svmax_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_z)))
+svint16_t svmax_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_m)))
+svuint8_t svmax_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_m)))
+svuint32_t svmax_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_m)))
+svuint64_t svmax_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_m)))
+svuint16_t svmax_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_x)))
+svuint8_t svmax_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_x)))
+svuint32_t svmax_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_x)))
+svuint64_t svmax_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_x)))
+svuint16_t svmax_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_z)))
+svuint8_t svmax_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_z)))
+svuint32_t svmax_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_z)))
+svuint64_t svmax_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_z)))
+svuint16_t svmax_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f64_m)))
+svfloat64_t svmaxnm_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f32_m)))
+svfloat32_t svmaxnm_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f16_m)))
+svfloat16_t svmaxnm_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f64_x)))
+svfloat64_t svmaxnm_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f32_x)))
+svfloat32_t svmaxnm_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f16_x)))
+svfloat16_t svmaxnm_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f64_z)))
+svfloat64_t svmaxnm_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f32_z)))
+svfloat32_t svmaxnm_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f16_z)))
+svfloat16_t svmaxnm_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_m)))
+svfloat64_t svmaxnm_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_m)))
+svfloat32_t svmaxnm_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_m)))
+svfloat16_t svmaxnm_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_x)))
+svfloat64_t svmaxnm_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_x)))
+svfloat32_t svmaxnm_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x)))
+svfloat16_t svmaxnm_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_z)))
+svfloat64_t svmaxnm_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_z)))
+svfloat32_t svmaxnm_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_z)))
+svfloat16_t svmaxnm_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmv_f64)))
+float64_t svmaxnmv(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmv_f32)))
+float32_t svmaxnmv(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmv_f16)))
+float16_t svmaxnmv(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_f64)))
+float64_t svmaxv(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_f32)))
+float32_t svmaxv(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_f16)))
+float16_t svmaxv(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s8)))
+int8_t svmaxv(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s32)))
+int32_t svmaxv(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s64)))
+int64_t svmaxv(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s16)))
+int16_t svmaxv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u8)))
+uint8_t svmaxv(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u32)))
+uint32_t svmaxv(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u64)))
+uint64_t svmaxv(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u16)))
+uint16_t svmaxv(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f64_m)))
+svfloat64_t svmin_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f32_m)))
+svfloat32_t svmin_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f16_m)))
+svfloat16_t svmin_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f64_x)))
+svfloat64_t svmin_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f32_x)))
+svfloat32_t svmin_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f16_x)))
+svfloat16_t svmin_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f64_z)))
+svfloat64_t svmin_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f32_z)))
+svfloat32_t svmin_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f16_z)))
+svfloat16_t svmin_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s8_m)))
+svint8_t svmin_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s32_m)))
+svint32_t svmin_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s64_m)))
+svint64_t svmin_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s16_m)))
+svint16_t svmin_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s8_x)))
+svint8_t svmin_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s32_x)))
+svint32_t svmin_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s64_x)))
+svint64_t svmin_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s16_x)))
+svint16_t svmin_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s8_z)))
+svint8_t svmin_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s32_z)))
+svint32_t svmin_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s64_z)))
+svint64_t svmin_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s16_z)))
+svint16_t svmin_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u8_m)))
+svuint8_t svmin_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u32_m)))
+svuint32_t svmin_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u64_m)))
+svuint64_t svmin_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u16_m)))
+svuint16_t svmin_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u8_x)))
+svuint8_t svmin_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u32_x)))
+svuint32_t svmin_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u64_x)))
+svuint64_t svmin_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u16_x)))
+svuint16_t svmin_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u8_z)))
+svuint8_t svmin_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u32_z)))
+svuint32_t svmin_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u64_z)))
+svuint64_t svmin_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u16_z)))
+svuint16_t svmin_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_m)))
+svfloat64_t svmin_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_m)))
+svfloat32_t svmin_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_m)))
+svfloat16_t svmin_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_x)))
+svfloat64_t svmin_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_x)))
+svfloat32_t svmin_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_x)))
+svfloat16_t svmin_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_z)))
+svfloat64_t svmin_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_z)))
+svfloat32_t svmin_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_z)))
+svfloat16_t svmin_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_m)))
+svint8_t svmin_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_m)))
+svint32_t svmin_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_m)))
+svint64_t svmin_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_m)))
+svint16_t svmin_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_x)))
+svint8_t svmin_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_x)))
+svint32_t svmin_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_x)))
+svint64_t svmin_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_x)))
+svint16_t svmin_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_z)))
+svint8_t svmin_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_z)))
+svint32_t svmin_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_z)))
+svint64_t svmin_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_z)))
+svint16_t svmin_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_m)))
+svuint8_t svmin_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_m)))
+svuint32_t svmin_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_m)))
+svuint64_t svmin_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_m)))
+svuint16_t svmin_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_x)))
+svuint8_t svmin_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_x)))
+svuint32_t svmin_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_x)))
+svuint64_t svmin_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_x)))
+svuint16_t svmin_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_z)))
+svuint8_t svmin_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_z)))
+svuint32_t svmin_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_z)))
+svuint64_t svmin_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_z)))
+svuint16_t svmin_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f64_m)))
+svfloat64_t svminnm_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f32_m)))
+svfloat32_t svminnm_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f16_m)))
+svfloat16_t svminnm_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f64_x)))
+svfloat64_t svminnm_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f32_x)))
+svfloat32_t svminnm_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f16_x)))
+svfloat16_t svminnm_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f64_z)))
+svfloat64_t svminnm_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f32_z)))
+svfloat32_t svminnm_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f16_z)))
+svfloat16_t svminnm_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_m)))
+svfloat64_t svminnm_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_m)))
+svfloat32_t svminnm_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_m)))
+svfloat16_t svminnm_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_x)))
+svfloat64_t svminnm_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_x)))
+svfloat32_t svminnm_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_x)))
+svfloat16_t svminnm_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_z)))
+svfloat64_t svminnm_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_z)))
+svfloat32_t svminnm_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_z)))
+svfloat16_t svminnm_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmv_f64)))
+float64_t svminnmv(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmv_f32)))
+float32_t svminnmv(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmv_f16)))
+float16_t svminnmv(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_f64)))
+float64_t svminv(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_f32)))
+float32_t svminv(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_f16)))
+float16_t svminv(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s8)))
+int8_t svminv(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s32)))
+int32_t svminv(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s64)))
+int64_t svminv(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s16)))
+int16_t svminv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u8)))
+uint8_t svminv(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u32)))
+uint32_t svminv(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u64)))
+uint64_t svminv(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u16)))
+uint16_t svminv(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f64_m)))
+svfloat64_t svmla_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f32_m)))
+svfloat32_t svmla_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f16_m)))
+svfloat16_t svmla_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f64_x)))
+svfloat64_t svmla_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f32_x)))
+svfloat32_t svmla_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f16_x)))
+svfloat16_t svmla_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f64_z)))
+svfloat64_t svmla_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f32_z)))
+svfloat32_t svmla_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f16_z)))
+svfloat16_t svmla_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u8_m)))
+svuint8_t svmla_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u32_m)))
+svuint32_t svmla_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u64_m)))
+svuint64_t svmla_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u16_m)))
+svuint16_t svmla_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s8_m)))
+svint8_t svmla_m(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s32_m)))
+svint32_t svmla_m(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s64_m)))
+svint64_t svmla_m(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s16_m)))
+svint16_t svmla_m(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u8_x)))
+svuint8_t svmla_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u32_x)))
+svuint32_t svmla_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u64_x)))
+svuint64_t svmla_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u16_x)))
+svuint16_t svmla_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s8_x)))
+svint8_t svmla_x(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s32_x)))
+svint32_t svmla_x(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s64_x)))
+svint64_t svmla_x(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s16_x)))
+svint16_t svmla_x(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u8_z)))
+svuint8_t svmla_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u32_z)))
+svuint32_t svmla_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u64_z)))
+svuint64_t svmla_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u16_z)))
+svuint16_t svmla_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s8_z)))
+svint8_t svmla_z(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s32_z)))
+svint32_t svmla_z(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s64_z)))
+svint64_t svmla_z(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s16_z)))
+svint16_t svmla_z(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f64_m)))
+svfloat64_t svmla_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f32_m)))
+svfloat32_t svmla_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f16_m)))
+svfloat16_t svmla_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f64_x)))
+svfloat64_t svmla_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f32_x)))
+svfloat32_t svmla_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f16_x)))
+svfloat16_t svmla_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f64_z)))
+svfloat64_t svmla_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f32_z)))
+svfloat32_t svmla_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f16_z)))
+svfloat16_t svmla_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u8_m)))
+svuint8_t svmla_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u32_m)))
+svuint32_t svmla_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u64_m)))
+svuint64_t svmla_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u16_m)))
+svuint16_t svmla_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s8_m)))
+svint8_t svmla_m(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s32_m)))
+svint32_t svmla_m(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s64_m)))
+svint64_t svmla_m(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s16_m)))
+svint16_t svmla_m(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u8_x)))
+svuint8_t svmla_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u32_x)))
+svuint32_t svmla_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u64_x)))
+svuint64_t svmla_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u16_x)))
+svuint16_t svmla_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s8_x)))
+svint8_t svmla_x(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s32_x)))
+svint32_t svmla_x(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s64_x)))
+svint64_t svmla_x(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s16_x)))
+svint16_t svmla_x(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u8_z)))
+svuint8_t svmla_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u32_z)))
+svuint32_t svmla_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u64_z)))
+svuint64_t svmla_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u16_z)))
+svuint16_t svmla_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s8_z)))
+svint8_t svmla_z(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s32_z)))
+svint32_t svmla_z(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s64_z)))
+svint64_t svmla_z(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s16_z)))
+svint16_t svmla_z(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_f64)))
+svfloat64_t svmla_lane(svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_f32)))
+svfloat32_t svmla_lane(svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_f16)))
+svfloat16_t svmla_lane(svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f64_m)))
+svfloat64_t svmls_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f32_m)))
+svfloat32_t svmls_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f16_m)))
+svfloat16_t svmls_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f64_x)))
+svfloat64_t svmls_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f32_x)))
+svfloat32_t svmls_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f16_x)))
+svfloat16_t svmls_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f64_z)))
+svfloat64_t svmls_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f32_z)))
+svfloat32_t svmls_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f16_z)))
+svfloat16_t svmls_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u8_m)))
+svuint8_t svmls_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u32_m)))
+svuint32_t svmls_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u64_m)))
+svuint64_t svmls_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u16_m)))
+svuint16_t svmls_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s8_m)))
+svint8_t svmls_m(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s32_m)))
+svint32_t svmls_m(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s64_m)))
+svint64_t svmls_m(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s16_m)))
+svint16_t svmls_m(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u8_x)))
+svuint8_t svmls_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u32_x)))
+svuint32_t svmls_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u64_x)))
+svuint64_t svmls_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u16_x)))
+svuint16_t svmls_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s8_x)))
+svint8_t svmls_x(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s32_x)))
+svint32_t svmls_x(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s64_x)))
+svint64_t svmls_x(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s16_x)))
+svint16_t svmls_x(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u8_z)))
+svuint8_t svmls_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u32_z)))
+svuint32_t svmls_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u64_z)))
+svuint64_t svmls_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u16_z)))
+svuint16_t svmls_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s8_z)))
+svint8_t svmls_z(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s32_z)))
+svint32_t svmls_z(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s64_z)))
+svint64_t svmls_z(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s16_z)))
+svint16_t svmls_z(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f64_m)))
+svfloat64_t svmls_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f32_m)))
+svfloat32_t svmls_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f16_m)))
+svfloat16_t svmls_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f64_x)))
+svfloat64_t svmls_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f32_x)))
+svfloat32_t svmls_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f16_x)))
+svfloat16_t svmls_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f64_z)))
+svfloat64_t svmls_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f32_z)))
+svfloat32_t svmls_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f16_z)))
+svfloat16_t svmls_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u8_m)))
+svuint8_t svmls_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u32_m)))
+svuint32_t svmls_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u64_m)))
+svuint64_t svmls_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u16_m)))
+svuint16_t svmls_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s8_m)))
+svint8_t svmls_m(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s32_m)))
+svint32_t svmls_m(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s64_m)))
+svint64_t svmls_m(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s16_m)))
+svint16_t svmls_m(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u8_x)))
+svuint8_t svmls_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u32_x)))
+svuint32_t svmls_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u64_x)))
+svuint64_t svmls_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u16_x)))
+svuint16_t svmls_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s8_x)))
+svint8_t svmls_x(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s32_x)))
+svint32_t svmls_x(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s64_x)))
+svint64_t svmls_x(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s16_x)))
+svint16_t svmls_x(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u8_z)))
+svuint8_t svmls_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u32_z)))
+svuint32_t svmls_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u64_z)))
+svuint64_t svmls_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u16_z)))
+svuint16_t svmls_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s8_z)))
+svint8_t svmls_z(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s32_z)))
+svint32_t svmls_z(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s64_z)))
+svint64_t svmls_z(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s16_z)))
+svint16_t svmls_z(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_f64)))
+svfloat64_t svmls_lane(svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_f32)))
+svfloat32_t svmls_lane(svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_f16)))
+svfloat16_t svmls_lane(svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmov_b_z)))
+svbool_t svmov_z(svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f64_m)))
+svfloat64_t svmsb_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f32_m)))
+svfloat32_t svmsb_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f16_m)))
+svfloat16_t svmsb_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f64_x)))
+svfloat64_t svmsb_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f32_x)))
+svfloat32_t svmsb_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f16_x)))
+svfloat16_t svmsb_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f64_z)))
+svfloat64_t svmsb_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f32_z)))
+svfloat32_t svmsb_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f16_z)))
+svfloat16_t svmsb_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u8_m)))
+svuint8_t svmsb_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u32_m)))
+svuint32_t svmsb_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u64_m)))
+svuint64_t svmsb_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u16_m)))
+svuint16_t svmsb_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s8_m)))
+svint8_t svmsb_m(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s32_m)))
+svint32_t svmsb_m(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s64_m)))
+svint64_t svmsb_m(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s16_m)))
+svint16_t svmsb_m(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u8_x)))
+svuint8_t svmsb_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u32_x)))
+svuint32_t svmsb_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u64_x)))
+svuint64_t svmsb_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u16_x)))
+svuint16_t svmsb_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s8_x)))
+svint8_t svmsb_x(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s32_x)))
+svint32_t svmsb_x(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s64_x)))
+svint64_t svmsb_x(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s16_x)))
+svint16_t svmsb_x(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u8_z)))
+svuint8_t svmsb_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u32_z)))
+svuint32_t svmsb_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u64_z)))
+svuint64_t svmsb_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u16_z)))
+svuint16_t svmsb_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s8_z)))
+svint8_t svmsb_z(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s32_z)))
+svint32_t svmsb_z(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s64_z)))
+svint64_t svmsb_z(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s16_z)))
+svint16_t svmsb_z(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f64_m)))
+svfloat64_t svmsb_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f32_m)))
+svfloat32_t svmsb_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f16_m)))
+svfloat16_t svmsb_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f64_x)))
+svfloat64_t svmsb_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f32_x)))
+svfloat32_t svmsb_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f16_x)))
+svfloat16_t svmsb_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f64_z)))
+svfloat64_t svmsb_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f32_z)))
+svfloat32_t svmsb_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f16_z)))
+svfloat16_t svmsb_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u8_m)))
+svuint8_t svmsb_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u32_m)))
+svuint32_t svmsb_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u64_m)))
+svuint64_t svmsb_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u16_m)))
+svuint16_t svmsb_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s8_m)))
+svint8_t svmsb_m(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s32_m)))
+svint32_t svmsb_m(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s64_m)))
+svint64_t svmsb_m(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s16_m)))
+svint16_t svmsb_m(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u8_x)))
+svuint8_t svmsb_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u32_x)))
+svuint32_t svmsb_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u64_x)))
+svuint64_t svmsb_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u16_x)))
+svuint16_t svmsb_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s8_x)))
+svint8_t svmsb_x(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s32_x)))
+svint32_t svmsb_x(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s64_x)))
+svint64_t svmsb_x(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s16_x)))
+svint16_t svmsb_x(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u8_z)))
+svuint8_t svmsb_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u32_z)))
+svuint32_t svmsb_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u64_z)))
+svuint64_t svmsb_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u16_z)))
+svuint16_t svmsb_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s8_z)))
+svint8_t svmsb_z(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s32_z)))
+svint32_t svmsb_z(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s64_z)))
+svint64_t svmsb_z(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s16_z)))
+svint16_t svmsb_z(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f64_m)))
+svfloat64_t svmul_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f32_m)))
+svfloat32_t svmul_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f16_m)))
+svfloat16_t svmul_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f64_x)))
+svfloat64_t svmul_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f32_x)))
+svfloat32_t svmul_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f16_x)))
+svfloat16_t svmul_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f64_z)))
+svfloat64_t svmul_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f32_z)))
+svfloat32_t svmul_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f16_z)))
+svfloat16_t svmul_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u8_m)))
+svuint8_t svmul_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u32_m)))
+svuint32_t svmul_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u64_m)))
+svuint64_t svmul_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u16_m)))
+svuint16_t svmul_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s8_m)))
+svint8_t svmul_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s32_m)))
+svint32_t svmul_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s64_m)))
+svint64_t svmul_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s16_m)))
+svint16_t svmul_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u8_x)))
+svuint8_t svmul_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u32_x)))
+svuint32_t svmul_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u64_x)))
+svuint64_t svmul_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u16_x)))
+svuint16_t svmul_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s8_x)))
+svint8_t svmul_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s32_x)))
+svint32_t svmul_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s64_x)))
+svint64_t svmul_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s16_x)))
+svint16_t svmul_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u8_z)))
+svuint8_t svmul_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u32_z)))
+svuint32_t svmul_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u64_z)))
+svuint64_t svmul_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u16_z)))
+svuint16_t svmul_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s8_z)))
+svint8_t svmul_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s32_z)))
+svint32_t svmul_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s64_z)))
+svint64_t svmul_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s16_z)))
+svint16_t svmul_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f64_m)))
+svfloat64_t svmul_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f32_m)))
+svfloat32_t svmul_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f16_m)))
+svfloat16_t svmul_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f64_x)))
+svfloat64_t svmul_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f32_x)))
+svfloat32_t svmul_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f16_x)))
+svfloat16_t svmul_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f64_z)))
+svfloat64_t svmul_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f32_z)))
+svfloat32_t svmul_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f16_z)))
+svfloat16_t svmul_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u8_m)))
+svuint8_t svmul_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u32_m)))
+svuint32_t svmul_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u64_m)))
+svuint64_t svmul_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u16_m)))
+svuint16_t svmul_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s8_m)))
+svint8_t svmul_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s32_m)))
+svint32_t svmul_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s64_m)))
+svint64_t svmul_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s16_m)))
+svint16_t svmul_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u8_x)))
+svuint8_t svmul_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u32_x)))
+svuint32_t svmul_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u64_x)))
+svuint64_t svmul_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u16_x)))
+svuint16_t svmul_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s8_x)))
+svint8_t svmul_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s32_x)))
+svint32_t svmul_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s64_x)))
+svint64_t svmul_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s16_x)))
+svint16_t svmul_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u8_z)))
+svuint8_t svmul_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u32_z)))
+svuint32_t svmul_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u64_z)))
+svuint64_t svmul_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u16_z)))
+svuint16_t svmul_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s8_z)))
+svint8_t svmul_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s32_z)))
+svint32_t svmul_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s64_z)))
+svint64_t svmul_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s16_z)))
+svint16_t svmul_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_f64)))
+svfloat64_t svmul_lane(svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_f32)))
+svfloat32_t svmul_lane(svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_f16)))
+svfloat16_t svmul_lane(svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s8_m)))
+svint8_t svmulh_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s32_m)))
+svint32_t svmulh_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s64_m)))
+svint64_t svmulh_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s16_m)))
+svint16_t svmulh_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s8_x)))
+svint8_t svmulh_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s32_x)))
+svint32_t svmulh_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s64_x)))
+svint64_t svmulh_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s16_x)))
+svint16_t svmulh_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s8_z)))
+svint8_t svmulh_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s32_z)))
+svint32_t svmulh_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s64_z)))
+svint64_t svmulh_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s16_z)))
+svint16_t svmulh_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u8_m)))
+svuint8_t svmulh_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u32_m)))
+svuint32_t svmulh_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u64_m)))
+svuint64_t svmulh_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u16_m)))
+svuint16_t svmulh_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u8_x)))
+svuint8_t svmulh_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u32_x)))
+svuint32_t svmulh_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u64_x)))
+svuint64_t svmulh_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u16_x)))
+svuint16_t svmulh_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u8_z)))
+svuint8_t svmulh_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u32_z)))
+svuint32_t svmulh_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u64_z)))
+svuint64_t svmulh_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u16_z)))
+svuint16_t svmulh_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s8_m)))
+svint8_t svmulh_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s32_m)))
+svint32_t svmulh_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s64_m)))
+svint64_t svmulh_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s16_m)))
+svint16_t svmulh_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s8_x)))
+svint8_t svmulh_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s32_x)))
+svint32_t svmulh_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s64_x)))
+svint64_t svmulh_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s16_x)))
+svint16_t svmulh_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s8_z)))
+svint8_t svmulh_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s32_z)))
+svint32_t svmulh_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s64_z)))
+svint64_t svmulh_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s16_z)))
+svint16_t svmulh_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u8_m)))
+svuint8_t svmulh_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u32_m)))
+svuint32_t svmulh_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u64_m)))
+svuint64_t svmulh_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u16_m)))
+svuint16_t svmulh_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u8_x)))
+svuint8_t svmulh_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u32_x)))
+svuint32_t svmulh_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u64_x)))
+svuint64_t svmulh_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u16_x)))
+svuint16_t svmulh_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u8_z)))
+svuint8_t svmulh_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u32_z)))
+svuint32_t svmulh_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u64_z)))
+svuint64_t svmulh_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u16_z)))
+svuint16_t svmulh_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f64_m)))
+svfloat64_t svmulx_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f32_m)))
+svfloat32_t svmulx_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f16_m)))
+svfloat16_t svmulx_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f64_x)))
+svfloat64_t svmulx_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f32_x)))
+svfloat32_t svmulx_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f16_x)))
+svfloat16_t svmulx_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f64_z)))
+svfloat64_t svmulx_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f32_z)))
+svfloat32_t svmulx_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f16_z)))
+svfloat16_t svmulx_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f64_m)))
+svfloat64_t svmulx_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f32_m)))
+svfloat32_t svmulx_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f16_m)))
+svfloat16_t svmulx_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f64_x)))
+svfloat64_t svmulx_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f32_x)))
+svfloat32_t svmulx_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f16_x)))
+svfloat16_t svmulx_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f64_z)))
+svfloat64_t svmulx_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f32_z)))
+svfloat32_t svmulx_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f16_z)))
+svfloat16_t svmulx_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnand_b_z)))
+svbool_t svnand_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f64_m)))
+svfloat64_t svneg_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f32_m)))
+svfloat32_t svneg_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f16_m)))
+svfloat16_t svneg_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f64_x)))
+svfloat64_t svneg_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f32_x)))
+svfloat32_t svneg_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f16_x)))
+svfloat16_t svneg_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f64_z)))
+svfloat64_t svneg_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f32_z)))
+svfloat32_t svneg_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f16_z)))
+svfloat16_t svneg_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s8_m)))
+svint8_t svneg_m(svint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s32_m)))
+svint32_t svneg_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s64_m)))
+svint64_t svneg_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s16_m)))
+svint16_t svneg_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s8_x)))
+svint8_t svneg_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s32_x)))
+svint32_t svneg_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s64_x)))
+svint64_t svneg_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s16_x)))
+svint16_t svneg_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s8_z)))
+svint8_t svneg_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s32_z)))
+svint32_t svneg_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s64_z)))
+svint64_t svneg_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s16_z)))
+svint16_t svneg_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f64_m)))
+svfloat64_t svnmad_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f32_m)))
+svfloat32_t svnmad_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f16_m)))
+svfloat16_t svnmad_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f64_x)))
+svfloat64_t svnmad_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f32_x)))
+svfloat32_t svnmad_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f16_x)))
+svfloat16_t svnmad_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f64_z)))
+svfloat64_t svnmad_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f32_z)))
+svfloat32_t svnmad_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f16_z)))
+svfloat16_t svnmad_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f64_m)))
+svfloat64_t svnmad_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f32_m)))
+svfloat32_t svnmad_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f16_m)))
+svfloat16_t svnmad_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f64_x)))
+svfloat64_t svnmad_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f32_x)))
+svfloat32_t svnmad_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f16_x)))
+svfloat16_t svnmad_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f64_z)))
+svfloat64_t svnmad_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f32_z)))
+svfloat32_t svnmad_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f16_z)))
+svfloat16_t svnmad_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f64_m)))
+svfloat64_t svnmla_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f32_m)))
+svfloat32_t svnmla_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f16_m)))
+svfloat16_t svnmla_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f64_x)))
+svfloat64_t svnmla_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f32_x)))
+svfloat32_t svnmla_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f16_x)))
+svfloat16_t svnmla_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f64_z)))
+svfloat64_t svnmla_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f32_z)))
+svfloat32_t svnmla_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f16_z)))
+svfloat16_t svnmla_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f64_m)))
+svfloat64_t svnmla_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f32_m)))
+svfloat32_t svnmla_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f16_m)))
+svfloat16_t svnmla_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f64_x)))
+svfloat64_t svnmla_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f32_x)))
+svfloat32_t svnmla_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f16_x)))
+svfloat16_t svnmla_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f64_z)))
+svfloat64_t svnmla_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f32_z)))
+svfloat32_t svnmla_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f16_z)))
+svfloat16_t svnmla_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f64_m)))
+svfloat64_t svnmls_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f32_m)))
+svfloat32_t svnmls_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f16_m)))
+svfloat16_t svnmls_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f64_x)))
+svfloat64_t svnmls_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f32_x)))
+svfloat32_t svnmls_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f16_x)))
+svfloat16_t svnmls_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f64_z)))
+svfloat64_t svnmls_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f32_z)))
+svfloat32_t svnmls_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f16_z)))
+svfloat16_t svnmls_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f64_m)))
+svfloat64_t svnmls_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f32_m)))
+svfloat32_t svnmls_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f16_m)))
+svfloat16_t svnmls_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f64_x)))
+svfloat64_t svnmls_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f32_x)))
+svfloat32_t svnmls_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f16_x)))
+svfloat16_t svnmls_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f64_z)))
+svfloat64_t svnmls_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f32_z)))
+svfloat32_t svnmls_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f16_z)))
+svfloat16_t svnmls_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f64_m)))
+svfloat64_t svnmsb_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f32_m)))
+svfloat32_t svnmsb_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f16_m)))
+svfloat16_t svnmsb_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f64_x)))
+svfloat64_t svnmsb_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f32_x)))
+svfloat32_t svnmsb_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f16_x)))
+svfloat16_t svnmsb_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f64_z)))
+svfloat64_t svnmsb_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f32_z)))
+svfloat32_t svnmsb_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f16_z)))
+svfloat16_t svnmsb_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f64_m)))
+svfloat64_t svnmsb_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f32_m)))
+svfloat32_t svnmsb_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f16_m)))
+svfloat16_t svnmsb_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f64_x)))
+svfloat64_t svnmsb_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f32_x)))
+svfloat32_t svnmsb_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f16_x)))
+svfloat16_t svnmsb_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f64_z)))
+svfloat64_t svnmsb_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f32_z)))
+svfloat32_t svnmsb_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f16_z)))
+svfloat16_t svnmsb_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnor_b_z)))
+svbool_t svnor_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_b_z)))
+svbool_t svnot_z(svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u8_m)))
+svuint8_t svnot_m(svuint8_t, svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u32_m)))
+svuint32_t svnot_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u64_m)))
+svuint64_t svnot_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u16_m)))
+svuint16_t svnot_m(svuint16_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s8_m)))
+svint8_t svnot_m(svint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s32_m)))
+svint32_t svnot_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s64_m)))
+svint64_t svnot_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s16_m)))
+svint16_t svnot_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u8_x)))
+svuint8_t svnot_x(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u32_x)))
+svuint32_t svnot_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u64_x)))
+svuint64_t svnot_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u16_x)))
+svuint16_t svnot_x(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s8_x)))
+svint8_t svnot_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s32_x)))
+svint32_t svnot_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s64_x)))
+svint64_t svnot_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s16_x)))
+svint16_t svnot_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u8_z)))
+svuint8_t svnot_z(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u32_z)))
+svuint32_t svnot_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u64_z)))
+svuint64_t svnot_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u16_z)))
+svuint16_t svnot_z(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s8_z)))
+svint8_t svnot_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s32_z)))
+svint32_t svnot_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s64_z)))
+svint64_t svnot_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s16_z)))
+svint16_t svnot_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorn_b_z)))
+svbool_t svorn_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_b_z)))
+svbool_t svorr_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u8_m)))
+svuint8_t svorr_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u32_m)))
+svuint32_t svorr_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u64_m)))
+svuint64_t svorr_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u16_m)))
+svuint16_t svorr_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s8_m)))
+svint8_t svorr_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s32_m)))
+svint32_t svorr_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s64_m)))
+svint64_t svorr_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s16_m)))
+svint16_t svorr_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u8_x)))
+svuint8_t svorr_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u32_x)))
+svuint32_t svorr_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u64_x)))
+svuint64_t svorr_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u16_x)))
+svuint16_t svorr_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s8_x)))
+svint8_t svorr_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s32_x)))
+svint32_t svorr_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s64_x)))
+svint64_t svorr_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s16_x)))
+svint16_t svorr_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u8_z)))
+svuint8_t svorr_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u32_z)))
+svuint32_t svorr_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u64_z)))
+svuint64_t svorr_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u16_z)))
+svuint16_t svorr_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s8_z)))
+svint8_t svorr_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s32_z)))
+svint32_t svorr_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s64_z)))
+svint64_t svorr_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s16_z)))
+svint16_t svorr_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u8_m)))
+svuint8_t svorr_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u32_m)))
+svuint32_t svorr_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u64_m)))
+svuint64_t svorr_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u16_m)))
+svuint16_t svorr_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s8_m)))
+svint8_t svorr_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s32_m)))
+svint32_t svorr_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s64_m)))
+svint64_t svorr_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s16_m)))
+svint16_t svorr_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u8_x)))
+svuint8_t svorr_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u32_x)))
+svuint32_t svorr_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u64_x)))
+svuint64_t svorr_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u16_x)))
+svuint16_t svorr_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s8_x)))
+svint8_t svorr_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s32_x)))
+svint32_t svorr_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s64_x)))
+svint64_t svorr_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s16_x)))
+svint16_t svorr_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u8_z)))
+svuint8_t svorr_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u32_z)))
+svuint32_t svorr_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u64_z)))
+svuint64_t svorr_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u16_z)))
+svuint16_t svorr_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s8_z)))
+svint8_t svorr_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s32_z)))
+svint32_t svorr_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s64_z)))
+svint64_t svorr_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s16_z)))
+svint16_t svorr_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u8)))
+uint8_t svorv(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u32)))
+uint32_t svorv(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u64)))
+uint64_t svorv(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u16)))
+uint16_t svorv(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s8)))
+int8_t svorv(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s32)))
+int32_t svorv(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s64)))
+int64_t svorv(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s16)))
+int16_t svorv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpfalse_b)))
+svbool_t svpfalse(void);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpfirst_b)))
+svbool_t svpfirst(svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8)))
+svint8_t svqadd(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32)))
+svint32_t svqadd(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64)))
+svint64_t svqadd(svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16)))
+svint16_t svqadd(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8)))
+svuint8_t svqadd(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32)))
+svuint32_t svqadd(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64)))
+svuint64_t svqadd(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16)))
+svuint16_t svqadd(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8)))
+svint8_t svqadd(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32)))
+svint32_t svqadd(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64)))
+svint64_t svqadd(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16)))
+svint16_t svqadd(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8)))
+svuint8_t svqadd(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32)))
+svuint32_t svqadd(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64)))
+svuint64_t svqadd(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16)))
+svuint16_t svqadd(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_s32)))
+int32_t svqdecb(int32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_s64)))
+int64_t svqdecb(int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_u32)))
+uint32_t svqdecb(uint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_u64)))
+uint64_t svqdecb(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_s32)))
+int32_t svqdecb_pat(int32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_s64)))
+int64_t svqdecb_pat(int64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_u32)))
+uint32_t svqdecb_pat(uint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_u64)))
+uint64_t svqdecb_pat(uint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_s32)))
+int32_t svqdecd(int32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_s64)))
+int64_t svqdecd(int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_u32)))
+uint32_t svqdecd(uint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_u64)))
+uint64_t svqdecd(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_s64)))
+svint64_t svqdecd(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_u64)))
+svuint64_t svqdecd(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_s32)))
+int32_t svqdecd_pat(int32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_s64)))
+int64_t svqdecd_pat(int64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_u32)))
+uint32_t svqdecd_pat(uint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_u64)))
+uint64_t svqdecd_pat(uint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_s64)))
+svint64_t svqdecd_pat(svint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_u64)))
+svuint64_t svqdecd_pat(svuint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_s32)))
+int32_t svqdech(int32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_s64)))
+int64_t svqdech(int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_u32)))
+uint32_t svqdech(uint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_u64)))
+uint64_t svqdech(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_s16)))
+svint16_t svqdech(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_u16)))
+svuint16_t svqdech(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_s32)))
+int32_t svqdech_pat(int32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_s64)))
+int64_t svqdech_pat(int64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_u32)))
+uint32_t svqdech_pat(uint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_u64)))
+uint64_t svqdech_pat(uint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_s16)))
+svint16_t svqdech_pat(svint16_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_u16)))
+svuint16_t svqdech_pat(svuint16_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b8)))
+int32_t svqdecp_b8(int32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b32)))
+int32_t svqdecp_b32(int32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b64)))
+int32_t svqdecp_b64(int32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b16)))
+int32_t svqdecp_b16(int32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b8)))
+int64_t svqdecp_b8(int64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b32)))
+int64_t svqdecp_b32(int64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b64)))
+int64_t svqdecp_b64(int64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b16)))
+int64_t svqdecp_b16(int64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b8)))
+uint32_t svqdecp_b8(uint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b32)))
+uint32_t svqdecp_b32(uint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b64)))
+uint32_t svqdecp_b64(uint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b16)))
+uint32_t svqdecp_b16(uint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b8)))
+uint64_t svqdecp_b8(uint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b32)))
+uint64_t svqdecp_b32(uint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b64)))
+uint64_t svqdecp_b64(uint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b16)))
+uint64_t svqdecp_b16(uint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_s32)))
+svint32_t svqdecp(svint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_s64)))
+svint64_t svqdecp(svint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_s16)))
+svint16_t svqdecp(svint16_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_u32)))
+svuint32_t svqdecp(svuint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_u64)))
+svuint64_t svqdecp(svuint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_u16)))
+svuint16_t svqdecp(svuint16_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_s32)))
+int32_t svqdecw(int32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_s64)))
+int64_t svqdecw(int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_u32)))
+uint32_t svqdecw(uint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_u64)))
+uint64_t svqdecw(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_s32)))
+svint32_t svqdecw(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_u32)))
+svuint32_t svqdecw(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_s32)))
+int32_t svqdecw_pat(int32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_s64)))
+int64_t svqdecw_pat(int64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_u32)))
+uint32_t svqdecw_pat(uint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_u64)))
+uint64_t svqdecw_pat(uint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_s32)))
+svint32_t svqdecw_pat(svint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_u32)))
+svuint32_t svqdecw_pat(svuint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_s32)))
+int32_t svqincb(int32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_s64)))
+int64_t svqincb(int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_u32)))
+uint32_t svqincb(uint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_u64)))
+uint64_t svqincb(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_s32)))
+int32_t svqincb_pat(int32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_s64)))
+int64_t svqincb_pat(int64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_u32)))
+uint32_t svqincb_pat(uint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_u64)))
+uint64_t svqincb_pat(uint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_s32)))
+int32_t svqincd(int32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_s64)))
+int64_t svqincd(int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_u32)))
+uint32_t svqincd(uint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_u64)))
+uint64_t svqincd(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_s64)))
+svint64_t svqincd(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_u64)))
+svuint64_t svqincd(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_s32)))
+int32_t svqincd_pat(int32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_s64)))
+int64_t svqincd_pat(int64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_u32)))
+uint32_t svqincd_pat(uint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_u64)))
+uint64_t svqincd_pat(uint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_s64)))
+svint64_t svqincd_pat(svint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_u64)))
+svuint64_t svqincd_pat(svuint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_s32)))
+int32_t svqinch(int32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_s64)))
+int64_t svqinch(int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_u32)))
+uint32_t svqinch(uint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_u64)))
+uint64_t svqinch(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_s16)))
+svint16_t svqinch(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_u16)))
+svuint16_t svqinch(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_s32)))
+int32_t svqinch_pat(int32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_s64)))
+int64_t svqinch_pat(int64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_u32)))
+uint32_t svqinch_pat(uint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_u64)))
+uint64_t svqinch_pat(uint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_s16)))
+svint16_t svqinch_pat(svint16_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_u16)))
+svuint16_t svqinch_pat(svuint16_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b8)))
+int32_t svqincp_b8(int32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b32)))
+int32_t svqincp_b32(int32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b64)))
+int32_t svqincp_b64(int32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b16)))
+int32_t svqincp_b16(int32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b8)))
+int64_t svqincp_b8(int64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b32)))
+int64_t svqincp_b32(int64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b64)))
+int64_t svqincp_b64(int64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b16)))
+int64_t svqincp_b16(int64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b8)))
+uint32_t svqincp_b8(uint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b32)))
+uint32_t svqincp_b32(uint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b64)))
+uint32_t svqincp_b64(uint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b16)))
+uint32_t svqincp_b16(uint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b8)))
+uint64_t svqincp_b8(uint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b32)))
+uint64_t svqincp_b32(uint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b64)))
+uint64_t svqincp_b64(uint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b16)))
+uint64_t svqincp_b16(uint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_s32)))
+svint32_t svqincp(svint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_s64)))
+svint64_t svqincp(svint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_s16)))
+svint16_t svqincp(svint16_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_u32)))
+svuint32_t svqincp(svuint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_u64)))
+svuint64_t svqincp(svuint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_u16)))
+svuint16_t svqincp(svuint16_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_s32)))
+int32_t svqincw(int32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_s64)))
+int64_t svqincw(int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_u32)))
+uint32_t svqincw(uint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_u64)))
+uint64_t svqincw(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_s32)))
+svint32_t svqincw(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_u32)))
+svuint32_t svqincw(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_s32)))
+int32_t svqincw_pat(int32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_s64)))
+int64_t svqincw_pat(int64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_u32)))
+uint32_t svqincw_pat(uint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_u64)))
+uint64_t svqincw_pat(uint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_s32)))
+svint32_t svqincw_pat(svint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_u32)))
+svuint32_t svqincw_pat(svuint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8)))
+svint8_t svqsub(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32)))
+svint32_t svqsub(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64)))
+svint64_t svqsub(svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16)))
+svint16_t svqsub(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8)))
+svuint8_t svqsub(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32)))
+svuint32_t svqsub(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64)))
+svuint64_t svqsub(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16)))
+svuint16_t svqsub(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8)))
+svint8_t svqsub(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32)))
+svint32_t svqsub(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64)))
+svint64_t svqsub(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16)))
+svint16_t svqsub(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8)))
+svuint8_t svqsub(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32)))
+svuint32_t svqsub(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64)))
+svuint64_t svqsub(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16)))
+svuint16_t svqsub(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u8_m)))
+svuint8_t svrbit_m(svuint8_t, svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u32_m)))
+svuint32_t svrbit_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u64_m)))
+svuint64_t svrbit_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u16_m)))
+svuint16_t svrbit_m(svuint16_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s8_m)))
+svint8_t svrbit_m(svint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s32_m)))
+svint32_t svrbit_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s64_m)))
+svint64_t svrbit_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s16_m)))
+svint16_t svrbit_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u8_x)))
+svuint8_t svrbit_x(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u32_x)))
+svuint32_t svrbit_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u64_x)))
+svuint64_t svrbit_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u16_x)))
+svuint16_t svrbit_x(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s8_x)))
+svint8_t svrbit_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s32_x)))
+svint32_t svrbit_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s64_x)))
+svint64_t svrbit_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s16_x)))
+svint16_t svrbit_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u8_z)))
+svuint8_t svrbit_z(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u32_z)))
+svuint32_t svrbit_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u64_z)))
+svuint64_t svrbit_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u16_z)))
+svuint16_t svrbit_z(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s8_z)))
+svint8_t svrbit_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s32_z)))
+svint32_t svrbit_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s64_z)))
+svint64_t svrbit_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s16_z)))
+svint16_t svrbit_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_f64)))
+svfloat64_t svrecpe(svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_f32)))
+svfloat32_t svrecpe(svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_f16)))
+svfloat16_t svrecpe(svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecps_f64)))
+svfloat64_t svrecps(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecps_f32)))
+svfloat32_t svrecps(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecps_f16)))
+svfloat16_t svrecps(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f64_m)))
+svfloat64_t svrecpx_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f32_m)))
+svfloat32_t svrecpx_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f16_m)))
+svfloat16_t svrecpx_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f64_x)))
+svfloat64_t svrecpx_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f32_x)))
+svfloat32_t svrecpx_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f16_x)))
+svfloat16_t svrecpx_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f64_z)))
+svfloat64_t svrecpx_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f32_z)))
+svfloat32_t svrecpx_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f16_z)))
+svfloat16_t svrecpx_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u8)))
+svuint8_t svrev(svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u32)))
+svuint32_t svrev(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u64)))
+svuint64_t svrev(svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u16)))
+svuint16_t svrev(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s8)))
+svint8_t svrev(svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_f64)))
+svfloat64_t svrev(svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_f32)))
+svfloat32_t svrev(svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_f16)))
+svfloat16_t svrev(svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s32)))
+svint32_t svrev(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s64)))
+svint64_t svrev(svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s16)))
+svint16_t svrev(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u32_m)))
+svuint32_t svrevb_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u64_m)))
+svuint64_t svrevb_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u16_m)))
+svuint16_t svrevb_m(svuint16_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s32_m)))
+svint32_t svrevb_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s64_m)))
+svint64_t svrevb_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s16_m)))
+svint16_t svrevb_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u32_x)))
+svuint32_t svrevb_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u64_x)))
+svuint64_t svrevb_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u16_x)))
+svuint16_t svrevb_x(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s32_x)))
+svint32_t svrevb_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s64_x)))
+svint64_t svrevb_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s16_x)))
+svint16_t svrevb_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u32_z)))
+svuint32_t svrevb_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u64_z)))
+svuint64_t svrevb_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u16_z)))
+svuint16_t svrevb_z(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s32_z)))
+svint32_t svrevb_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s64_z)))
+svint64_t svrevb_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s16_z)))
+svint16_t svrevb_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_m)))
+svuint32_t svrevh_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u64_m)))
+svuint64_t svrevh_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s32_m)))
+svint32_t svrevh_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s64_m)))
+svint64_t svrevh_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_x)))
+svuint32_t svrevh_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u64_x)))
+svuint64_t svrevh_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s32_x)))
+svint32_t svrevh_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s64_x)))
+svint64_t svrevh_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_z)))
+svuint32_t svrevh_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u64_z)))
+svuint64_t svrevh_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s32_z)))
+svint32_t svrevh_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s64_z)))
+svint64_t svrevh_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_m)))
+svuint64_t svrevw_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_s64_m)))
+svint64_t svrevw_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_x)))
+svuint64_t svrevw_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_s64_x)))
+svint64_t svrevw_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_z)))
+svuint64_t svrevw_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_s64_z)))
+svint64_t svrevw_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f64_m)))
+svfloat64_t svrinta_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_m)))
+svfloat32_t svrinta_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f16_m)))
+svfloat16_t svrinta_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f64_x)))
+svfloat64_t svrinta_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_x)))
+svfloat32_t svrinta_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f16_x)))
+svfloat16_t svrinta_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f64_z)))
+svfloat64_t svrinta_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_z)))
+svfloat32_t svrinta_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f16_z)))
+svfloat16_t svrinta_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f64_m)))
+svfloat64_t svrinti_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f32_m)))
+svfloat32_t svrinti_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f16_m)))
+svfloat16_t svrinti_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f64_x)))
+svfloat64_t svrinti_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f32_x)))
+svfloat32_t svrinti_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f16_x)))
+svfloat16_t svrinti_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f64_z)))
+svfloat64_t svrinti_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f32_z)))
+svfloat32_t svrinti_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f16_z)))
+svfloat16_t svrinti_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f64_m)))
+svfloat64_t svrintm_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_m)))
+svfloat32_t svrintm_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f16_m)))
+svfloat16_t svrintm_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f64_x)))
+svfloat64_t svrintm_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_x)))
+svfloat32_t svrintm_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f16_x)))
+svfloat16_t svrintm_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f64_z)))
+svfloat64_t svrintm_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_z)))
+svfloat32_t svrintm_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f16_z)))
+svfloat16_t svrintm_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f64_m)))
+svfloat64_t svrintn_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_m)))
+svfloat32_t svrintn_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f16_m)))
+svfloat16_t svrintn_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f64_x)))
+svfloat64_t svrintn_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_x)))
+svfloat32_t svrintn_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f16_x)))
+svfloat16_t svrintn_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f64_z)))
+svfloat64_t svrintn_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_z)))
+svfloat32_t svrintn_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f16_z)))
+svfloat16_t svrintn_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f64_m)))
+svfloat64_t svrintp_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_m)))
+svfloat32_t svrintp_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f16_m)))
+svfloat16_t svrintp_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f64_x)))
+svfloat64_t svrintp_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_x)))
+svfloat32_t svrintp_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f16_x)))
+svfloat16_t svrintp_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f64_z)))
+svfloat64_t svrintp_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_z)))
+svfloat32_t svrintp_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f16_z)))
+svfloat16_t svrintp_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f64_m)))
+svfloat64_t svrintx_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f32_m)))
+svfloat32_t svrintx_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f16_m)))
+svfloat16_t svrintx_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f64_x)))
+svfloat64_t svrintx_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f32_x)))
+svfloat32_t svrintx_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f16_x)))
+svfloat16_t svrintx_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f64_z)))
+svfloat64_t svrintx_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f32_z)))
+svfloat32_t svrintx_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f16_z)))
+svfloat16_t svrintx_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f64_m)))
+svfloat64_t svrintz_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f32_m)))
+svfloat32_t svrintz_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f16_m)))
+svfloat16_t svrintz_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f64_x)))
+svfloat64_t svrintz_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f32_x)))
+svfloat32_t svrintz_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f16_x)))
+svfloat16_t svrintz_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f64_z)))
+svfloat64_t svrintz_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f32_z)))
+svfloat32_t svrintz_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f16_z)))
+svfloat16_t svrintz_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_f64)))
+svfloat64_t svrsqrte(svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_f32)))
+svfloat32_t svrsqrte(svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_f16)))
+svfloat16_t svrsqrte(svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrts_f64)))
+svfloat64_t svrsqrts(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrts_f32)))
+svfloat32_t svrsqrts(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrts_f16)))
+svfloat16_t svrsqrts(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f64_m)))
+svfloat64_t svscale_m(svbool_t, svfloat64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f32_m)))
+svfloat32_t svscale_m(svbool_t, svfloat32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f16_m)))
+svfloat16_t svscale_m(svbool_t, svfloat16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f64_x)))
+svfloat64_t svscale_x(svbool_t, svfloat64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f32_x)))
+svfloat32_t svscale_x(svbool_t, svfloat32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f16_x)))
+svfloat16_t svscale_x(svbool_t, svfloat16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f64_z)))
+svfloat64_t svscale_z(svbool_t, svfloat64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f32_z)))
+svfloat32_t svscale_z(svbool_t, svfloat32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f16_z)))
+svfloat16_t svscale_z(svbool_t, svfloat16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f64_m)))
+svfloat64_t svscale_m(svbool_t, svfloat64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f32_m)))
+svfloat32_t svscale_m(svbool_t, svfloat32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f16_m)))
+svfloat16_t svscale_m(svbool_t, svfloat16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f64_x)))
+svfloat64_t svscale_x(svbool_t, svfloat64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f32_x)))
+svfloat32_t svscale_x(svbool_t, svfloat32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f16_x)))
+svfloat16_t svscale_x(svbool_t, svfloat16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f64_z)))
+svfloat64_t svscale_z(svbool_t, svfloat64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f32_z)))
+svfloat32_t svscale_z(svbool_t, svfloat32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f16_z)))
+svfloat16_t svscale_z(svbool_t, svfloat16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_b)))
+svbool_t svsel(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8)))
+svuint8_t svsel(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u32)))
+svuint32_t svsel(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u64)))
+svuint64_t svsel(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u16)))
+svuint16_t svsel(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s8)))
+svint8_t svsel(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f64)))
+svfloat64_t svsel(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f32)))
+svfloat32_t svsel(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16)))
+svfloat16_t svsel(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s32)))
+svint32_t svsel(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s64)))
+svint64_t svsel(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s16)))
+svint16_t svsel(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u8)))
+svuint8x2_t svset2(svuint8x2_t, uint64_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u32)))
+svuint32x2_t svset2(svuint32x2_t, uint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u64)))
+svuint64x2_t svset2(svuint64x2_t, uint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u16)))
+svuint16x2_t svset2(svuint16x2_t, uint64_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s8)))
+svint8x2_t svset2(svint8x2_t, uint64_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_f64)))
+svfloat64x2_t svset2(svfloat64x2_t, uint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_f32)))
+svfloat32x2_t svset2(svfloat32x2_t, uint64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_f16)))
+svfloat16x2_t svset2(svfloat16x2_t, uint64_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s32)))
+svint32x2_t svset2(svint32x2_t, uint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s64)))
+svint64x2_t svset2(svint64x2_t, uint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s16)))
+svint16x2_t svset2(svint16x2_t, uint64_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u8)))
+svuint8x3_t svset3(svuint8x3_t, uint64_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u32)))
+svuint32x3_t svset3(svuint32x3_t, uint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u64)))
+svuint64x3_t svset3(svuint64x3_t, uint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u16)))
+svuint16x3_t svset3(svuint16x3_t, uint64_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s8)))
+svint8x3_t svset3(svint8x3_t, uint64_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_f64)))
+svfloat64x3_t svset3(svfloat64x3_t, uint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_f32)))
+svfloat32x3_t svset3(svfloat32x3_t, uint64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_f16)))
+svfloat16x3_t svset3(svfloat16x3_t, uint64_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s32)))
+svint32x3_t svset3(svint32x3_t, uint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s64)))
+svint64x3_t svset3(svint64x3_t, uint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s16)))
+svint16x3_t svset3(svint16x3_t, uint64_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u8)))
+svuint8x4_t svset4(svuint8x4_t, uint64_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u32)))
+svuint32x4_t svset4(svuint32x4_t, uint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u64)))
+svuint64x4_t svset4(svuint64x4_t, uint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u16)))
+svuint16x4_t svset4(svuint16x4_t, uint64_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s8)))
+svint8x4_t svset4(svint8x4_t, uint64_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_f64)))
+svfloat64x4_t svset4(svfloat64x4_t, uint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_f32)))
+svfloat32x4_t svset4(svfloat32x4_t, uint64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_f16)))
+svfloat16x4_t svset4(svfloat16x4_t, uint64_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s32)))
+svint32x4_t svset4(svint32x4_t, uint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s64)))
+svint64x4_t svset4(svint64x4_t, uint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s16)))
+svint16x4_t svset4(svint16x4_t, uint64_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u8)))
+svuint8_t svsplice(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u32)))
+svuint32_t svsplice(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u64)))
+svuint64_t svsplice(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u16)))
+svuint16_t svsplice(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s8)))
+svint8_t svsplice(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_f64)))
+svfloat64_t svsplice(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_f32)))
+svfloat32_t svsplice(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_f16)))
+svfloat16_t svsplice(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s32)))
+svint32_t svsplice(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s64)))
+svint64_t svsplice(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s16)))
+svint16_t svsplice(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f64_m)))
+svfloat64_t svsqrt_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f32_m)))
+svfloat32_t svsqrt_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f16_m)))
+svfloat16_t svsqrt_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f64_x)))
+svfloat64_t svsqrt_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f32_x)))
+svfloat32_t svsqrt_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f16_x)))
+svfloat16_t svsqrt_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f64_z)))
+svfloat64_t svsqrt_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f32_z)))
+svfloat32_t svsqrt_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f16_z)))
+svfloat16_t svsqrt_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u8)))
+void svst1(svbool_t, uint8_t *, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u32)))
+void svst1(svbool_t, uint32_t *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u64)))
+void svst1(svbool_t, uint64_t *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u16)))
+void svst1(svbool_t, uint16_t *, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s8)))
+void svst1(svbool_t, int8_t *, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f64)))
+void svst1(svbool_t, float64_t *, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f32)))
+void svst1(svbool_t, float32_t *, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f16)))
+void svst1(svbool_t, float16_t *, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s32)))
+void svst1(svbool_t, int32_t *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s64)))
+void svst1(svbool_t, int64_t *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s16)))
+void svst1(svbool_t, int16_t *, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u8)))
+void svst1_vnum(svbool_t, uint8_t *, int64_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u32)))
+void svst1_vnum(svbool_t, uint32_t *, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u64)))
+void svst1_vnum(svbool_t, uint64_t *, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u16)))
+void svst1_vnum(svbool_t, uint16_t *, int64_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s8)))
+void svst1_vnum(svbool_t, int8_t *, int64_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f64)))
+void svst1_vnum(svbool_t, float64_t *, int64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f32)))
+void svst1_vnum(svbool_t, float32_t *, int64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f16)))
+void svst1_vnum(svbool_t, float16_t *, int64_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s32)))
+void svst1_vnum(svbool_t, int32_t *, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s64)))
+void svst1_vnum(svbool_t, int64_t *, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s16)))
+void svst1_vnum(svbool_t, int16_t *, int64_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_s32)))
+void svst1b(svbool_t, int8_t *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_s64)))
+void svst1b(svbool_t, int8_t *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_s16)))
+void svst1b(svbool_t, int8_t *, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_u32)))
+void svst1b(svbool_t, uint8_t *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_u64)))
+void svst1b(svbool_t, uint8_t *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_u16)))
+void svst1b(svbool_t, uint8_t *, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_s32)))
+void svst1b_vnum(svbool_t, int8_t *, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_s64)))
+void svst1b_vnum(svbool_t, int8_t *, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_s16)))
+void svst1b_vnum(svbool_t, int8_t *, int64_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_u32)))
+void svst1b_vnum(svbool_t, uint8_t *, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_u64)))
+void svst1b_vnum(svbool_t, uint8_t *, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_u16)))
+void svst1b_vnum(svbool_t, uint8_t *, int64_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_s32)))
+void svst1h(svbool_t, int16_t *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_s64)))
+void svst1h(svbool_t, int16_t *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_u32)))
+void svst1h(svbool_t, uint16_t *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_u64)))
+void svst1h(svbool_t, uint16_t *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_s32)))
+void svst1h_vnum(svbool_t, int16_t *, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_s64)))
+void svst1h_vnum(svbool_t, int16_t *, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_u32)))
+void svst1h_vnum(svbool_t, uint16_t *, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_u64)))
+void svst1h_vnum(svbool_t, uint16_t *, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_s64)))
+void svst1w(svbool_t, int32_t *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_u64)))
+void svst1w(svbool_t, uint32_t *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_vnum_s64)))
+void svst1w_vnum(svbool_t, int32_t *, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_vnum_u64)))
+void svst1w_vnum(svbool_t, uint32_t *, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u8)))
+void svst2(svbool_t, uint8_t *, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u32)))
+void svst2(svbool_t, uint32_t *, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u64)))
+void svst2(svbool_t, uint64_t *, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u16)))
+void svst2(svbool_t, uint16_t *, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s8)))
+void svst2(svbool_t, int8_t *, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_f64)))
+void svst2(svbool_t, float64_t *, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_f32)))
+void svst2(svbool_t, float32_t *, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_f16)))
+void svst2(svbool_t, float16_t *, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s32)))
+void svst2(svbool_t, int32_t *, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s64)))
+void svst2(svbool_t, int64_t *, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s16)))
+void svst2(svbool_t, int16_t *, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u8)))
+void svst2_vnum(svbool_t, uint8_t *, int64_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u32)))
+void svst2_vnum(svbool_t, uint32_t *, int64_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u64)))
+void svst2_vnum(svbool_t, uint64_t *, int64_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u16)))
+void svst2_vnum(svbool_t, uint16_t *, int64_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s8)))
+void svst2_vnum(svbool_t, int8_t *, int64_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_f64)))
+void svst2_vnum(svbool_t, float64_t *, int64_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_f32)))
+void svst2_vnum(svbool_t, float32_t *, int64_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_f16)))
+void svst2_vnum(svbool_t, float16_t *, int64_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s32)))
+void svst2_vnum(svbool_t, int32_t *, int64_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s64)))
+void svst2_vnum(svbool_t, int64_t *, int64_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s16)))
+void svst2_vnum(svbool_t, int16_t *, int64_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u8)))
+void svst3(svbool_t, uint8_t *, svuint8x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u32)))
+void svst3(svbool_t, uint32_t *, svuint32x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u64)))
+void svst3(svbool_t, uint64_t *, svuint64x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u16)))
+void svst3(svbool_t, uint16_t *, svuint16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s8)))
+void svst3(svbool_t, int8_t *, svint8x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_f64)))
+void svst3(svbool_t, float64_t *, svfloat64x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_f32)))
+void svst3(svbool_t, float32_t *, svfloat32x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_f16)))
+void svst3(svbool_t, float16_t *, svfloat16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s32)))
+void svst3(svbool_t, int32_t *, svint32x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s64)))
+void svst3(svbool_t, int64_t *, svint64x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s16)))
+void svst3(svbool_t, int16_t *, svint16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u8)))
+void svst3_vnum(svbool_t, uint8_t *, int64_t, svuint8x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u32)))
+void svst3_vnum(svbool_t, uint32_t *, int64_t, svuint32x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u64)))
+void svst3_vnum(svbool_t, uint64_t *, int64_t, svuint64x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u16)))
+void svst3_vnum(svbool_t, uint16_t *, int64_t, svuint16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s8)))
+void svst3_vnum(svbool_t, int8_t *, int64_t, svint8x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_f64)))
+void svst3_vnum(svbool_t, float64_t *, int64_t, svfloat64x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_f32)))
+void svst3_vnum(svbool_t, float32_t *, int64_t, svfloat32x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_f16)))
+void svst3_vnum(svbool_t, float16_t *, int64_t, svfloat16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s32)))
+void svst3_vnum(svbool_t, int32_t *, int64_t, svint32x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s64)))
+void svst3_vnum(svbool_t, int64_t *, int64_t, svint64x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s16)))
+void svst3_vnum(svbool_t, int16_t *, int64_t, svint16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u8)))
+void svst4(svbool_t, uint8_t *, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u32)))
+void svst4(svbool_t, uint32_t *, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u64)))
+void svst4(svbool_t, uint64_t *, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u16)))
+void svst4(svbool_t, uint16_t *, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s8)))
+void svst4(svbool_t, int8_t *, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_f64)))
+void svst4(svbool_t, float64_t *, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_f32)))
+void svst4(svbool_t, float32_t *, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_f16)))
+void svst4(svbool_t, float16_t *, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s32)))
+void svst4(svbool_t, int32_t *, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s64)))
+void svst4(svbool_t, int64_t *, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s16)))
+void svst4(svbool_t, int16_t *, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u8)))
+void svst4_vnum(svbool_t, uint8_t *, int64_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u32)))
+void svst4_vnum(svbool_t, uint32_t *, int64_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u64)))
+void svst4_vnum(svbool_t, uint64_t *, int64_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u16)))
+void svst4_vnum(svbool_t, uint16_t *, int64_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s8)))
+void svst4_vnum(svbool_t, int8_t *, int64_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_f64)))
+void svst4_vnum(svbool_t, float64_t *, int64_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_f32)))
+void svst4_vnum(svbool_t, float32_t *, int64_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_f16)))
+void svst4_vnum(svbool_t, float16_t *, int64_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s32)))
+void svst4_vnum(svbool_t, int32_t *, int64_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s64)))
+void svst4_vnum(svbool_t, int64_t *, int64_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s16)))
+void svst4_vnum(svbool_t, int16_t *, int64_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u8)))
+void svstnt1(svbool_t, uint8_t *, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u32)))
+void svstnt1(svbool_t, uint32_t *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u64)))
+void svstnt1(svbool_t, uint64_t *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u16)))
+void svstnt1(svbool_t, uint16_t *, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s8)))
+void svstnt1(svbool_t, int8_t *, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f64)))
+void svstnt1(svbool_t, float64_t *, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f32)))
+void svstnt1(svbool_t, float32_t *, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f16)))
+void svstnt1(svbool_t, float16_t *, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s32)))
+void svstnt1(svbool_t, int32_t *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s64)))
+void svstnt1(svbool_t, int64_t *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s16)))
+void svstnt1(svbool_t, int16_t *, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u8)))
+void svstnt1_vnum(svbool_t, uint8_t *, int64_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u32)))
+void svstnt1_vnum(svbool_t, uint32_t *, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u64)))
+void svstnt1_vnum(svbool_t, uint64_t *, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u16)))
+void svstnt1_vnum(svbool_t, uint16_t *, int64_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s8)))
+void svstnt1_vnum(svbool_t, int8_t *, int64_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f64)))
+void svstnt1_vnum(svbool_t, float64_t *, int64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f32)))
+void svstnt1_vnum(svbool_t, float32_t *, int64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f16)))
+void svstnt1_vnum(svbool_t, float16_t *, int64_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s32)))
+void svstnt1_vnum(svbool_t, int32_t *, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s64)))
+void svstnt1_vnum(svbool_t, int64_t *, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s16)))
+void svstnt1_vnum(svbool_t, int16_t *, int64_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f64_m)))
+svfloat64_t svsub_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f32_m)))
+svfloat32_t svsub_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f16_m)))
+svfloat16_t svsub_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f64_x)))
+svfloat64_t svsub_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f32_x)))
+svfloat32_t svsub_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f16_x)))
+svfloat16_t svsub_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f64_z)))
+svfloat64_t svsub_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f32_z)))
+svfloat32_t svsub_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f16_z)))
+svfloat16_t svsub_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u8_m)))
+svuint8_t svsub_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u32_m)))
+svuint32_t svsub_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u64_m)))
+svuint64_t svsub_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u16_m)))
+svuint16_t svsub_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s8_m)))
+svint8_t svsub_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s32_m)))
+svint32_t svsub_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s64_m)))
+svint64_t svsub_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s16_m)))
+svint16_t svsub_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u8_x)))
+svuint8_t svsub_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u32_x)))
+svuint32_t svsub_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u64_x)))
+svuint64_t svsub_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u16_x)))
+svuint16_t svsub_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s8_x)))
+svint8_t svsub_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s32_x)))
+svint32_t svsub_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s64_x)))
+svint64_t svsub_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s16_x)))
+svint16_t svsub_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u8_z)))
+svuint8_t svsub_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u32_z)))
+svuint32_t svsub_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u64_z)))
+svuint64_t svsub_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u16_z)))
+svuint16_t svsub_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s8_z)))
+svint8_t svsub_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s32_z)))
+svint32_t svsub_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s64_z)))
+svint64_t svsub_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s16_z)))
+svint16_t svsub_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f64_m)))
+svfloat64_t svsub_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f32_m)))
+svfloat32_t svsub_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f16_m)))
+svfloat16_t svsub_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f64_x)))
+svfloat64_t svsub_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f32_x)))
+svfloat32_t svsub_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f16_x)))
+svfloat16_t svsub_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f64_z)))
+svfloat64_t svsub_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f32_z)))
+svfloat32_t svsub_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f16_z)))
+svfloat16_t svsub_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u8_m)))
+svuint8_t svsub_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u32_m)))
+svuint32_t svsub_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u64_m)))
+svuint64_t svsub_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u16_m)))
+svuint16_t svsub_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s8_m)))
+svint8_t svsub_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s32_m)))
+svint32_t svsub_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s64_m)))
+svint64_t svsub_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s16_m)))
+svint16_t svsub_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u8_x)))
+svuint8_t svsub_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u32_x)))
+svuint32_t svsub_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u64_x)))
+svuint64_t svsub_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u16_x)))
+svuint16_t svsub_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s8_x)))
+svint8_t svsub_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s32_x)))
+svint32_t svsub_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s64_x)))
+svint64_t svsub_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s16_x)))
+svint16_t svsub_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u8_z)))
+svuint8_t svsub_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u32_z)))
+svuint32_t svsub_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u64_z)))
+svuint64_t svsub_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u16_z)))
+svuint16_t svsub_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s8_z)))
+svint8_t svsub_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s32_z)))
+svint32_t svsub_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s64_z)))
+svint64_t svsub_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s16_z)))
+svint16_t svsub_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f64_m)))
+svfloat64_t svsubr_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f32_m)))
+svfloat32_t svsubr_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f16_m)))
+svfloat16_t svsubr_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f64_x)))
+svfloat64_t svsubr_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f32_x)))
+svfloat32_t svsubr_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f16_x)))
+svfloat16_t svsubr_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f64_z)))
+svfloat64_t svsubr_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f32_z)))
+svfloat32_t svsubr_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f16_z)))
+svfloat16_t svsubr_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u8_m)))
+svuint8_t svsubr_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u32_m)))
+svuint32_t svsubr_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u64_m)))
+svuint64_t svsubr_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u16_m)))
+svuint16_t svsubr_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s8_m)))
+svint8_t svsubr_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s32_m)))
+svint32_t svsubr_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s64_m)))
+svint64_t svsubr_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s16_m)))
+svint16_t svsubr_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u8_x)))
+svuint8_t svsubr_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u32_x)))
+svuint32_t svsubr_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u64_x)))
+svuint64_t svsubr_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u16_x)))
+svuint16_t svsubr_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s8_x)))
+svint8_t svsubr_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s32_x)))
+svint32_t svsubr_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s64_x)))
+svint64_t svsubr_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s16_x)))
+svint16_t svsubr_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u8_z)))
+svuint8_t svsubr_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u32_z)))
+svuint32_t svsubr_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u64_z)))
+svuint64_t svsubr_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u16_z)))
+svuint16_t svsubr_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s8_z)))
+svint8_t svsubr_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s32_z)))
+svint32_t svsubr_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s64_z)))
+svint64_t svsubr_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s16_z)))
+svint16_t svsubr_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f64_m)))
+svfloat64_t svsubr_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f32_m)))
+svfloat32_t svsubr_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f16_m)))
+svfloat16_t svsubr_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f64_x)))
+svfloat64_t svsubr_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f32_x)))
+svfloat32_t svsubr_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f16_x)))
+svfloat16_t svsubr_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f64_z)))
+svfloat64_t svsubr_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f32_z)))
+svfloat32_t svsubr_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f16_z)))
+svfloat16_t svsubr_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u8_m)))
+svuint8_t svsubr_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u32_m)))
+svuint32_t svsubr_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u64_m)))
+svuint64_t svsubr_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u16_m)))
+svuint16_t svsubr_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s8_m)))
+svint8_t svsubr_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s32_m)))
+svint32_t svsubr_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s64_m)))
+svint64_t svsubr_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s16_m)))
+svint16_t svsubr_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u8_x)))
+svuint8_t svsubr_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u32_x)))
+svuint32_t svsubr_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u64_x)))
+svuint64_t svsubr_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u16_x)))
+svuint16_t svsubr_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s8_x)))
+svint8_t svsubr_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s32_x)))
+svint32_t svsubr_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s64_x)))
+svint64_t svsubr_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s16_x)))
+svint16_t svsubr_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u8_z)))
+svuint8_t svsubr_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u32_z)))
+svuint32_t svsubr_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u64_z)))
+svuint64_t svsubr_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u16_z)))
+svuint16_t svsubr_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s8_z)))
+svint8_t svsubr_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s32_z)))
+svint32_t svsubr_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s64_z)))
+svint64_t svsubr_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s16_z)))
+svint16_t svsubr_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u8)))
+svuint8_t svtbl(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u32)))
+svuint32_t svtbl(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u64)))
+svuint64_t svtbl(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u16)))
+svuint16_t svtbl(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s8)))
+svint8_t svtbl(svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_f64)))
+svfloat64_t svtbl(svfloat64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_f32)))
+svfloat32_t svtbl(svfloat32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_f16)))
+svfloat16_t svtbl(svfloat16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s32)))
+svint32_t svtbl(svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s64)))
+svint64_t svtbl(svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s16)))
+svint16_t svtbl(svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u8)))
+svuint8_t svtrn1(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u32)))
+svuint32_t svtrn1(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u64)))
+svuint64_t svtrn1(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u16)))
+svuint16_t svtrn1(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s8)))
+svint8_t svtrn1(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_f64)))
+svfloat64_t svtrn1(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_f32)))
+svfloat32_t svtrn1(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_f16)))
+svfloat16_t svtrn1(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s32)))
+svint32_t svtrn1(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s64)))
+svint64_t svtrn1(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s16)))
+svint16_t svtrn1(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u8)))
+svuint8_t svtrn2(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u32)))
+svuint32_t svtrn2(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u64)))
+svuint64_t svtrn2(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u16)))
+svuint16_t svtrn2(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s8)))
+svint8_t svtrn2(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_f64)))
+svfloat64_t svtrn2(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_f32)))
+svfloat32_t svtrn2(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_f16)))
+svfloat16_t svtrn2(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s32)))
+svint32_t svtrn2(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s64)))
+svint64_t svtrn2(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s16)))
+svint16_t svtrn2(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_b)))
+svbool_t svunpkhi(svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_s32)))
+svint32_t svunpkhi(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_s64)))
+svint64_t svunpkhi(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_s16)))
+svint16_t svunpkhi(svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_u32)))
+svuint32_t svunpkhi(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_u64)))
+svuint64_t svunpkhi(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_u16)))
+svuint16_t svunpkhi(svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_b)))
+svbool_t svunpklo(svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_s32)))
+svint32_t svunpklo(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_s64)))
+svint64_t svunpklo(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_s16)))
+svint16_t svunpklo(svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_u32)))
+svuint32_t svunpklo(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_u64)))
+svuint64_t svunpklo(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_u16)))
+svuint16_t svunpklo(svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u8)))
+svuint8_t svuzp1(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u32)))
+svuint32_t svuzp1(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u64)))
+svuint64_t svuzp1(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u16)))
+svuint16_t svuzp1(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s8)))
+svint8_t svuzp1(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_f64)))
+svfloat64_t svuzp1(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_f32)))
+svfloat32_t svuzp1(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_f16)))
+svfloat16_t svuzp1(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s32)))
+svint32_t svuzp1(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s64)))
+svint64_t svuzp1(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s16)))
+svint16_t svuzp1(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u8)))
+svuint8_t svuzp2(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u32)))
+svuint32_t svuzp2(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u64)))
+svuint64_t svuzp2(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u16)))
+svuint16_t svuzp2(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s8)))
+svint8_t svuzp2(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_f64)))
+svfloat64_t svuzp2(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_f32)))
+svfloat32_t svuzp2(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_f16)))
+svfloat16_t svuzp2(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s32)))
+svint32_t svuzp2(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s64)))
+svint64_t svuzp2(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s16)))
+svint16_t svuzp2(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_s32)))
+svbool_t svwhilele_b8(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_s32)))
+svbool_t svwhilele_b32(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_s32)))
+svbool_t svwhilele_b64(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_s32)))
+svbool_t svwhilele_b16(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_s64)))
+svbool_t svwhilele_b8(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_s64)))
+svbool_t svwhilele_b32(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_s64)))
+svbool_t svwhilele_b64(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_s64)))
+svbool_t svwhilele_b16(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_u32)))
+svbool_t svwhilele_b8(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_u32)))
+svbool_t svwhilele_b32(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_u32)))
+svbool_t svwhilele_b64(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_u32)))
+svbool_t svwhilele_b16(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_u64)))
+svbool_t svwhilele_b8(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_u64)))
+svbool_t svwhilele_b32(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_u64)))
+svbool_t svwhilele_b64(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_u64)))
+svbool_t svwhilele_b16(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_u32)))
+svbool_t svwhilelt_b8(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_u32)))
+svbool_t svwhilelt_b32(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_u32)))
+svbool_t svwhilelt_b64(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_u32)))
+svbool_t svwhilelt_b16(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_u64)))
+svbool_t svwhilelt_b8(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_u64)))
+svbool_t svwhilelt_b32(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_u64)))
+svbool_t svwhilelt_b64(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_u64)))
+svbool_t svwhilelt_b16(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_s32)))
+svbool_t svwhilelt_b8(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_s32)))
+svbool_t svwhilelt_b32(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_s32)))
+svbool_t svwhilelt_b64(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_s32)))
+svbool_t svwhilelt_b16(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_s64)))
+svbool_t svwhilelt_b8(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_s64)))
+svbool_t svwhilelt_b32(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_s64)))
+svbool_t svwhilelt_b64(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_s64)))
+svbool_t svwhilelt_b16(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u8)))
+svuint8_t svzip1(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u32)))
+svuint32_t svzip1(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u64)))
+svuint64_t svzip1(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u16)))
+svuint16_t svzip1(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s8)))
+svint8_t svzip1(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_f64)))
+svfloat64_t svzip1(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_f32)))
+svfloat32_t svzip1(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_f16)))
+svfloat16_t svzip1(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s32)))
+svint32_t svzip1(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s64)))
+svint64_t svzip1(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s16)))
+svint16_t svzip1(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u8)))
+svuint8_t svzip2(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u32)))
+svuint32_t svzip2(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u64)))
+svuint64_t svzip2(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u16)))
+svuint16_t svzip2(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s8)))
+svint8_t svzip2(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_f64)))
+svfloat64_t svzip2(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_f32)))
+svfloat32_t svzip2(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_f16)))
+svfloat16_t svzip2(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s32)))
+svint32_t svzip2(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s64)))
+svint64_t svzip2(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s16)))
+svint16_t svzip2(svint16_t, svint16_t);
#define svcvtnt_bf16_x svcvtnt_bf16_m
#define svcvtnt_bf16_f32_x svcvtnt_bf16_f32_m
#define svcvtnt_f16_x svcvtnt_f16_m
diff --git a/lib/include/arm_vector_types.h b/lib/include/arm_vector_types.h
index b0dd66b07f9b..8e79d39a6041 100644
--- a/lib/include/arm_vector_types.h
+++ b/lib/include/arm_vector_types.h
@@ -16,7 +16,7 @@
#define __ARM_NEON_TYPES_H
typedef float float32_t;
typedef __fp16 float16_t;
-#ifdef __aarch64__
+#if defined(__aarch64__) || defined(__arm64ec__)
typedef double float64_t;
#endif
@@ -40,7 +40,7 @@ typedef __attribute__((neon_vector_type(4))) float16_t float16x4_t;
typedef __attribute__((neon_vector_type(8))) float16_t float16x8_t;
typedef __attribute__((neon_vector_type(2))) float32_t float32x2_t;
typedef __attribute__((neon_vector_type(4))) float32_t float32x4_t;
-#ifdef __aarch64__
+#if defined(__aarch64__) || defined(__arm64ec__)
typedef __attribute__((neon_vector_type(1))) float64_t float64x1_t;
typedef __attribute__((neon_vector_type(2))) float64_t float64x2_t;
#endif
@@ -125,7 +125,7 @@ typedef struct float32x4x2_t {
float32x4_t val[2];
} float32x4x2_t;
-#ifdef __aarch64__
+#if defined(__aarch64__) || defined(__arm64ec__)
typedef struct float64x1x2_t {
float64x1_t val[2];
} float64x1x2_t;
@@ -215,7 +215,7 @@ typedef struct float32x4x3_t {
float32x4_t val[3];
} float32x4x3_t;
-#ifdef __aarch64__
+#if defined(__aarch64__) || defined(__arm64ec__)
typedef struct float64x1x3_t {
float64x1_t val[3];
} float64x1x3_t;
@@ -305,7 +305,7 @@ typedef struct float32x4x4_t {
float32x4_t val[4];
} float32x4x4_t;
-#ifdef __aarch64__
+#if defined(__aarch64__) || defined(__arm64ec__)
typedef struct float64x1x4_t {
float64x1_t val[4];
} float64x1x4_t;
diff --git a/lib/include/avx512erintrin.h b/lib/include/avx512erintrin.h
deleted file mode 100644
index 1c5a2d2d208f..000000000000
--- a/lib/include/avx512erintrin.h
+++ /dev/null
@@ -1,271 +0,0 @@
-/*===---- avx512erintrin.h - AVX512ER intrinsics ---------------------------===
- *
- * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
- * See https://llvm.org/LICENSE.txt for license information.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- *
- *===-----------------------------------------------------------------------===
- */
-#ifndef __IMMINTRIN_H
-#error "Never use directly; include instead."
-#endif
-
-#ifndef __AVX512ERINTRIN_H
-#define __AVX512ERINTRIN_H
-
-/* exp2a23 */
-#define _mm512_exp2a23_round_pd(A, R) \
- ((__m512d)__builtin_ia32_exp2pd_mask((__v8df)(__m512d)(A), \
- (__v8df)_mm512_setzero_pd(), \
- (__mmask8)-1, (int)(R)))
-
-#define _mm512_mask_exp2a23_round_pd(S, M, A, R) \
- ((__m512d)__builtin_ia32_exp2pd_mask((__v8df)(__m512d)(A), \
- (__v8df)(__m512d)(S), (__mmask8)(M), \
- (int)(R)))
-
-#define _mm512_maskz_exp2a23_round_pd(M, A, R) \
- ((__m512d)__builtin_ia32_exp2pd_mask((__v8df)(__m512d)(A), \
- (__v8df)_mm512_setzero_pd(), \
- (__mmask8)(M), (int)(R)))
-
-#define _mm512_exp2a23_pd(A) \
- _mm512_exp2a23_round_pd((A), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm512_mask_exp2a23_pd(S, M, A) \
- _mm512_mask_exp2a23_round_pd((S), (M), (A), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm512_maskz_exp2a23_pd(M, A) \
- _mm512_maskz_exp2a23_round_pd((M), (A), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm512_exp2a23_round_ps(A, R) \
- ((__m512)__builtin_ia32_exp2ps_mask((__v16sf)(__m512)(A), \
- (__v16sf)_mm512_setzero_ps(), \
- (__mmask16)-1, (int)(R)))
-
-#define _mm512_mask_exp2a23_round_ps(S, M, A, R) \
- ((__m512)__builtin_ia32_exp2ps_mask((__v16sf)(__m512)(A), \
- (__v16sf)(__m512)(S), (__mmask16)(M), \
- (int)(R)))
-
-#define _mm512_maskz_exp2a23_round_ps(M, A, R) \
- ((__m512)__builtin_ia32_exp2ps_mask((__v16sf)(__m512)(A), \
- (__v16sf)_mm512_setzero_ps(), \
- (__mmask16)(M), (int)(R)))
-
-#define _mm512_exp2a23_ps(A) \
- _mm512_exp2a23_round_ps((A), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm512_mask_exp2a23_ps(S, M, A) \
- _mm512_mask_exp2a23_round_ps((S), (M), (A), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm512_maskz_exp2a23_ps(M, A) \
- _mm512_maskz_exp2a23_round_ps((M), (A), _MM_FROUND_CUR_DIRECTION)
-
-/* rsqrt28 */
-#define _mm512_rsqrt28_round_pd(A, R) \
- ((__m512d)__builtin_ia32_rsqrt28pd_mask((__v8df)(__m512d)(A), \
- (__v8df)_mm512_setzero_pd(), \
- (__mmask8)-1, (int)(R)))
-
-#define _mm512_mask_rsqrt28_round_pd(S, M, A, R) \
- ((__m512d)__builtin_ia32_rsqrt28pd_mask((__v8df)(__m512d)(A), \
- (__v8df)(__m512d)(S), (__mmask8)(M), \
- (int)(R)))
-
-#define _mm512_maskz_rsqrt28_round_pd(M, A, R) \
- ((__m512d)__builtin_ia32_rsqrt28pd_mask((__v8df)(__m512d)(A), \
- (__v8df)_mm512_setzero_pd(), \
- (__mmask8)(M), (int)(R)))
-
-#define _mm512_rsqrt28_pd(A) \
- _mm512_rsqrt28_round_pd((A), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm512_mask_rsqrt28_pd(S, M, A) \
- _mm512_mask_rsqrt28_round_pd((S), (M), (A), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm512_maskz_rsqrt28_pd(M, A) \
- _mm512_maskz_rsqrt28_round_pd((M), (A), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm512_rsqrt28_round_ps(A, R) \
- ((__m512)__builtin_ia32_rsqrt28ps_mask((__v16sf)(__m512)(A), \
- (__v16sf)_mm512_setzero_ps(), \
- (__mmask16)-1, (int)(R)))
-
-#define _mm512_mask_rsqrt28_round_ps(S, M, A, R) \
- ((__m512)__builtin_ia32_rsqrt28ps_mask((__v16sf)(__m512)(A), \
- (__v16sf)(__m512)(S), (__mmask16)(M), \
- (int)(R)))
-
-#define _mm512_maskz_rsqrt28_round_ps(M, A, R) \
- ((__m512)__builtin_ia32_rsqrt28ps_mask((__v16sf)(__m512)(A), \
- (__v16sf)_mm512_setzero_ps(), \
- (__mmask16)(M), (int)(R)))
-
-#define _mm512_rsqrt28_ps(A) \
- _mm512_rsqrt28_round_ps((A), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm512_mask_rsqrt28_ps(S, M, A) \
- _mm512_mask_rsqrt28_round_ps((S), (M), A, _MM_FROUND_CUR_DIRECTION)
-
-#define _mm512_maskz_rsqrt28_ps(M, A) \
- _mm512_maskz_rsqrt28_round_ps((M), (A), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm_rsqrt28_round_ss(A, B, R) \
- ((__m128)__builtin_ia32_rsqrt28ss_round_mask((__v4sf)(__m128)(A), \
- (__v4sf)(__m128)(B), \
- (__v4sf)_mm_setzero_ps(), \
- (__mmask8)-1, (int)(R)))
-
-#define _mm_mask_rsqrt28_round_ss(S, M, A, B, R) \
- ((__m128)__builtin_ia32_rsqrt28ss_round_mask((__v4sf)(__m128)(A), \
- (__v4sf)(__m128)(B), \
- (__v4sf)(__m128)(S), \
- (__mmask8)(M), (int)(R)))
-
-#define _mm_maskz_rsqrt28_round_ss(M, A, B, R) \
- ((__m128)__builtin_ia32_rsqrt28ss_round_mask((__v4sf)(__m128)(A), \
- (__v4sf)(__m128)(B), \
- (__v4sf)_mm_setzero_ps(), \
- (__mmask8)(M), (int)(R)))
-
-#define _mm_rsqrt28_ss(A, B) \
- _mm_rsqrt28_round_ss((A), (B), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm_mask_rsqrt28_ss(S, M, A, B) \
- _mm_mask_rsqrt28_round_ss((S), (M), (A), (B), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm_maskz_rsqrt28_ss(M, A, B) \
- _mm_maskz_rsqrt28_round_ss((M), (A), (B), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm_rsqrt28_round_sd(A, B, R) \
- ((__m128d)__builtin_ia32_rsqrt28sd_round_mask((__v2df)(__m128d)(A), \
- (__v2df)(__m128d)(B), \
- (__v2df)_mm_setzero_pd(), \
- (__mmask8)-1, (int)(R)))
-
-#define _mm_mask_rsqrt28_round_sd(S, M, A, B, R) \
- ((__m128d)__builtin_ia32_rsqrt28sd_round_mask((__v2df)(__m128d)(A), \
- (__v2df)(__m128d)(B), \
- (__v2df)(__m128d)(S), \
- (__mmask8)(M), (int)(R)))
-
-#define _mm_maskz_rsqrt28_round_sd(M, A, B, R) \
- ((__m128d)__builtin_ia32_rsqrt28sd_round_mask((__v2df)(__m128d)(A), \
- (__v2df)(__m128d)(B), \
- (__v2df)_mm_setzero_pd(), \
- (__mmask8)(M), (int)(R)))
-
-#define _mm_rsqrt28_sd(A, B) \
- _mm_rsqrt28_round_sd((A), (B), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm_mask_rsqrt28_sd(S, M, A, B) \
- _mm_mask_rsqrt28_round_sd((S), (M), (A), (B), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm_maskz_rsqrt28_sd(M, A, B) \
- _mm_maskz_rsqrt28_round_sd((M), (A), (B), _MM_FROUND_CUR_DIRECTION)
-
-/* rcp28 */
-#define _mm512_rcp28_round_pd(A, R) \
- ((__m512d)__builtin_ia32_rcp28pd_mask((__v8df)(__m512d)(A), \
- (__v8df)_mm512_setzero_pd(), \
- (__mmask8)-1, (int)(R)))
-
-#define _mm512_mask_rcp28_round_pd(S, M, A, R) \
- ((__m512d)__builtin_ia32_rcp28pd_mask((__v8df)(__m512d)(A), \
- (__v8df)(__m512d)(S), (__mmask8)(M), \
- (int)(R)))
-
-#define _mm512_maskz_rcp28_round_pd(M, A, R) \
- ((__m512d)__builtin_ia32_rcp28pd_mask((__v8df)(__m512d)(A), \
- (__v8df)_mm512_setzero_pd(), \
- (__mmask8)(M), (int)(R)))
-
-#define _mm512_rcp28_pd(A) \
- _mm512_rcp28_round_pd((A), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm512_mask_rcp28_pd(S, M, A) \
- _mm512_mask_rcp28_round_pd((S), (M), (A), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm512_maskz_rcp28_pd(M, A) \
- _mm512_maskz_rcp28_round_pd((M), (A), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm512_rcp28_round_ps(A, R) \
- ((__m512)__builtin_ia32_rcp28ps_mask((__v16sf)(__m512)(A), \
- (__v16sf)_mm512_setzero_ps(), \
- (__mmask16)-1, (int)(R)))
-
-#define _mm512_mask_rcp28_round_ps(S, M, A, R) \
- ((__m512)__builtin_ia32_rcp28ps_mask((__v16sf)(__m512)(A), \
- (__v16sf)(__m512)(S), (__mmask16)(M), \
- (int)(R)))
-
-#define _mm512_maskz_rcp28_round_ps(M, A, R) \
- ((__m512)__builtin_ia32_rcp28ps_mask((__v16sf)(__m512)(A), \
- (__v16sf)_mm512_setzero_ps(), \
- (__mmask16)(M), (int)(R)))
-
-#define _mm512_rcp28_ps(A) \
- _mm512_rcp28_round_ps((A), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm512_mask_rcp28_ps(S, M, A) \
- _mm512_mask_rcp28_round_ps((S), (M), (A), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm512_maskz_rcp28_ps(M, A) \
- _mm512_maskz_rcp28_round_ps((M), (A), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm_rcp28_round_ss(A, B, R) \
- ((__m128)__builtin_ia32_rcp28ss_round_mask((__v4sf)(__m128)(A), \
- (__v4sf)(__m128)(B), \
- (__v4sf)_mm_setzero_ps(), \
- (__mmask8)-1, (int)(R)))
-
-#define _mm_mask_rcp28_round_ss(S, M, A, B, R) \
- ((__m128)__builtin_ia32_rcp28ss_round_mask((__v4sf)(__m128)(A), \
- (__v4sf)(__m128)(B), \
- (__v4sf)(__m128)(S), \
- (__mmask8)(M), (int)(R)))
-
-#define _mm_maskz_rcp28_round_ss(M, A, B, R) \
- ((__m128)__builtin_ia32_rcp28ss_round_mask((__v4sf)(__m128)(A), \
- (__v4sf)(__m128)(B), \
- (__v4sf)_mm_setzero_ps(), \
- (__mmask8)(M), (int)(R)))
-
-#define _mm_rcp28_ss(A, B) \
- _mm_rcp28_round_ss((A), (B), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm_mask_rcp28_ss(S, M, A, B) \
- _mm_mask_rcp28_round_ss((S), (M), (A), (B), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm_maskz_rcp28_ss(M, A, B) \
- _mm_maskz_rcp28_round_ss((M), (A), (B), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm_rcp28_round_sd(A, B, R) \
- ((__m128d)__builtin_ia32_rcp28sd_round_mask((__v2df)(__m128d)(A), \
- (__v2df)(__m128d)(B), \
- (__v2df)_mm_setzero_pd(), \
- (__mmask8)-1, (int)(R)))
-
-#define _mm_mask_rcp28_round_sd(S, M, A, B, R) \
- ((__m128d)__builtin_ia32_rcp28sd_round_mask((__v2df)(__m128d)(A), \
- (__v2df)(__m128d)(B), \
- (__v2df)(__m128d)(S), \
- (__mmask8)(M), (int)(R)))
-
-#define _mm_maskz_rcp28_round_sd(M, A, B, R) \
- ((__m128d)__builtin_ia32_rcp28sd_round_mask((__v2df)(__m128d)(A), \
- (__v2df)(__m128d)(B), \
- (__v2df)_mm_setzero_pd(), \
- (__mmask8)(M), (int)(R)))
-
-#define _mm_rcp28_sd(A, B) \
- _mm_rcp28_round_sd((A), (B), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm_mask_rcp28_sd(S, M, A, B) \
- _mm_mask_rcp28_round_sd((S), (M), (A), (B), _MM_FROUND_CUR_DIRECTION)
-
-#define _mm_maskz_rcp28_sd(M, A, B) \
- _mm_maskz_rcp28_round_sd((M), (A), (B), _MM_FROUND_CUR_DIRECTION)
-
-#endif /* __AVX512ERINTRIN_H */
diff --git a/lib/include/avx512fp16intrin.h b/lib/include/avx512fp16intrin.h
index 4123f10c3951..e136aa14a194 100644
--- a/lib/include/avx512fp16intrin.h
+++ b/lib/include/avx512fp16intrin.h
@@ -96,8 +96,8 @@ _mm512_set_ph(_Float16 __h1, _Float16 __h2, _Float16 __h3, _Float16 __h4,
(h5), (h4), (h3), (h2), (h1))
static __inline __m512h __DEFAULT_FN_ATTRS512
-_mm512_set1_pch(_Float16 _Complex h) {
- return (__m512h)_mm512_set1_ps(__builtin_bit_cast(float, h));
+_mm512_set1_pch(_Float16 _Complex __h) {
+ return (__m512h)_mm512_set1_ps(__builtin_bit_cast(float, __h));
}
static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_castph_ps(__m128h __a) {
@@ -282,75 +282,75 @@ _mm512_zextph256_ph512(__m256h __a) {
#define _mm_comi_sh(A, B, pred) \
_mm_comi_round_sh((A), (B), (pred), _MM_FROUND_CUR_DIRECTION)
-static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comieq_sh(__m128h A,
- __m128h B) {
- return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_EQ_OS,
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comieq_sh(__m128h __A,
+ __m128h __B) {
+ return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_EQ_OS,
_MM_FROUND_CUR_DIRECTION);
}
-static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comilt_sh(__m128h A,
- __m128h B) {
- return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_LT_OS,
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comilt_sh(__m128h __A,
+ __m128h __B) {
+ return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_LT_OS,
_MM_FROUND_CUR_DIRECTION);
}
-static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comile_sh(__m128h A,
- __m128h B) {
- return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_LE_OS,
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comile_sh(__m128h __A,
+ __m128h __B) {
+ return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_LE_OS,
_MM_FROUND_CUR_DIRECTION);
}
-static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comigt_sh(__m128h A,
- __m128h B) {
- return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_GT_OS,
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comigt_sh(__m128h __A,
+ __m128h __B) {
+ return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_GT_OS,
_MM_FROUND_CUR_DIRECTION);
}
-static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comige_sh(__m128h A,
- __m128h B) {
- return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_GE_OS,
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comige_sh(__m128h __A,
+ __m128h __B) {
+ return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_GE_OS,
_MM_FROUND_CUR_DIRECTION);
}
-static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comineq_sh(__m128h A,
- __m128h B) {
- return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_NEQ_US,
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comineq_sh(__m128h __A,
+ __m128h __B) {
+ return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_NEQ_US,
_MM_FROUND_CUR_DIRECTION);
}
-static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomieq_sh(__m128h A,
- __m128h B) {
- return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_EQ_OQ,
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomieq_sh(__m128h __A,
+ __m128h __B) {
+ return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_EQ_OQ,
_MM_FROUND_CUR_DIRECTION);
}
-static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomilt_sh(__m128h A,
- __m128h B) {
- return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_LT_OQ,
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomilt_sh(__m128h __A,
+ __m128h __B) {
+ return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_LT_OQ,
_MM_FROUND_CUR_DIRECTION);
}
-static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomile_sh(__m128h A,
- __m128h B) {
- return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_LE_OQ,
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomile_sh(__m128h __A,
+ __m128h __B) {
+ return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_LE_OQ,
_MM_FROUND_CUR_DIRECTION);
}
-static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomigt_sh(__m128h A,
- __m128h B) {
- return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_GT_OQ,
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomigt_sh(__m128h __A,
+ __m128h __B) {
+ return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_GT_OQ,
_MM_FROUND_CUR_DIRECTION);
}
-static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomige_sh(__m128h A,
- __m128h B) {
- return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_GE_OQ,
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomige_sh(__m128h __A,
+ __m128h __B) {
+ return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_GE_OQ,
_MM_FROUND_CUR_DIRECTION);
}
-static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomineq_sh(__m128h A,
- __m128h B) {
- return __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, _CMP_NEQ_UQ,
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomineq_sh(__m128h __A,
+ __m128h __B) {
+ return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_NEQ_UQ,
_MM_FROUND_CUR_DIRECTION);
}
diff --git a/lib/include/avx512pfintrin.h b/lib/include/avx512pfintrin.h
deleted file mode 100644
index f853be021a2d..000000000000
--- a/lib/include/avx512pfintrin.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/*===------------- avx512pfintrin.h - PF intrinsics ------------------------===
- *
- *
- * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
- * See https://llvm.org/LICENSE.txt for license information.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- *
- *===-----------------------------------------------------------------------===
- */
-#ifndef __IMMINTRIN_H
-#error "Never use directly; include instead."
-#endif
-
-#ifndef __AVX512PFINTRIN_H
-#define __AVX512PFINTRIN_H
-
-#define _mm512_mask_prefetch_i32gather_pd(index, mask, addr, scale, hint) \
- __builtin_ia32_gatherpfdpd((__mmask8)(mask), (__v8si)(__m256i)(index), \
- (void const *)(addr), (int)(scale), \
- (int)(hint))
-
-#define _mm512_prefetch_i32gather_pd(index, addr, scale, hint) \
- __builtin_ia32_gatherpfdpd((__mmask8) -1, (__v8si)(__m256i)(index), \
- (void const *)(addr), (int)(scale), \
- (int)(hint))
-
-#define _mm512_mask_prefetch_i32gather_ps(index, mask, addr, scale, hint) \
- __builtin_ia32_gatherpfdps((__mmask16)(mask), \
- (__v16si)(__m512i)(index), (void const *)(addr), \
- (int)(scale), (int)(hint))
-
-#define _mm512_prefetch_i32gather_ps(index, addr, scale, hint) \
- __builtin_ia32_gatherpfdps((__mmask16) -1, \
- (__v16si)(__m512i)(index), (void const *)(addr), \
- (int)(scale), (int)(hint))
-
-#define _mm512_mask_prefetch_i64gather_pd(index, mask, addr, scale, hint) \
- __builtin_ia32_gatherpfqpd((__mmask8)(mask), (__v8di)(__m512i)(index), \
- (void const *)(addr), (int)(scale), \
- (int)(hint))
-
-#define _mm512_prefetch_i64gather_pd(index, addr, scale, hint) \
- __builtin_ia32_gatherpfqpd((__mmask8) -1, (__v8di)(__m512i)(index), \
- (void const *)(addr), (int)(scale), \
- (int)(hint))
-
-#define _mm512_mask_prefetch_i64gather_ps(index, mask, addr, scale, hint) \
- __builtin_ia32_gatherpfqps((__mmask8)(mask), (__v8di)(__m512i)(index), \
- (void const *)(addr), (int)(scale), (int)(hint))
-
-#define _mm512_prefetch_i64gather_ps(index, addr, scale, hint) \
- __builtin_ia32_gatherpfqps((__mmask8) -1, (__v8di)(__m512i)(index), \
- (void const *)(addr), (int)(scale), (int)(hint))
-
-#define _mm512_prefetch_i32scatter_pd(addr, index, scale, hint) \
- __builtin_ia32_scatterpfdpd((__mmask8)-1, (__v8si)(__m256i)(index), \
- (void *)(addr), (int)(scale), \
- (int)(hint))
-
-#define _mm512_mask_prefetch_i32scatter_pd(addr, mask, index, scale, hint) \
- __builtin_ia32_scatterpfdpd((__mmask8)(mask), (__v8si)(__m256i)(index), \
- (void *)(addr), (int)(scale), \
- (int)(hint))
-
-#define _mm512_prefetch_i32scatter_ps(addr, index, scale, hint) \
- __builtin_ia32_scatterpfdps((__mmask16)-1, (__v16si)(__m512i)(index), \
- (void *)(addr), (int)(scale), (int)(hint))
-
-#define _mm512_mask_prefetch_i32scatter_ps(addr, mask, index, scale, hint) \
- __builtin_ia32_scatterpfdps((__mmask16)(mask), \
- (__v16si)(__m512i)(index), (void *)(addr), \
- (int)(scale), (int)(hint))
-
-#define _mm512_prefetch_i64scatter_pd(addr, index, scale, hint) \
- __builtin_ia32_scatterpfqpd((__mmask8)-1, (__v8di)(__m512i)(index), \
- (void *)(addr), (int)(scale), \
- (int)(hint))
-
-#define _mm512_mask_prefetch_i64scatter_pd(addr, mask, index, scale, hint) \
- __builtin_ia32_scatterpfqpd((__mmask8)(mask), (__v8di)(__m512i)(index), \
- (void *)(addr), (int)(scale), \
- (int)(hint))
-
-#define _mm512_prefetch_i64scatter_ps(addr, index, scale, hint) \
- __builtin_ia32_scatterpfqps((__mmask8)-1, (__v8di)(__m512i)(index), \
- (void *)(addr), (int)(scale), (int)(hint))
-
-#define _mm512_mask_prefetch_i64scatter_ps(addr, mask, index, scale, hint) \
- __builtin_ia32_scatterpfqps((__mmask8)(mask), (__v8di)(__m512i)(index), \
- (void *)(addr), (int)(scale), (int)(hint))
-
-#endif
diff --git a/lib/include/avxintrin.h b/lib/include/avxintrin.h
index f116d8bc3a94..4983f3311370 100644
--- a/lib/include/avxintrin.h
+++ b/lib/include/avxintrin.h
@@ -207,6 +207,8 @@ _mm256_div_ps(__m256 __a, __m256 __b)
/// Compares two 256-bit vectors of [4 x double] and returns the greater
/// of each pair of values.
///
+/// If either value in a comparison is NaN, returns the value from \a __b.
+///
/// \headerfile
///
/// This intrinsic corresponds to the VMAXPD instruction.
@@ -226,6 +228,8 @@ _mm256_max_pd(__m256d __a, __m256d __b)
/// Compares two 256-bit vectors of [8 x float] and returns the greater
/// of each pair of values.
///
+/// If either value in a comparison is NaN, returns the value from \a __b.
+///
/// \headerfile
///
/// This intrinsic corresponds to the VMAXPS instruction.
@@ -245,6 +249,8 @@ _mm256_max_ps(__m256 __a, __m256 __b)
/// Compares two 256-bit vectors of [4 x double] and returns the lesser
/// of each pair of values.
///
+/// If either value in a comparison is NaN, returns the value from \a __b.
+///
/// \headerfile
///
/// This intrinsic corresponds to the VMINPD instruction.
@@ -264,6 +270,8 @@ _mm256_min_pd(__m256d __a, __m256d __b)
/// Compares two 256-bit vectors of [8 x float] and returns the lesser
/// of each pair of values.
///
+/// If either value in a comparison is NaN, returns the value from \a __b.
+///
/// \headerfile
///
/// This intrinsic corresponds to the VMINPS instruction.
@@ -832,6 +840,7 @@ _mm256_permutevar_pd(__m256d __a, __m256i __c)
/// Copies the values stored in a 128-bit vector of [4 x float] as
/// specified by the 128-bit integer vector operand.
+///
/// \headerfile
///
/// This intrinsic corresponds to the VPERMILPS instruction.
@@ -1574,14 +1583,6 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
(__v4df)(__m256d)(b), (int)(mask)))
/* Compare */
-#define _CMP_EQ_OQ 0x00 /* Equal (ordered, non-signaling) */
-#define _CMP_LT_OS 0x01 /* Less-than (ordered, signaling) */
-#define _CMP_LE_OS 0x02 /* Less-than-or-equal (ordered, signaling) */
-#define _CMP_UNORD_Q 0x03 /* Unordered (non-signaling) */
-#define _CMP_NEQ_UQ 0x04 /* Not-equal (unordered, non-signaling) */
-#define _CMP_NLT_US 0x05 /* Not-less-than (unordered, signaling) */
-#define _CMP_NLE_US 0x06 /* Not-less-than-or-equal (unordered, signaling) */
-#define _CMP_ORD_Q 0x07 /* Ordered (non-signaling) */
#define _CMP_EQ_UQ 0x08 /* Equal (unordered, non-signaling) */
#define _CMP_NGE_US 0x09 /* Not-greater-than-or-equal (unordered, signaling) */
#define _CMP_NGT_US 0x0a /* Not-greater-than (unordered, signaling) */
@@ -1607,13 +1608,14 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
#define _CMP_GT_OQ 0x1e /* Greater-than (ordered, non-signaling) */
#define _CMP_TRUE_US 0x1f /* True (unordered, signaling) */
+/* Below intrinsic defined in emmintrin.h can be used for AVX */
/// Compares each of the corresponding double-precision values of two
/// 128-bit vectors of [2 x double], using the operation specified by the
/// immediate integer operand.
///
-/// Returns a [2 x double] vector consisting of two doubles corresponding to
-/// the two comparison results: zero if the comparison is false, and all 1's
-/// if the comparison is true.
+/// Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, comparisons that are ordered
+/// return false, and comparisons that are unordered return true.
///
/// \headerfile
///
@@ -1663,17 +1665,16 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
/// 0x1E: Greater-than (ordered, non-signaling) \n
/// 0x1F: True (unordered, signaling)
/// \returns A 128-bit vector of [2 x double] containing the comparison results.
-#define _mm_cmp_pd(a, b, c) \
- ((__m128d)__builtin_ia32_cmppd((__v2df)(__m128d)(a), \
- (__v2df)(__m128d)(b), (c)))
+/// \fn __m128d _mm_cmp_pd(__m128d a, __m128d b, const int c)
+/* Below intrinsic defined in xmmintrin.h can be used for AVX */
/// Compares each of the corresponding values of two 128-bit vectors of
/// [4 x float], using the operation specified by the immediate integer
/// operand.
///
-/// Returns a [4 x float] vector consisting of four floats corresponding to
-/// the four comparison results: zero if the comparison is false, and all 1's
-/// if the comparison is true.
+/// Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+/// If either value in a comparison is NaN, comparisons that are ordered
+/// return false, and comparisons that are unordered return true.
///
/// \headerfile
///
@@ -1723,17 +1724,15 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
/// 0x1E: Greater-than (ordered, non-signaling) \n
/// 0x1F: True (unordered, signaling)
/// \returns A 128-bit vector of [4 x float] containing the comparison results.
-#define _mm_cmp_ps(a, b, c) \
- ((__m128)__builtin_ia32_cmpps((__v4sf)(__m128)(a), \
- (__v4sf)(__m128)(b), (c)))
+/// \fn __m128 _mm_cmp_ps(__m128 a, __m128 b, const int c)
/// Compares each of the corresponding double-precision values of two
/// 256-bit vectors of [4 x double], using the operation specified by the
/// immediate integer operand.
///
-/// Returns a [4 x double] vector consisting of four doubles corresponding to
-/// the four comparison results: zero if the comparison is false, and all 1's
-/// if the comparison is true.
+/// Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, comparisons that are ordered
+/// return false, and comparisons that are unordered return true.
///
/// \headerfile
///
@@ -1791,9 +1790,9 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
/// [8 x float], using the operation specified by the immediate integer
/// operand.
///
-/// Returns a [8 x float] vector consisting of eight floats corresponding to
-/// the eight comparison results: zero if the comparison is false, and all
-/// 1's if the comparison is true.
+/// Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+/// If either value in a comparison is NaN, comparisons that are ordered
+/// return false, and comparisons that are unordered return true.
///
/// \headerfile
///
@@ -1847,12 +1846,14 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
((__m256)__builtin_ia32_cmpps256((__v8sf)(__m256)(a), \
(__v8sf)(__m256)(b), (c)))
+/* Below intrinsic defined in emmintrin.h can be used for AVX */
/// Compares each of the corresponding scalar double-precision values of
/// two 128-bit vectors of [2 x double], using the operation specified by the
/// immediate integer operand.
///
-/// If the result is true, all 64 bits of the destination vector are set;
-/// otherwise they are cleared.
+/// Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, comparisons that are ordered
+/// return false, and comparisons that are unordered return true.
///
/// \headerfile
///
@@ -1902,16 +1903,16 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
/// 0x1E: Greater-than (ordered, non-signaling) \n
/// 0x1F: True (unordered, signaling)
/// \returns A 128-bit vector of [2 x double] containing the comparison results.
-#define _mm_cmp_sd(a, b, c) \
- ((__m128d)__builtin_ia32_cmpsd((__v2df)(__m128d)(a), \
- (__v2df)(__m128d)(b), (c)))
+/// \fn __m128d _mm_cmp_sd(__m128d a, __m128d b, const int c)
+/* Below intrinsic defined in xmmintrin.h can be used for AVX */
/// Compares each of the corresponding scalar values of two 128-bit
/// vectors of [4 x float], using the operation specified by the immediate
/// integer operand.
///
-/// If the result is true, all 32 bits of the destination vector are set;
-/// otherwise they are cleared.
+/// Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+/// If either value in a comparison is NaN, comparisons that are ordered
+/// return false, and comparisons that are unordered return true.
///
/// \headerfile
///
@@ -1961,9 +1962,7 @@ _mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
/// 0x1E: Greater-than (ordered, non-signaling) \n
/// 0x1F: True (unordered, signaling)
/// \returns A 128-bit vector of [4 x float] containing the comparison results.
-#define _mm_cmp_ss(a, b, c) \
- ((__m128)__builtin_ia32_cmpss((__v4sf)(__m128)(a), \
- (__v4sf)(__m128)(b), (c)))
+/// \fn __m128 _mm_cmp_ss(__m128 a, __m128 b, const int c)
/// Takes a [8 x i32] vector and returns the vector element value
/// indexed by the immediate constant operand.
@@ -2213,6 +2212,10 @@ _mm256_cvtpd_ps(__m256d __a)
/// Converts a vector of [8 x float] into a vector of [8 x i32].
///
+/// If a converted value does not fit in a 32-bit integer, raises a
+/// floating-point invalid exception. If the exception is masked, returns
+/// the most negative integer.
+///
/// \headerfile
///
/// This intrinsic corresponds to the VCVTPS2DQ instruction.
@@ -2242,9 +2245,13 @@ _mm256_cvtps_pd(__m128 __a)
return (__m256d)__builtin_convertvector((__v4sf)__a, __v4df);
}
-/// Converts a 256-bit vector of [4 x double] into a 128-bit vector of [4
-/// x i32], truncating the result by rounding towards zero when it is
-/// inexact.
+/// Converts a 256-bit vector of [4 x double] into four signed truncated
+/// (rounded toward zero) 32-bit integers returned in a 128-bit vector of
+/// [4 x i32].
+///
+/// If a converted value does not fit in a 32-bit integer, raises a
+/// floating-point invalid exception. If the exception is masked, returns
+/// the most negative integer.
///
/// \headerfile
///
@@ -2259,9 +2266,12 @@ _mm256_cvttpd_epi32(__m256d __a)
return (__m128i)__builtin_ia32_cvttpd2dq256((__v4df) __a);
}
-/// Converts a 256-bit vector of [4 x double] into a 128-bit vector of [4
-/// x i32]. When a conversion is inexact, the value returned is rounded
-/// according to the rounding control bits in the MXCSR register.
+/// Converts a 256-bit vector of [4 x double] into a 128-bit vector of
+/// [4 x i32].
+///
+/// If a converted value does not fit in a 32-bit integer, raises a
+/// floating-point invalid exception. If the exception is masked, returns
+/// the most negative integer.
///
/// \headerfile
///
@@ -2276,8 +2286,12 @@ _mm256_cvtpd_epi32(__m256d __a)
return (__m128i)__builtin_ia32_cvtpd2dq256((__v4df) __a);
}
-/// Converts a vector of [8 x float] into a vector of [8 x i32],
-/// truncating the result by rounding towards zero when it is inexact.
+/// Converts a vector of [8 x float] into eight signed truncated (rounded
+/// toward zero) 32-bit integers returned in a vector of [8 x i32].
+///
+/// If a converted value does not fit in a 32-bit integer, raises a
+/// floating-point invalid exception. If the exception is masked, returns
+/// the most negative integer.
///
/// \headerfile
///
diff --git a/lib/include/bmiintrin.h b/lib/include/bmiintrin.h
index d8e57c0cb494..78bffe68e221 100644
--- a/lib/include/bmiintrin.h
+++ b/lib/include/bmiintrin.h
@@ -161,8 +161,7 @@ _mm_tzcnt_64(unsigned long long __X)
#undef __RELAXED_FN_ATTRS
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__BMI__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__BMI__)
/* Define the default attributes for the functions in this file. */
#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("bmi")))
@@ -610,7 +609,6 @@ __blsr_u64(unsigned long long __X)
#undef __DEFAULT_FN_ATTRS
-#endif /* !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) \
- || defined(__BMI__) */
+#endif /* !defined(__SCE__) || __has_feature(modules) || defined(__BMI__) */
#endif /* __BMIINTRIN_H */
diff --git a/lib/include/builtins.h b/lib/include/builtins.h
index 65095861ca9b..1e534e632c8e 100644
--- a/lib/include/builtins.h
+++ b/lib/include/builtins.h
@@ -13,4 +13,7 @@
#ifndef __BUILTINS_H
#define __BUILTINS_H
+#if defined(__MVS__) && __has_include_next()
+#include_next
+#endif /* __MVS__ */
#endif /* __BUILTINS_H */
diff --git a/lib/include/cpuid.h b/lib/include/cpuid.h
index 1ad6853a97c9..82d995f1b966 100644
--- a/lib/include/cpuid.h
+++ b/lib/include/cpuid.h
@@ -10,7 +10,7 @@
#ifndef __CPUID_H
#define __CPUID_H
-#if !(__x86_64__ || __i386__)
+#if !defined(__x86_64__) && !defined(__i386__)
#error this header is for x86 only
#endif
@@ -200,6 +200,9 @@
#define bit_AMXINT8 0x02000000
/* Features in %eax for leaf 7 sub-leaf 1 */
+#define bit_SHA512 0x00000001
+#define bit_SM3 0x00000002
+#define bit_SM4 0x00000004
#define bit_RAOINT 0x00000008
#define bit_AVXVNNI 0x00000010
#define bit_AVX512BF16 0x00000020
@@ -211,7 +214,12 @@
/* Features in %edx for leaf 7 sub-leaf 1 */
#define bit_AVXVNNIINT8 0x00000010
#define bit_AVXNECONVERT 0x00000020
+#define bit_AMXCOMPLEX 0x00000100
+#define bit_AVXVNNIINT16 0x00000400
#define bit_PREFETCHI 0x00004000
+#define bit_USERMSR 0x00008000
+#define bit_AVX10 0x00080000
+#define bit_APXF 0x00200000
/* Features in %eax for leaf 13 sub-leaf 1 */
#define bit_XSAVEOPT 0x00000001
@@ -244,8 +252,11 @@
#define bit_RDPRU 0x00000010
#define bit_WBNOINVD 0x00000200
+/* Features in %ebx for leaf 0x24 */
+#define bit_AVX10_256 0x00020000
+#define bit_AVX10_512 0x00040000
-#if __i386__
+#ifdef __i386__
#define __cpuid(__leaf, __eax, __ebx, __ecx, __edx) \
__asm("cpuid" : "=a"(__eax), "=b" (__ebx), "=c"(__ecx), "=d"(__edx) \
: "0"(__leaf))
@@ -274,7 +285,7 @@ static __inline unsigned int __get_cpuid_max (unsigned int __leaf,
unsigned int *__sig)
{
unsigned int __eax, __ebx, __ecx, __edx;
-#if __i386__
+#ifdef __i386__
int __cpuid_supported;
__asm(" pushfl\n"
@@ -328,4 +339,13 @@ static __inline int __get_cpuid_count (unsigned int __leaf,
return 1;
}
+// In some configurations, __cpuidex is defined as a builtin (primarily
+// -fms-extensions) which will conflict with the __cpuidex definition below.
+#if !(__has_builtin(__cpuidex))
+static __inline void __cpuidex(int __cpu_info[4], int __leaf, int __subleaf) {
+ __cpuid_count(__leaf, __subleaf, __cpu_info[0], __cpu_info[1], __cpu_info[2],
+ __cpu_info[3]);
+}
+#endif
+
#endif /* __CPUID_H */
diff --git a/lib/include/cuda_wrappers/algorithm b/lib/include/cuda_wrappers/algorithm
index f14a0b00bb04..3f59f28ae35b 100644
--- a/lib/include/cuda_wrappers/algorithm
+++ b/lib/include/cuda_wrappers/algorithm
@@ -99,7 +99,7 @@ template
__attribute__((enable_if(true, "")))
inline _CPP14_CONSTEXPR __host__ __device__ const __T &
min(const __T &__a, const __T &__b) {
- return __a < __b ? __a : __b;
+ return __b < __a ? __b : __a;
}
#pragma pop_macro("_CPP14_CONSTEXPR")
diff --git a/lib/include/emmintrin.h b/lib/include/emmintrin.h
index 96e3ebdecbdf..4dff6421350c 100644
--- a/lib/include/emmintrin.h
+++ b/lib/include/emmintrin.h
@@ -259,6 +259,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_sqrt_pd(__m128d __a) {
/// result. The upper 64 bits of the result are copied from the upper
/// double-precision value of the first operand.
///
+/// If either value in a comparison is NaN, returns the value from \a __b.
+///
/// \headerfile
///
/// This intrinsic corresponds to the VMINSD / MINSD instruction.
@@ -278,9 +280,11 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_min_sd(__m128d __a,
}
/// Performs element-by-element comparison of the two 128-bit vectors of
-/// [2 x double] and returns the vector containing the lesser of each pair of
+/// [2 x double] and returns a vector containing the lesser of each pair of
/// values.
///
+/// If either value in a comparison is NaN, returns the value from \a __b.
+///
/// \headerfile
///
/// This intrinsic corresponds to the VMINPD / MINPD instruction.
@@ -301,6 +305,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_min_pd(__m128d __a,
/// result. The upper 64 bits of the result are copied from the upper
/// double-precision value of the first operand.
///
+/// If either value in a comparison is NaN, returns the value from \a __b.
+///
/// \headerfile
///
/// This intrinsic corresponds to the VMAXSD / MAXSD instruction.
@@ -320,9 +326,11 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_max_sd(__m128d __a,
}
/// Performs element-by-element comparison of the two 128-bit vectors of
-/// [2 x double] and returns the vector containing the greater of each pair
+/// [2 x double] and returns a vector containing the greater of each pair
/// of values.
///
+/// If either value in a comparison is NaN, returns the value from \a __b.
+///
/// \headerfile
///
/// This intrinsic corresponds to the VMAXPD / MAXPD instruction.
@@ -410,8 +418,10 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_xor_pd(__m128d __a,
}
/// Compares each of the corresponding double-precision values of the
-/// 128-bit vectors of [2 x double] for equality. Each comparison yields 0x0
-/// for false, 0xFFFFFFFFFFFFFFFF for true.
+/// 128-bit vectors of [2 x double] for equality.
+///
+/// Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns false.
///
/// \headerfile
///
@@ -429,8 +439,10 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpeq_pd(__m128d __a,
/// Compares each of the corresponding double-precision values of the
/// 128-bit vectors of [2 x double] to determine if the values in the first
-/// operand are less than those in the second operand. Each comparison
-/// yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// operand are less than those in the second operand.
+///
+/// Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns false.
///
/// \headerfile
///
@@ -450,7 +462,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmplt_pd(__m128d __a,
/// 128-bit vectors of [2 x double] to determine if the values in the first
/// operand are less than or equal to those in the second operand.
///
-/// Each comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns false.
///
/// \headerfile
///
@@ -470,7 +483,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmple_pd(__m128d __a,
/// 128-bit vectors of [2 x double] to determine if the values in the first
/// operand are greater than those in the second operand.
///
-/// Each comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns false.
///
/// \headerfile
///
@@ -490,7 +504,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpgt_pd(__m128d __a,
/// 128-bit vectors of [2 x double] to determine if the values in the first
/// operand are greater than or equal to those in the second operand.
///
-/// Each comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns false.
///
/// \headerfile
///
@@ -510,8 +525,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpge_pd(__m128d __a,
/// 128-bit vectors of [2 x double] to determine if the values in the first
/// operand are ordered with respect to those in the second operand.
///
-/// A pair of double-precision values are "ordered" with respect to each
-/// other if neither value is a NaN. Each comparison yields 0x0 for false,
+/// A pair of double-precision values are ordered with respect to each
+/// other if neither value is a NaN. Each comparison returns 0x0 for false,
/// 0xFFFFFFFFFFFFFFFF for true.
///
/// \headerfile
@@ -532,8 +547,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpord_pd(__m128d __a,
/// 128-bit vectors of [2 x double] to determine if the values in the first
/// operand are unordered with respect to those in the second operand.
///
-/// A pair of double-precision values are "unordered" with respect to each
-/// other if one or both values are NaN. Each comparison yields 0x0 for
+/// A pair of double-precision values are unordered with respect to each
+/// other if one or both values are NaN. Each comparison returns 0x0 for
/// false, 0xFFFFFFFFFFFFFFFF for true.
///
/// \headerfile
@@ -555,7 +570,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpunord_pd(__m128d __a,
/// 128-bit vectors of [2 x double] to determine if the values in the first
/// operand are unequal to those in the second operand.
///
-/// Each comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns true.
///
/// \headerfile
///
@@ -575,7 +591,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpneq_pd(__m128d __a,
/// 128-bit vectors of [2 x double] to determine if the values in the first
/// operand are not less than those in the second operand.
///
-/// Each comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns true.
///
/// \headerfile
///
@@ -595,7 +612,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpnlt_pd(__m128d __a,
/// 128-bit vectors of [2 x double] to determine if the values in the first
/// operand are not less than or equal to those in the second operand.
///
-/// Each comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns true.
///
/// \headerfile
///
@@ -615,7 +633,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpnle_pd(__m128d __a,
/// 128-bit vectors of [2 x double] to determine if the values in the first
/// operand are not greater than those in the second operand.
///
-/// Each comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns true.
///
/// \headerfile
///
@@ -635,7 +654,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpngt_pd(__m128d __a,
/// 128-bit vectors of [2 x double] to determine if the values in the first
/// operand are not greater than or equal to those in the second operand.
///
-/// Each comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns true.
///
/// \headerfile
///
@@ -654,7 +674,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpnge_pd(__m128d __a,
/// Compares the lower double-precision floating-point values in each of
/// the two 128-bit floating-point vectors of [2 x double] for equality.
///
-/// The comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns false.
///
/// \headerfile
///
@@ -678,7 +699,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpeq_sd(__m128d __a,
/// the value in the first parameter is less than the corresponding value in
/// the second parameter.
///
-/// The comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns false.
///
/// \headerfile
///
@@ -702,7 +724,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmplt_sd(__m128d __a,
/// the value in the first parameter is less than or equal to the
/// corresponding value in the second parameter.
///
-/// The comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns false.
///
/// \headerfile
///
@@ -726,7 +749,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmple_sd(__m128d __a,
/// the value in the first parameter is greater than the corresponding value
/// in the second parameter.
///
-/// The comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns false.
///
/// \headerfile
///
@@ -751,7 +775,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpgt_sd(__m128d __a,
/// the value in the first parameter is greater than or equal to the
/// corresponding value in the second parameter.
///
-/// The comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns false.
///
/// \headerfile
///
@@ -773,11 +798,11 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpge_sd(__m128d __a,
/// Compares the lower double-precision floating-point values in each of
/// the two 128-bit floating-point vectors of [2 x double] to determine if
-/// the value in the first parameter is "ordered" with respect to the
+/// the value in the first parameter is ordered with respect to the
/// corresponding value in the second parameter.
///
-/// The comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true. A pair
-/// of double-precision values are "ordered" with respect to each other if
+/// The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true. A pair
+/// of double-precision values are ordered with respect to each other if
/// neither value is a NaN.
///
/// \headerfile
@@ -799,11 +824,11 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpord_sd(__m128d __a,
/// Compares the lower double-precision floating-point values in each of
/// the two 128-bit floating-point vectors of [2 x double] to determine if
-/// the value in the first parameter is "unordered" with respect to the
+/// the value in the first parameter is unordered with respect to the
/// corresponding value in the second parameter.
///
-/// The comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true. A pair
-/// of double-precision values are "unordered" with respect to each other if
+/// The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true. A pair
+/// of double-precision values are unordered with respect to each other if
/// one or both values are NaN.
///
/// \headerfile
@@ -829,7 +854,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpunord_sd(__m128d __a,
/// the value in the first parameter is unequal to the corresponding value in
/// the second parameter.
///
-/// The comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns true.
///
/// \headerfile
///
@@ -853,7 +879,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpneq_sd(__m128d __a,
/// the value in the first parameter is not less than the corresponding
/// value in the second parameter.
///
-/// The comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns true.
///
/// \headerfile
///
@@ -877,7 +904,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpnlt_sd(__m128d __a,
/// the value in the first parameter is not less than or equal to the
/// corresponding value in the second parameter.
///
-/// The comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns true.
///
/// \headerfile
///
@@ -901,7 +929,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpnle_sd(__m128d __a,
/// the value in the first parameter is not greater than the corresponding
/// value in the second parameter.
///
-/// The comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns true.
///
/// \headerfile
///
@@ -926,7 +955,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpngt_sd(__m128d __a,
/// the value in the first parameter is not greater than or equal to the
/// corresponding value in the second parameter.
///
-/// The comparison yields 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, returns true.
///
/// \headerfile
///
@@ -949,8 +979,8 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpnge_sd(__m128d __a,
/// Compares the lower double-precision floating-point values in each of
/// the two 128-bit floating-point vectors of [2 x double] for equality.
///
-/// The comparison yields 0 for false, 1 for true. If either of the two
-/// lower double-precision values is NaN, 0 is returned.
+/// The comparison returns 0 for false, 1 for true. If either value in a
+/// comparison is NaN, returns 0.
///
/// \headerfile
///
@@ -962,8 +992,7 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpnge_sd(__m128d __a,
/// \param __b
/// A 128-bit vector of [2 x double]. The lower double-precision value is
/// compared to the lower double-precision value of \a __a.
-/// \returns An integer containing the comparison results. If either of the two
-/// lower double-precision values is NaN, 0 is returned.
+/// \returns An integer containing the comparison results.
static __inline__ int __DEFAULT_FN_ATTRS _mm_comieq_sd(__m128d __a,
__m128d __b) {
return __builtin_ia32_comisdeq((__v2df)__a, (__v2df)__b);
@@ -974,8 +1003,8 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_comieq_sd(__m128d __a,
/// the value in the first parameter is less than the corresponding value in
/// the second parameter.
///
-/// The comparison yields 0 for false, 1 for true. If either of the two
-/// lower double-precision values is NaN, 0 is returned.
+/// The comparison returns 0 for false, 1 for true. If either value in a
+/// comparison is NaN, returns 0.
///
/// \headerfile
///
@@ -987,8 +1016,7 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_comieq_sd(__m128d __a,
/// \param __b
/// A 128-bit vector of [2 x double]. The lower double-precision value is
/// compared to the lower double-precision value of \a __a.
-/// \returns An integer containing the comparison results. If either of the two
-/// lower double-precision values is NaN, 0 is returned.
+/// \returns An integer containing the comparison results.
static __inline__ int __DEFAULT_FN_ATTRS _mm_comilt_sd(__m128d __a,
__m128d __b) {
return __builtin_ia32_comisdlt((__v2df)__a, (__v2df)__b);
@@ -999,8 +1027,8 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_comilt_sd(__m128d __a,
/// the value in the first parameter is less than or equal to the
/// corresponding value in the second parameter.
///
-/// The comparison yields 0 for false, 1 for true. If either of the two
-/// lower double-precision values is NaN, 0 is returned.
+/// The comparison returns 0 for false, 1 for true. If either value in a
+/// comparison is NaN, returns 0.
///
/// \headerfile
///
@@ -1012,8 +1040,7 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_comilt_sd(__m128d __a,
/// \param __b
/// A 128-bit vector of [2 x double]. The lower double-precision value is
/// compared to the lower double-precision value of \a __a.
-/// \returns An integer containing the comparison results. If either of the two
-/// lower double-precision values is NaN, 0 is returned.
+/// \returns An integer containing the comparison results.
static __inline__ int __DEFAULT_FN_ATTRS _mm_comile_sd(__m128d __a,
__m128d __b) {
return __builtin_ia32_comisdle((__v2df)__a, (__v2df)__b);
@@ -1024,8 +1051,8 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_comile_sd(__m128d __a,
/// the value in the first parameter is greater than the corresponding value
/// in the second parameter.
///
-/// The comparison yields 0 for false, 1 for true. If either of the two
-/// lower double-precision values is NaN, 0 is returned.
+/// The comparison returns 0 for false, 1 for true. If either value in a
+/// comparison is NaN, returns 0.
///
/// \headerfile
///
@@ -1037,8 +1064,7 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_comile_sd(__m128d __a,
/// \param __b
/// A 128-bit vector of [2 x double]. The lower double-precision value is
/// compared to the lower double-precision value of \a __a.
-/// \returns An integer containing the comparison results. If either of the two
-/// lower double-precision values is NaN, 0 is returned.
+/// \returns An integer containing the comparison results.
static __inline__ int __DEFAULT_FN_ATTRS _mm_comigt_sd(__m128d __a,
__m128d __b) {
return __builtin_ia32_comisdgt((__v2df)__a, (__v2df)__b);
@@ -1049,8 +1075,8 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_comigt_sd(__m128d __a,
/// the value in the first parameter is greater than or equal to the
/// corresponding value in the second parameter.
///
-/// The comparison yields 0 for false, 1 for true. If either of the two
-/// lower double-precision values is NaN, 0 is returned.
+/// The comparison returns 0 for false, 1 for true. If either value in a
+/// comparison is NaN, returns 0.
///
/// \headerfile
///
@@ -1062,8 +1088,7 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_comigt_sd(__m128d __a,
/// \param __b
/// A 128-bit vector of [2 x double]. The lower double-precision value is
/// compared to the lower double-precision value of \a __a.
-/// \returns An integer containing the comparison results. If either of the two
-/// lower double-precision values is NaN, 0 is returned.
+/// \returns An integer containing the comparison results.
static __inline__ int __DEFAULT_FN_ATTRS _mm_comige_sd(__m128d __a,
__m128d __b) {
return __builtin_ia32_comisdge((__v2df)__a, (__v2df)__b);
@@ -1074,8 +1099,8 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_comige_sd(__m128d __a,
/// the value in the first parameter is unequal to the corresponding value in
/// the second parameter.
///
-/// The comparison yields 0 for false, 1 for true. If either of the two
-/// lower double-precision values is NaN, 1 is returned.
+/// The comparison returns 0 for false, 1 for true. If either value in a
+/// comparison is NaN, returns 1.
///
/// \headerfile
///
@@ -1087,18 +1112,17 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_comige_sd(__m128d __a,
/// \param __b
/// A 128-bit vector of [2 x double]. The lower double-precision value is
/// compared to the lower double-precision value of \a __a.
-/// \returns An integer containing the comparison results. If either of the two
-/// lower double-precision values is NaN, 1 is returned.
+/// \returns An integer containing the comparison results.
static __inline__ int __DEFAULT_FN_ATTRS _mm_comineq_sd(__m128d __a,
__m128d __b) {
return __builtin_ia32_comisdneq((__v2df)__a, (__v2df)__b);
}
/// Compares the lower double-precision floating-point values in each of
-/// the two 128-bit floating-point vectors of [2 x double] for equality. The
-/// comparison yields 0 for false, 1 for true.
+/// the two 128-bit floating-point vectors of [2 x double] for equality.
///
-/// If either of the two lower double-precision values is NaN, 0 is returned.
+/// The comparison returns 0 for false, 1 for true. If either value in a
+/// comparison is NaN, returns 0.
///
/// \headerfile
///
@@ -1110,8 +1134,7 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_comineq_sd(__m128d __a,
/// \param __b
/// A 128-bit vector of [2 x double]. The lower double-precision value is
/// compared to the lower double-precision value of \a __a.
-/// \returns An integer containing the comparison results. If either of the two
-/// lower double-precision values is NaN, 0 is returned.
+/// \returns An integer containing the comparison results.
static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomieq_sd(__m128d __a,
__m128d __b) {
return __builtin_ia32_ucomisdeq((__v2df)__a, (__v2df)__b);
@@ -1122,8 +1145,8 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomieq_sd(__m128d __a,
/// the value in the first parameter is less than the corresponding value in
/// the second parameter.
///
-/// The comparison yields 0 for false, 1 for true. If either of the two lower
-/// double-precision values is NaN, 0 is returned.
+/// The comparison returns 0 for false, 1 for true. If either value in a
+/// comparison is NaN, returns 0.
///
/// \headerfile
///
@@ -1135,8 +1158,7 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomieq_sd(__m128d __a,
/// \param __b
/// A 128-bit vector of [2 x double]. The lower double-precision value is
/// compared to the lower double-precision value of \a __a.
-/// \returns An integer containing the comparison results. If either of the two
-/// lower double-precision values is NaN, 0 is returned.
+/// \returns An integer containing the comparison results.
static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomilt_sd(__m128d __a,
__m128d __b) {
return __builtin_ia32_ucomisdlt((__v2df)__a, (__v2df)__b);
@@ -1147,8 +1169,8 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomilt_sd(__m128d __a,
/// the value in the first parameter is less than or equal to the
/// corresponding value in the second parameter.
///
-/// The comparison yields 0 for false, 1 for true. If either of the two lower
-/// double-precision values is NaN, 0 is returned.
+/// The comparison returns 0 for false, 1 for true. If either value in a
+/// comparison is NaN, returns 0.
///
/// \headerfile
///
@@ -1160,8 +1182,7 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomilt_sd(__m128d __a,
/// \param __b
/// A 128-bit vector of [2 x double]. The lower double-precision value is
/// compared to the lower double-precision value of \a __a.
-/// \returns An integer containing the comparison results. If either of the two
-/// lower double-precision values is NaN, 0 is returned.
+/// \returns An integer containing the comparison results.
static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomile_sd(__m128d __a,
__m128d __b) {
return __builtin_ia32_ucomisdle((__v2df)__a, (__v2df)__b);
@@ -1172,8 +1193,8 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomile_sd(__m128d __a,
/// the value in the first parameter is greater than the corresponding value
/// in the second parameter.
///
-/// The comparison yields 0 for false, 1 for true. If either of the two lower
-/// double-precision values is NaN, 0 is returned.
+/// The comparison returns 0 for false, 1 for true. If either value in a
+/// comparison is NaN, returns 0.
///
/// \headerfile
///
@@ -1185,8 +1206,7 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomile_sd(__m128d __a,
/// \param __b
/// A 128-bit vector of [2 x double]. The lower double-precision value is
/// compared to the lower double-precision value of \a __a.
-/// \returns An integer containing the comparison results. If either of the two
-/// lower double-precision values is NaN, 0 is returned.
+/// \returns An integer containing the comparison results.
static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomigt_sd(__m128d __a,
__m128d __b) {
return __builtin_ia32_ucomisdgt((__v2df)__a, (__v2df)__b);
@@ -1197,8 +1217,8 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomigt_sd(__m128d __a,
/// the value in the first parameter is greater than or equal to the
/// corresponding value in the second parameter.
///
-/// The comparison yields 0 for false, 1 for true. If either of the two
-/// lower double-precision values is NaN, 0 is returned.
+/// The comparison returns 0 for false, 1 for true. If either value in a
+/// comparison is NaN, returns 0.
///
/// \headerfile
///
@@ -1210,8 +1230,7 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomigt_sd(__m128d __a,
/// \param __b
/// A 128-bit vector of [2 x double]. The lower double-precision value is
/// compared to the lower double-precision value of \a __a.
-/// \returns An integer containing the comparison results. If either of the two
-/// lower double-precision values is NaN, 0 is returned.
+/// \returns An integer containing the comparison results.
static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomige_sd(__m128d __a,
__m128d __b) {
return __builtin_ia32_ucomisdge((__v2df)__a, (__v2df)__b);
@@ -1222,8 +1241,8 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomige_sd(__m128d __a,
/// the value in the first parameter is unequal to the corresponding value in
/// the second parameter.
///
-/// The comparison yields 0 for false, 1 for true. If either of the two lower
-/// double-precision values is NaN, 1 is returned.
+/// The comparison returns 0 for false, 1 for true. If either value in a
+/// comparison is NaN, returns 1.
///
/// \headerfile
///
@@ -1235,8 +1254,7 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomige_sd(__m128d __a,
/// \param __b
/// A 128-bit vector of [2 x double]. The lower double-precision value is
/// compared to the lower double-precision value of \a __a.
-/// \returns An integer containing the comparison result. If either of the two
-/// lower double-precision values is NaN, 1 is returned.
+/// \returns An integer containing the comparison result.
static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomineq_sd(__m128d __a,
__m128d __b) {
return __builtin_ia32_ucomisdneq((__v2df)__a, (__v2df)__b);
@@ -1304,6 +1322,10 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cvtepi32_pd(__m128i __a) {
/// returned in the lower 64 bits of a 128-bit vector of [4 x i32]. The upper
/// 64 bits of the result vector are set to zero.
///
+/// If a converted value does not fit in a 32-bit integer, raises a
+/// floating-point invalid exception. If the exception is masked, returns
+/// the most negative integer.
+///
/// \headerfile
///
/// This intrinsic corresponds to the VCVTPD2DQ / CVTPD2DQ instruction.
@@ -1319,6 +1341,10 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtpd_epi32(__m128d __a) {
/// Converts the low-order element of a 128-bit vector of [2 x double]
/// into a 32-bit signed integer value.
///
+/// If the converted value does not fit in a 32-bit integer, raises a
+/// floating-point invalid exception. If the exception is masked, returns
+/// the most negative integer.
+///
/// \headerfile
///
/// This intrinsic corresponds to the VCVTSD2SI / CVTSD2SI instruction.
@@ -1404,12 +1430,13 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cvtss_sd(__m128d __a,
}
/// Converts the two double-precision floating-point elements of a
-/// 128-bit vector of [2 x double] into two signed 32-bit integer values,
-/// returned in the lower 64 bits of a 128-bit vector of [4 x i32].
+/// 128-bit vector of [2 x double] into two signed truncated (rounded
+/// toward zero) 32-bit integer values, returned in the lower 64 bits
+/// of a 128-bit vector of [4 x i32].
///
-/// If the result of either conversion is inexact, the result is truncated
-/// (rounded towards zero) regardless of the current MXCSR setting. The upper
-/// 64 bits of the result vector are set to zero.
+/// If a converted value does not fit in a 32-bit integer, raises a
+/// floating-point invalid exception. If the exception is masked, returns
+/// the most negative integer.
///
/// \headerfile
///
@@ -1425,7 +1452,11 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvttpd_epi32(__m128d __a) {
}
/// Converts the low-order element of a [2 x double] vector into a 32-bit
-/// signed integer value, truncating the result when it is inexact.
+/// signed truncated (rounded toward zero) integer value.
+///
+/// If the converted value does not fit in a 32-bit integer, raises a
+/// floating-point invalid exception. If the exception is masked, returns
+/// the most negative integer.
///
/// \headerfile
///
@@ -1444,6 +1475,10 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_cvttsd_si32(__m128d __a) {
/// 128-bit vector of [2 x double] into two signed 32-bit integer values,
/// returned in a 64-bit vector of [2 x i32].
///
+/// If a converted value does not fit in a 32-bit integer, raises a
+/// floating-point invalid exception. If the exception is masked, returns
+/// the most negative integer.
+///
/// \headerfile
///
/// This intrinsic corresponds to the CVTPD2PI instruction.
@@ -1456,11 +1491,12 @@ static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX _mm_cvtpd_pi32(__m128d __a) {
}
/// Converts the two double-precision floating-point elements of a
-/// 128-bit vector of [2 x double] into two signed 32-bit integer values,
-/// returned in a 64-bit vector of [2 x i32].
+/// 128-bit vector of [2 x double] into two signed truncated (rounded toward
+/// zero) 32-bit integer values, returned in a 64-bit vector of [2 x i32].
///
-/// If the result of either conversion is inexact, the result is truncated
-/// (rounded towards zero) regardless of the current MXCSR setting.
+/// If a converted value does not fit in a 32-bit integer, raises a
+/// floating-point invalid exception. If the exception is masked, returns
+/// the most negative integer.
///
/// \headerfile
///
@@ -1735,7 +1771,7 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_undefined_pd(void) {
/// lower 64 bits contain the value of the parameter. The upper 64 bits are
/// set to zero.
static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_set_sd(double __w) {
- return __extension__(__m128d){__w, 0};
+ return __extension__(__m128d){__w, 0.0};
}
/// Constructs a 128-bit floating-point vector of [2 x double], with each
@@ -2099,9 +2135,11 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_add_epi64(__m128i __a,
}
/// Adds, with saturation, the corresponding elements of two 128-bit
-/// signed [16 x i8] vectors, saving each sum in the corresponding element of
-/// a 128-bit result vector of [16 x i8]. Positive sums greater than 0x7F are
-/// saturated to 0x7F. Negative sums less than 0x80 are saturated to 0x80.
+/// signed [16 x i8] vectors, saving each sum in the corresponding element
+/// of a 128-bit result vector of [16 x i8].
+///
+/// Positive sums greater than 0x7F are saturated to 0x7F. Negative sums
+/// less than 0x80 are saturated to 0x80.
///
/// \headerfile
///
@@ -2119,10 +2157,11 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_adds_epi8(__m128i __a,
}
/// Adds, with saturation, the corresponding elements of two 128-bit
-/// signed [8 x i16] vectors, saving each sum in the corresponding element of
-/// a 128-bit result vector of [8 x i16]. Positive sums greater than 0x7FFF
-/// are saturated to 0x7FFF. Negative sums less than 0x8000 are saturated to
-/// 0x8000.
+/// signed [8 x i16] vectors, saving each sum in the corresponding element
+/// of a 128-bit result vector of [8 x i16].
+///
+/// Positive sums greater than 0x7FFF are saturated to 0x7FFF. Negative sums
+/// less than 0x8000 are saturated to 0x8000.
///
/// \headerfile
///
@@ -2141,8 +2180,10 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_adds_epi16(__m128i __a,
/// Adds, with saturation, the corresponding elements of two 128-bit
/// unsigned [16 x i8] vectors, saving each sum in the corresponding element
-/// of a 128-bit result vector of [16 x i8]. Positive sums greater than 0xFF
-/// are saturated to 0xFF. Negative sums are saturated to 0x00.
+/// of a 128-bit result vector of [16 x i8].
+///
+/// Positive sums greater than 0xFF are saturated to 0xFF. Negative sums are
+/// saturated to 0x00.
///
/// \headerfile
///
@@ -2161,8 +2202,10 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_adds_epu8(__m128i __a,
/// Adds, with saturation, the corresponding elements of two 128-bit
/// unsigned [8 x i16] vectors, saving each sum in the corresponding element
-/// of a 128-bit result vector of [8 x i16]. Positive sums greater than
-/// 0xFFFF are saturated to 0xFFFF. Negative sums are saturated to 0x0000.
+/// of a 128-bit result vector of [8 x i16].
+///
+/// Positive sums greater than 0xFFFF are saturated to 0xFFFF. Negative sums
+/// are saturated to 0x0000.
///
/// \headerfile
///
@@ -2518,10 +2561,12 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sub_epi64(__m128i __a,
return (__m128i)((__v2du)__a - (__v2du)__b);
}
-/// Subtracts corresponding 8-bit signed integer values in the input and
-/// returns the differences in the corresponding bytes in the destination.
-/// Differences greater than 0x7F are saturated to 0x7F, and differences less
-/// than 0x80 are saturated to 0x80.
+/// Subtracts, with saturation, corresponding 8-bit signed integer values in
+/// the input and returns the differences in the corresponding bytes in the
+/// destination.
+///
+/// Differences greater than 0x7F are saturated to 0x7F, and differences
+/// less than 0x80 are saturated to 0x80.
///
/// \headerfile
///
@@ -2538,8 +2583,10 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_subs_epi8(__m128i __a,
return (__m128i)__builtin_elementwise_sub_sat((__v16qs)__a, (__v16qs)__b);
}
-/// Subtracts corresponding 16-bit signed integer values in the input and
-/// returns the differences in the corresponding bytes in the destination.
+/// Subtracts, with saturation, corresponding 16-bit signed integer values in
+/// the input and returns the differences in the corresponding bytes in the
+/// destination.
+///
/// Differences greater than 0x7FFF are saturated to 0x7FFF, and values less
/// than 0x8000 are saturated to 0x8000.
///
@@ -2558,9 +2605,11 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_subs_epi16(__m128i __a,
return (__m128i)__builtin_elementwise_sub_sat((__v8hi)__a, (__v8hi)__b);
}
-/// Subtracts corresponding 8-bit unsigned integer values in the input
-/// and returns the differences in the corresponding bytes in the
-/// destination. Differences less than 0x00 are saturated to 0x00.
+/// Subtracts, with saturation, corresponding 8-bit unsigned integer values in
+/// the input and returns the differences in the corresponding bytes in the
+/// destination.
+///
+/// Differences less than 0x00 are saturated to 0x00.
///
/// \headerfile
///
@@ -2577,9 +2626,11 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_subs_epu8(__m128i __a,
return (__m128i)__builtin_elementwise_sub_sat((__v16qu)__a, (__v16qu)__b);
}
-/// Subtracts corresponding 16-bit unsigned integer values in the input
-/// and returns the differences in the corresponding bytes in the
-/// destination. Differences less than 0x0000 are saturated to 0x0000.
+/// Subtracts, with saturation, corresponding 16-bit unsigned integer values in
+/// the input and returns the differences in the corresponding bytes in the
+/// destination.
+///
+/// Differences less than 0x0000 are saturated to 0x0000.
///
/// \headerfile
///
@@ -3008,8 +3059,9 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_srl_epi64(__m128i __a,
}
/// Compares each of the corresponding 8-bit values of the 128-bit
-/// integer vectors for equality. Each comparison yields 0x0 for false, 0xFF
-/// for true.
+/// integer vectors for equality.
+///
+/// Each comparison returns 0x0 for false, 0xFF for true.
///
/// \headerfile
///
@@ -3026,8 +3078,9 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpeq_epi8(__m128i __a,
}
/// Compares each of the corresponding 16-bit values of the 128-bit
-/// integer vectors for equality. Each comparison yields 0x0 for false,
-/// 0xFFFF for true.
+/// integer vectors for equality.
+///
+/// Each comparison returns 0x0 for false, 0xFFFF for true.
///
/// \headerfile
///
@@ -3044,8 +3097,9 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpeq_epi16(__m128i __a,
}
/// Compares each of the corresponding 32-bit values of the 128-bit
-/// integer vectors for equality. Each comparison yields 0x0 for false,
-/// 0xFFFFFFFF for true.
+/// integer vectors for equality.
+///
+/// Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
///
/// \headerfile
///
@@ -3063,8 +3117,9 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpeq_epi32(__m128i __a,
/// Compares each of the corresponding signed 8-bit values of the 128-bit
/// integer vectors to determine if the values in the first operand are
-/// greater than those in the second operand. Each comparison yields 0x0 for
-/// false, 0xFF for true.
+/// greater than those in the second operand.
+///
+/// Each comparison returns 0x0 for false, 0xFF for true.
///
/// \headerfile
///
@@ -3086,7 +3141,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpgt_epi8(__m128i __a,
/// 128-bit integer vectors to determine if the values in the first operand
/// are greater than those in the second operand.
///
-/// Each comparison yields 0x0 for false, 0xFFFF for true.
+/// Each comparison returns 0x0 for false, 0xFFFF for true.
///
/// \headerfile
///
@@ -3106,7 +3161,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpgt_epi16(__m128i __a,
/// 128-bit integer vectors to determine if the values in the first operand
/// are greater than those in the second operand.
///
-/// Each comparison yields 0x0 for false, 0xFFFFFFFF for true.
+/// Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
///
/// \headerfile
///
@@ -3126,7 +3181,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpgt_epi32(__m128i __a,
/// integer vectors to determine if the values in the first operand are less
/// than those in the second operand.
///
-/// Each comparison yields 0x0 for false, 0xFF for true.
+/// Each comparison returns 0x0 for false, 0xFF for true.
///
/// \headerfile
///
@@ -3146,7 +3201,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmplt_epi8(__m128i __a,
/// 128-bit integer vectors to determine if the values in the first operand
/// are less than those in the second operand.
///
-/// Each comparison yields 0x0 for false, 0xFFFF for true.
+/// Each comparison returns 0x0 for false, 0xFFFF for true.
///
/// \headerfile
///
@@ -3166,7 +3221,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmplt_epi16(__m128i __a,
/// 128-bit integer vectors to determine if the values in the first operand
/// are less than those in the second operand.
///
-/// Each comparison yields 0x0 for false, 0xFFFFFFFF for true.
+/// Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
///
/// \headerfile
///
@@ -3207,7 +3262,11 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cvtsi64_sd(__m128d __a,
}
/// Converts the first (lower) element of a vector of [2 x double] into a
-/// 64-bit signed integer value, according to the current rounding mode.
+/// 64-bit signed integer value.
+///
+/// If the converted value does not fit in a 64-bit integer, raises a
+/// floating-point invalid exception. If the exception is masked, returns
+/// the most negative integer.
///
/// \headerfile
///
@@ -3222,7 +3281,11 @@ static __inline__ long long __DEFAULT_FN_ATTRS _mm_cvtsd_si64(__m128d __a) {
}
/// Converts the first (lower) element of a vector of [2 x double] into a
-/// 64-bit signed integer value, truncating the result when it is inexact.
+/// 64-bit signed truncated (rounded toward zero) integer value.
+///
+/// If a converted value does not fit in a 64-bit integer, raises a
+/// floating-point invalid exception. If the exception is masked, returns
+/// the most negative integer.
///
/// \headerfile
///
@@ -3253,6 +3316,10 @@ static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cvtepi32_ps(__m128i __a) {
/// Converts a vector of [4 x float] into a vector of [4 x i32].
///
+/// If a converted value does not fit in a 32-bit integer, raises a
+/// floating-point invalid exception. If the exception is masked, returns
+/// the most negative integer.
+///
/// \headerfile
///
/// This intrinsic corresponds to the VCVTPS2DQ / CVTPS2DQ instruction.
@@ -3265,8 +3332,12 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtps_epi32(__m128 __a) {
return (__m128i)__builtin_ia32_cvtps2dq((__v4sf)__a);
}
-/// Converts a vector of [4 x float] into a vector of [4 x i32],
-/// truncating the result when it is inexact.
+/// Converts a vector of [4 x float] into four signed truncated (rounded toward
+/// zero) 32-bit integers, returned in a vector of [4 x i32].
+///
+/// If a converted value does not fit in a 32-bit integer, raises a
+/// floating-point invalid exception. If the exception is masked, returns
+/// the most negative integer.
///
/// \headerfile
///
@@ -4050,26 +4121,22 @@ void _mm_mfence(void);
} // extern "C"
#endif
-/// Converts 16-bit signed integers from both 128-bit integer vector
-/// operands into 8-bit signed integers, and packs the results into the
-/// destination. Positive values greater than 0x7F are saturated to 0x7F.
-/// Negative values less than 0x80 are saturated to 0x80.
+/// Converts, with saturation, 16-bit signed integers from both 128-bit integer
+/// vector operands into 8-bit signed integers, and packs the results into
+/// the destination.
+///
+/// Positive values greater than 0x7F are saturated to 0x7F. Negative values
+/// less than 0x80 are saturated to 0x80.
///
/// \headerfile
///
/// This intrinsic corresponds to the VPACKSSWB / PACKSSWB instruction.
///
/// \param __a
-/// A 128-bit integer vector of [8 x i16]. Each 16-bit element is treated as
-/// a signed integer and is converted to a 8-bit signed integer with
-/// saturation. Values greater than 0x7F are saturated to 0x7F. Values less
-/// than 0x80 are saturated to 0x80. The converted [8 x i8] values are
+/// A 128-bit integer vector of [8 x i16]. The converted [8 x i8] values are
/// written to the lower 64 bits of the result.
/// \param __b
-/// A 128-bit integer vector of [8 x i16]. Each 16-bit element is treated as
-/// a signed integer and is converted to a 8-bit signed integer with
-/// saturation. Values greater than 0x7F are saturated to 0x7F. Values less
-/// than 0x80 are saturated to 0x80. The converted [8 x i8] values are
+/// A 128-bit integer vector of [8 x i16]. The converted [8 x i8] values are
/// written to the higher 64 bits of the result.
/// \returns A 128-bit vector of [16 x i8] containing the converted values.
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_packs_epi16(__m128i __a,
@@ -4077,26 +4144,22 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_packs_epi16(__m128i __a,
return (__m128i)__builtin_ia32_packsswb128((__v8hi)__a, (__v8hi)__b);
}
-/// Converts 32-bit signed integers from both 128-bit integer vector
-/// operands into 16-bit signed integers, and packs the results into the
-/// destination. Positive values greater than 0x7FFF are saturated to 0x7FFF.
-/// Negative values less than 0x8000 are saturated to 0x8000.
+/// Converts, with saturation, 32-bit signed integers from both 128-bit integer
+/// vector operands into 16-bit signed integers, and packs the results into
+/// the destination.
+///
+/// Positive values greater than 0x7FFF are saturated to 0x7FFF. Negative
+/// values less than 0x8000 are saturated to 0x8000.
///
/// \headerfile
///
/// This intrinsic corresponds to the VPACKSSDW / PACKSSDW instruction.
///
/// \param __a
-/// A 128-bit integer vector of [4 x i32]. Each 32-bit element is treated as
-/// a signed integer and is converted to a 16-bit signed integer with
-/// saturation. Values greater than 0x7FFF are saturated to 0x7FFF. Values
-/// less than 0x8000 are saturated to 0x8000. The converted [4 x i16] values
+/// A 128-bit integer vector of [4 x i32]. The converted [4 x i16] values
/// are written to the lower 64 bits of the result.
/// \param __b
-/// A 128-bit integer vector of [4 x i32]. Each 32-bit element is treated as
-/// a signed integer and is converted to a 16-bit signed integer with
-/// saturation. Values greater than 0x7FFF are saturated to 0x7FFF. Values
-/// less than 0x8000 are saturated to 0x8000. The converted [4 x i16] values
+/// A 128-bit integer vector of [4 x i32]. The converted [4 x i16] values
/// are written to the higher 64 bits of the result.
/// \returns A 128-bit vector of [8 x i16] containing the converted values.
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_packs_epi32(__m128i __a,
@@ -4104,26 +4167,22 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_packs_epi32(__m128i __a,
return (__m128i)__builtin_ia32_packssdw128((__v4si)__a, (__v4si)__b);
}
-/// Converts 16-bit signed integers from both 128-bit integer vector
-/// operands into 8-bit unsigned integers, and packs the results into the
-/// destination. Values greater than 0xFF are saturated to 0xFF. Values less
-/// than 0x00 are saturated to 0x00.
+/// Converts, with saturation, 16-bit signed integers from both 128-bit integer
+/// vector operands into 8-bit unsigned integers, and packs the results into
+/// the destination.
+///
+/// Values greater than 0xFF are saturated to 0xFF. Values less than 0x00
+/// are saturated to 0x00.
///
/// \headerfile
///
/// This intrinsic corresponds to the VPACKUSWB / PACKUSWB instruction.
///
/// \param __a
-/// A 128-bit integer vector of [8 x i16]. Each 16-bit element is treated as
-/// a signed integer and is converted to an 8-bit unsigned integer with
-/// saturation. Values greater than 0xFF are saturated to 0xFF. Values less
-/// than 0x00 are saturated to 0x00. The converted [8 x i8] values are
+/// A 128-bit integer vector of [8 x i16]. The converted [8 x i8] values are
/// written to the lower 64 bits of the result.
/// \param __b
-/// A 128-bit integer vector of [8 x i16]. Each 16-bit element is treated as
-/// a signed integer and is converted to an 8-bit unsigned integer with
-/// saturation. Values greater than 0xFF are saturated to 0xFF. Values less
-/// than 0x00 are saturated to 0x00. The converted [8 x i8] values are
+/// A 128-bit integer vector of [8 x i16]. The converted [8 x i8] values are
/// written to the higher 64 bits of the result.
/// \returns A 128-bit vector of [16 x i8] containing the converted values.
static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_packus_epi16(__m128i __a,
@@ -4742,6 +4801,78 @@ static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_castsi128_pd(__m128i __a) {
return (__m128d)__a;
}
+/// Compares each of the corresponding double-precision values of two
+/// 128-bit vectors of [2 x double], using the operation specified by the
+/// immediate integer operand.
+///
+/// Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, comparisons that are ordered
+/// return false, and comparisons that are unordered return true.
+///
+/// \headerfile
+///
+/// \code
+/// __m128d _mm_cmp_pd(__m128d a, __m128d b, const int c);
+/// \endcode
+///
+/// This intrinsic corresponds to the (V)CMPPD instruction.
+///
+/// \param a
+/// A 128-bit vector of [2 x double].
+/// \param b
+/// A 128-bit vector of [2 x double].
+/// \param c
+/// An immediate integer operand, with bits [4:0] specifying which comparison
+/// operation to use: \n
+/// 0x00: Equal (ordered, non-signaling) \n
+/// 0x01: Less-than (ordered, signaling) \n
+/// 0x02: Less-than-or-equal (ordered, signaling) \n
+/// 0x03: Unordered (non-signaling) \n
+/// 0x04: Not-equal (unordered, non-signaling) \n
+/// 0x05: Not-less-than (unordered, signaling) \n
+/// 0x06: Not-less-than-or-equal (unordered, signaling) \n
+/// 0x07: Ordered (non-signaling) \n
+/// \returns A 128-bit vector of [2 x double] containing the comparison results.
+#define _mm_cmp_pd(a, b, c) \
+ ((__m128d)__builtin_ia32_cmppd((__v2df)(__m128d)(a), (__v2df)(__m128d)(b), \
+ (c)))
+
+/// Compares each of the corresponding scalar double-precision values of
+/// two 128-bit vectors of [2 x double], using the operation specified by the
+/// immediate integer operand.
+///
+/// Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+/// If either value in a comparison is NaN, comparisons that are ordered
+/// return false, and comparisons that are unordered return true.
+///
+/// \headerfile
+///
+/// \code
+/// __m128d _mm_cmp_sd(__m128d a, __m128d b, const int c);
+/// \endcode
+///
+/// This intrinsic corresponds to the (V)CMPSD instruction.
+///
+/// \param a
+/// A 128-bit vector of [2 x double].
+/// \param b
+/// A 128-bit vector of [2 x double].
+/// \param c
+/// An immediate integer operand, with bits [4:0] specifying which comparison
+/// operation to use: \n
+/// 0x00: Equal (ordered, non-signaling) \n
+/// 0x01: Less-than (ordered, signaling) \n
+/// 0x02: Less-than-or-equal (ordered, signaling) \n
+/// 0x03: Unordered (non-signaling) \n
+/// 0x04: Not-equal (unordered, non-signaling) \n
+/// 0x05: Not-less-than (unordered, signaling) \n
+/// 0x06: Not-less-than-or-equal (unordered, signaling) \n
+/// 0x07: Ordered (non-signaling) \n
+/// \returns A 128-bit vector of [2 x double] containing the comparison results.
+#define _mm_cmp_sd(a, b, c) \
+ ((__m128d)__builtin_ia32_cmpsd((__v2df)(__m128d)(a), (__v2df)(__m128d)(b), \
+ (c)))
+
#if defined(__cplusplus)
extern "C" {
#endif
diff --git a/lib/include/float.h b/lib/include/float.h
index 0e73bca0a2d6..e5c439a9d47a 100644
--- a/lib/include/float.h
+++ b/lib/include/float.h
@@ -10,6 +10,10 @@
#ifndef __CLANG_FLOAT_H
#define __CLANG_FLOAT_H
+#if defined(__MVS__) && __has_include_next()
+#include_next
+#else
+
/* If we're on MinGW, fall back to the system's float.h, which might have
* additional definitions provided for Windows.
* For more details see http://msdn.microsoft.com/en-us/library/y0ybw9fy.aspx
@@ -82,6 +86,18 @@
# undef DBL_HAS_SUBNORM
# undef LDBL_HAS_SUBNORM
# endif
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L) || \
+ !defined(__STRICT_ANSI__)
+# undef FLT_NORM_MAX
+# undef DBL_NORM_MAX
+# undef LDBL_NORM_MAX
+#endif
+#endif
+
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L) || \
+ !defined(__STRICT_ANSI__)
+# undef INFINITY
+# undef NAN
#endif
/* Characteristics of floating point types, C99 5.2.4.2.2 */
@@ -151,6 +167,17 @@
# define LDBL_HAS_SUBNORM __LDBL_HAS_DENORM__
#endif
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L) || \
+ !defined(__STRICT_ANSI__)
+ /* C23 5.2.5.3.3p29-30 */
+# define INFINITY (__builtin_inff())
+# define NAN (__builtin_nanf(""))
+ /* C23 5.2.5.3.3p32 */
+# define FLT_NORM_MAX __FLT_NORM_MAX__
+# define DBL_NORM_MAX __DBL_NORM_MAX__
+# define LDBL_NORM_MAX __LDBL_NORM_MAX__
+#endif
+
#ifdef __STDC_WANT_IEC_60559_TYPES_EXT__
# define FLT16_MANT_DIG __FLT16_MANT_DIG__
# define FLT16_DECIMAL_DIG __FLT16_DECIMAL_DIG__
@@ -165,4 +192,5 @@
# define FLT16_TRUE_MIN __FLT16_TRUE_MIN__
#endif /* __STDC_WANT_IEC_60559_TYPES_EXT__ */
+#endif /* __MVS__ */
#endif /* __CLANG_FLOAT_H */
diff --git a/lib/include/fmaintrin.h b/lib/include/fmaintrin.h
index ea832fac4f99..22d1a780bbfd 100644
--- a/lib/include/fmaintrin.h
+++ b/lib/include/fmaintrin.h
@@ -60,7 +60,8 @@ _mm_fmadd_pd(__m128d __A, __m128d __B, __m128d __C)
/// Computes a scalar multiply-add of the single-precision values in the
/// low 32 bits of 128-bit vectors of [4 x float].
-/// \code
+///
+/// \code{.operation}
/// result[31:0] = (__A[31:0] * __B[31:0]) + __C[31:0]
/// result[127:32] = __A[127:32]
/// \endcode
@@ -88,7 +89,8 @@ _mm_fmadd_ss(__m128 __A, __m128 __B, __m128 __C)
/// Computes a scalar multiply-add of the double-precision values in the
/// low 64 bits of 128-bit vectors of [2 x double].
-/// \code
+///
+/// \code{.operation}
/// result[63:0] = (__A[63:0] * __B[63:0]) + __C[63:0]
/// result[127:64] = __A[127:64]
/// \endcode
@@ -156,7 +158,8 @@ _mm_fmsub_pd(__m128d __A, __m128d __B, __m128d __C)
/// Computes a scalar multiply-subtract of the single-precision values in
/// the low 32 bits of 128-bit vectors of [4 x float].
-/// \code
+///
+/// \code{.operation}
/// result[31:0] = (__A[31:0] * __B[31:0]) - __C[31:0]
/// result[127:32] = __A[127:32]
/// \endcode
@@ -184,7 +187,8 @@ _mm_fmsub_ss(__m128 __A, __m128 __B, __m128 __C)
/// Computes a scalar multiply-subtract of the double-precision values in
/// the low 64 bits of 128-bit vectors of [2 x double].
-/// \code
+///
+/// \code{.operation}
/// result[63:0] = (__A[63:0] * __B[63:0]) - __C[63:0]
/// result[127:64] = __A[127:64]
/// \endcode
@@ -252,7 +256,8 @@ _mm_fnmadd_pd(__m128d __A, __m128d __B, __m128d __C)
/// Computes a scalar negated multiply-add of the single-precision values in
/// the low 32 bits of 128-bit vectors of [4 x float].
-/// \code
+///
+/// \code{.operation}
/// result[31:0] = -(__A[31:0] * __B[31:0]) + __C[31:0]
/// result[127:32] = __A[127:32]
/// \endcode
@@ -280,7 +285,8 @@ _mm_fnmadd_ss(__m128 __A, __m128 __B, __m128 __C)
/// Computes a scalar negated multiply-add of the double-precision values
/// in the low 64 bits of 128-bit vectors of [2 x double].
-/// \code
+///
+/// \code{.operation}
/// result[63:0] = -(__A[63:0] * __B[63:0]) + __C[63:0]
/// result[127:64] = __A[127:64]
/// \endcode
@@ -348,7 +354,8 @@ _mm_fnmsub_pd(__m128d __A, __m128d __B, __m128d __C)
/// Computes a scalar negated multiply-subtract of the single-precision
/// values in the low 32 bits of 128-bit vectors of [4 x float].
-/// \code
+///
+/// \code{.operation}
/// result[31:0] = -(__A[31:0] * __B[31:0]) - __C[31:0]
/// result[127:32] = __A[127:32]
/// \endcode
@@ -376,7 +383,8 @@ _mm_fnmsub_ss(__m128 __A, __m128 __B, __m128 __C)
/// Computes a scalar negated multiply-subtract of the double-precision
/// values in the low 64 bits of 128-bit vectors of [2 x double].
-/// \code
+///
+/// \code{.operation}
/// result[63:0] = -(__A[63:0] * __B[63:0]) - __C[63:0]
/// result[127:64] = __A[127:64]
/// \endcode
@@ -404,7 +412,8 @@ _mm_fnmsub_sd(__m128d __A, __m128d __B, __m128d __C)
/// Computes a multiply with alternating add/subtract of 128-bit vectors of
/// [4 x float].
-/// \code
+///
+/// \code{.operation}
/// result[31:0] = (__A[31:0] * __B[31:0]) - __C[31:0]
/// result[63:32] = (__A[63:32] * __B[63:32]) + __C[63:32]
/// result[95:64] = (__A[95:64] * __B[95:64]) - __C[95:64]
@@ -430,7 +439,8 @@ _mm_fmaddsub_ps(__m128 __A, __m128 __B, __m128 __C)
/// Computes a multiply with alternating add/subtract of 128-bit vectors of
/// [2 x double].
-/// \code
+///
+/// \code{.operation}
/// result[63:0] = (__A[63:0] * __B[63:0]) - __C[63:0]
/// result[127:64] = (__A[127:64] * __B[127:64]) + __C[127:64]
/// \endcode
@@ -454,7 +464,8 @@ _mm_fmaddsub_pd(__m128d __A, __m128d __B, __m128d __C)
/// Computes a multiply with alternating add/subtract of 128-bit vectors of
/// [4 x float].
-/// \code
+///
+/// \code{.operation}
/// result[31:0] = (__A[31:0] * __B[31:0]) + __C[31:0]
/// result[63:32] = (__A[63:32] * __B[63:32]) - __C[63:32]
/// result[95:64] = (__A[95:64] * __B[95:64]) + __C[95:64]
@@ -480,7 +491,8 @@ _mm_fmsubadd_ps(__m128 __A, __m128 __B, __m128 __C)
/// Computes a multiply with alternating add/subtract of 128-bit vectors of
/// [2 x double].
-/// \code
+///
+/// \code{.operation}
/// result[63:0] = (__A[63:0] * __B[63:0]) + __C[63:0]
/// result[127:64] = (__A[127:64] * __B[127:64]) - __C[127:64]
/// \endcode
@@ -664,7 +676,8 @@ _mm256_fnmsub_pd(__m256d __A, __m256d __B, __m256d __C)
/// Computes a multiply with alternating add/subtract of 256-bit vectors of
/// [8 x float].
-/// \code
+///
+/// \code{.operation}
/// result[31:0] = (__A[31:0] * __B[31:0]) - __C[31:0]
/// result[63:32] = (__A[63:32] * __B[63:32]) + __C[63:32]
/// result[95:64] = (__A[95:64] * __B[95:64]) - __C[95:64]
@@ -694,7 +707,8 @@ _mm256_fmaddsub_ps(__m256 __A, __m256 __B, __m256 __C)
/// Computes a multiply with alternating add/subtract of 256-bit vectors of
/// [4 x double].
-/// \code
+///
+/// \code{.operation}
/// result[63:0] = (__A[63:0] * __B[63:0]) - __C[63:0]
/// result[127:64] = (__A[127:64] * __B[127:64]) + __C[127:64]
/// result[191:128] = (__A[191:128] * __B[191:128]) - __C[191:128]
@@ -720,7 +734,8 @@ _mm256_fmaddsub_pd(__m256d __A, __m256d __B, __m256d __C)
/// Computes a vector multiply with alternating add/subtract of 256-bit
/// vectors of [8 x float].
-/// \code
+///
+/// \code{.operation}
/// result[31:0] = (__A[31:0] * __B[31:0]) + __C[31:0]
/// result[63:32] = (__A[63:32] * __B[63:32]) - __C[63:32]
/// result[95:64] = (__A[95:64] * __B[95:64]) + __C[95:64]
@@ -750,7 +765,8 @@ _mm256_fmsubadd_ps(__m256 __A, __m256 __B, __m256 __C)
/// Computes a vector multiply with alternating add/subtract of 256-bit
/// vectors of [4 x double].
-/// \code
+///
+/// \code{.operation}
/// result[63:0] = (__A[63:0] * __B[63:0]) + __C[63:0]
/// result[127:64] = (__A[127:64] * __B[127:64]) - __C[127:64]
/// result[191:128] = (__A[191:128] * __B[191:128]) + __C[191:128]
diff --git a/lib/include/ia32intrin.h b/lib/include/ia32intrin.h
index 1b979770e196..8e65f232a0de 100644
--- a/lib/include/ia32intrin.h
+++ b/lib/include/ia32intrin.h
@@ -26,8 +26,8 @@
#define __DEFAULT_FN_ATTRS_CONSTEXPR __DEFAULT_FN_ATTRS
#endif
-/// Find the first set bit starting from the lsb. Result is undefined if
-/// input is 0.
+/// Finds the first set bit starting from the least significant bit. The result
+/// is undefined if the input is 0.
///
/// \headerfile
///
@@ -43,8 +43,8 @@ __bsfd(int __A) {
return __builtin_ctz((unsigned int)__A);
}
-/// Find the first set bit starting from the msb. Result is undefined if
-/// input is 0.
+/// Finds the first set bit starting from the most significant bit. The result
+/// is undefined if the input is 0.
///
/// \headerfile
///
@@ -90,8 +90,8 @@ _bswap(int __A) {
return (int)__builtin_bswap32((unsigned int)__A);
}
-/// Find the first set bit starting from the lsb. Result is undefined if
-/// input is 0.
+/// Finds the first set bit starting from the least significant bit. The result
+/// is undefined if the input is 0.
///
/// \headerfile
///
@@ -108,8 +108,8 @@ _bswap(int __A) {
/// \see __bsfd
#define _bit_scan_forward(A) __bsfd((A))
-/// Find the first set bit starting from the msb. Result is undefined if
-/// input is 0.
+/// Finds the first set bit starting from the most significant bit. The result
+/// is undefined if the input is 0.
///
/// \headerfile
///
@@ -127,8 +127,8 @@ _bswap(int __A) {
#define _bit_scan_reverse(A) __bsrd((A))
#ifdef __x86_64__
-/// Find the first set bit starting from the lsb. Result is undefined if
-/// input is 0.
+/// Finds the first set bit starting from the least significant bit. The result
+/// is undefined if the input is 0.
///
/// \headerfile
///
@@ -143,8 +143,8 @@ __bsfq(long long __A) {
return (long long)__builtin_ctzll((unsigned long long)__A);
}
-/// Find the first set bit starting from the msb. Result is undefined if
-/// input is 0.
+/// Finds the first set bit starting from the most significant bit. The result
+/// is undefined if input is 0.
///
/// \headerfile
///
@@ -159,7 +159,7 @@ __bsrq(long long __A) {
return 63 - __builtin_clzll((unsigned long long)__A);
}
-/// Swaps the bytes in the input. Converting little endian to big endian or
+/// Swaps the bytes in the input, converting little endian to big endian or
/// vice versa.
///
/// \headerfile
@@ -175,7 +175,7 @@ __bswapq(long long __A) {
return (long long)__builtin_bswap64((unsigned long long)__A);
}
-/// Swaps the bytes in the input. Converting little endian to big endian or
+/// Swaps the bytes in the input, converting little endian to big endian or
/// vice versa.
///
/// \headerfile
@@ -198,7 +198,7 @@ __bswapq(long long __A) {
/// \headerfile
///
/// This intrinsic corresponds to the \c POPCNT instruction or a
-/// a sequence of arithmetic and logic ops to calculate it.
+/// sequence of arithmetic and logic operations to calculate it.
///
/// \param __A
/// An unsigned 32-bit integer operand.
@@ -220,7 +220,7 @@ __popcntd(unsigned int __A)
/// \endcode
///
/// This intrinsic corresponds to the \c POPCNT instruction or a
-/// a sequence of arithmetic and logic ops to calculate it.
+/// sequence of arithmetic and logic operations to calculate it.
///
/// \param A
/// An unsigned 32-bit integer operand.
@@ -235,7 +235,7 @@ __popcntd(unsigned int __A)
/// \headerfile
///
/// This intrinsic corresponds to the \c POPCNT instruction or a
-/// a sequence of arithmetic and logic ops to calculate it.
+/// sequence of arithmetic and logic operations to calculate it.
///
/// \param __A
/// An unsigned 64-bit integer operand.
@@ -257,7 +257,7 @@ __popcntq(unsigned long long __A)
/// \endcode
///
/// This intrinsic corresponds to the \c POPCNT instruction or a
-/// a sequence of arithmetic and logic ops to calculate it.
+/// sequence of arithmetic and logic operations to calculate it.
///
/// \param A
/// An unsigned 64-bit integer operand.
@@ -268,7 +268,7 @@ __popcntq(unsigned long long __A)
#endif /* __x86_64__ */
#ifdef __x86_64__
-/// Returns the program status and control \c RFLAGS register with the \c VM
+/// Returns the program status-and-control \c RFLAGS register with the \c VM
/// and \c RF flags cleared.
///
/// \headerfile
@@ -282,7 +282,7 @@ __readeflags(void)
return __builtin_ia32_readeflags_u64();
}
-/// Writes the specified value to the program status and control \c RFLAGS
+/// Writes the specified value to the program status-and-control \c RFLAGS
/// register. Reserved bits are not affected.
///
/// \headerfile
@@ -298,7 +298,7 @@ __writeeflags(unsigned long long __f)
}
#else /* !__x86_64__ */
-/// Returns the program status and control \c EFLAGS register with the \c VM
+/// Returns the program status-and-control \c EFLAGS register with the \c VM
/// and \c RF flags cleared.
///
/// \headerfile
@@ -312,7 +312,7 @@ __readeflags(void)
return __builtin_ia32_readeflags_u32();
}
-/// Writes the specified value to the program status and control \c EFLAGS
+/// Writes the specified value to the program status-and-control \c EFLAGS
/// register. Reserved bits are not affected.
///
/// \headerfile
@@ -328,7 +328,7 @@ __writeeflags(unsigned int __f)
}
#endif /* !__x86_64__ */
-/// Cast a 32-bit float value to a 32-bit unsigned integer value.
+/// Casts a 32-bit float value to a 32-bit unsigned integer value.
///
/// \headerfile
///
@@ -337,13 +337,13 @@ __writeeflags(unsigned int __f)
///
/// \param __A
/// A 32-bit float value.
-/// \returns a 32-bit unsigned integer containing the converted value.
+/// \returns A 32-bit unsigned integer containing the converted value.
static __inline__ unsigned int __DEFAULT_FN_ATTRS_CAST
_castf32_u32(float __A) {
return __builtin_bit_cast(unsigned int, __A);
}
-/// Cast a 64-bit float value to a 64-bit unsigned integer value.
+/// Casts a 64-bit float value to a 64-bit unsigned integer value.
///
/// \headerfile
///
@@ -352,13 +352,13 @@ _castf32_u32(float __A) {
///
/// \param __A
/// A 64-bit float value.
-/// \returns a 64-bit unsigned integer containing the converted value.
+/// \returns A 64-bit unsigned integer containing the converted value.
static __inline__ unsigned long long __DEFAULT_FN_ATTRS_CAST
_castf64_u64(double __A) {
return __builtin_bit_cast(unsigned long long, __A);
}
-/// Cast a 32-bit unsigned integer value to a 32-bit float value.
+/// Casts a 32-bit unsigned integer value to a 32-bit float value.
///
/// \headerfile
///
@@ -367,13 +367,13 @@ _castf64_u64(double __A) {
///
/// \param __A
/// A 32-bit unsigned integer value.
-/// \returns a 32-bit float value containing the converted value.
+/// \returns A 32-bit float value containing the converted value.
static __inline__ float __DEFAULT_FN_ATTRS_CAST
_castu32_f32(unsigned int __A) {
return __builtin_bit_cast(float, __A);
}
-/// Cast a 64-bit unsigned integer value to a 64-bit float value.
+/// Casts a 64-bit unsigned integer value to a 64-bit float value.
///
/// \headerfile
///
@@ -382,7 +382,7 @@ _castu32_f32(unsigned int __A) {
///
/// \param __A
/// A 64-bit unsigned integer value.
-/// \returns a 64-bit float value containing the converted value.
+/// \returns A 64-bit float value containing the converted value.
static __inline__ double __DEFAULT_FN_ATTRS_CAST
_castu64_f64(unsigned long long __A) {
return __builtin_bit_cast(double, __A);
@@ -470,7 +470,7 @@ __crc32q(unsigned long long __C, unsigned long long __D)
}
#endif /* __x86_64__ */
-/// Reads the specified performance monitoring counter. Refer to your
+/// Reads the specified performance-monitoring counter. Refer to your
/// processor's documentation to determine which performance counters are
/// supported.
///
@@ -487,7 +487,7 @@ __rdpmc(int __A) {
return __builtin_ia32_rdpmc(__A);
}
-/// Reads the processor's time stamp counter and the \c IA32_TSC_AUX MSR
+/// Reads the processor's time-stamp counter and the \c IA32_TSC_AUX MSR
/// \c (0xc0000103).
///
/// \headerfile
@@ -495,14 +495,14 @@ __rdpmc(int __A) {
/// This intrinsic corresponds to the \c RDTSCP instruction.
///
/// \param __A
-/// Address of where to store the 32-bit \c IA32_TSC_AUX value.
-/// \returns The 64-bit value of the time stamp counter.
+/// The address of where to store the 32-bit \c IA32_TSC_AUX value.
+/// \returns The 64-bit value of the time-stamp counter.
static __inline__ unsigned long long __DEFAULT_FN_ATTRS
__rdtscp(unsigned int *__A) {
return __builtin_ia32_rdtscp(__A);
}
-/// Reads the processor's time stamp counter.
+/// Reads the processor's time-stamp counter.
///
/// \headerfile
///
@@ -512,7 +512,7 @@ __rdtscp(unsigned int *__A) {
///
/// This intrinsic corresponds to the \c RDTSC instruction.
///
-/// \returns The 64-bit value of the time stamp counter.
+/// \returns The 64-bit value of the time-stamp counter.
#define _rdtsc() __rdtsc()
/// Reads the specified performance monitoring counter. Refer to your
diff --git a/lib/include/immintrin.h b/lib/include/immintrin.h
index 27800f7a8202..cd6cf09b90ca 100644
--- a/lib/include/immintrin.h
+++ b/lib/include/immintrin.h
@@ -16,281 +16,231 @@
#include
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__MMX__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__MMX__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__SSE__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SSE__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__SSE2__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SSE2__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__SSE3__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SSE3__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__SSSE3__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SSSE3__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
+#if !defined(__SCE__) || __has_feature(modules) || \
(defined(__SSE4_2__) || defined(__SSE4_1__))
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
+#if !defined(__SCE__) || __has_feature(modules) || \
(defined(__AES__) || defined(__PCLMUL__))
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__CLFLUSHOPT__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__CLFLUSHOPT__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__CLWB__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__CLWB__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVX__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVX2__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX2__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__F16C__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__F16C__)
#include
#endif
/* No feature check desired due to internal checks */
#include
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__BMI2__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__BMI2__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__LZCNT__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__LZCNT__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__POPCNT__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__POPCNT__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__FMA__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__FMA__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVX512F__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512F__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVX512VL__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512VL__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVX512BW__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512BW__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVX512BITALG__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512BITALG__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVX512CD__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512CD__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVX512VPOPCNTDQ__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512VPOPCNTDQ__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
+#if !defined(__SCE__) || __has_feature(modules) || \
(defined(__AVX512VL__) && defined(__AVX512VPOPCNTDQ__))
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVX512VNNI__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512VNNI__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
+#if !defined(__SCE__) || __has_feature(modules) || \
(defined(__AVX512VL__) && defined(__AVX512VNNI__))
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVXVNNI__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVXVNNI__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVX512DQ__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512DQ__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
+#if !defined(__SCE__) || __has_feature(modules) || \
(defined(__AVX512VL__) && defined(__AVX512BITALG__))
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
+#if !defined(__SCE__) || __has_feature(modules) || \
(defined(__AVX512VL__) && defined(__AVX512BW__))
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
+#if !defined(__SCE__) || __has_feature(modules) || \
(defined(__AVX512VL__) && defined(__AVX512CD__))
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
+#if !defined(__SCE__) || __has_feature(modules) || \
(defined(__AVX512VL__) && defined(__AVX512DQ__))
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVX512ER__)
-#include
-#endif
-
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVX512IFMA__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512IFMA__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
+#if !defined(__SCE__) || __has_feature(modules) || \
(defined(__AVX512IFMA__) && defined(__AVX512VL__))
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVXIFMA__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVXIFMA__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVX512VBMI__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512VBMI__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
+#if !defined(__SCE__) || __has_feature(modules) || \
(defined(__AVX512VBMI__) && defined(__AVX512VL__))
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVX512VBMI2__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512VBMI2__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
+#if !defined(__SCE__) || __has_feature(modules) || \
(defined(__AVX512VBMI2__) && defined(__AVX512VL__))
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVX512PF__)
-#include
-#endif
-
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVX512FP16__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512FP16__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
+#if !defined(__SCE__) || __has_feature(modules) || \
(defined(__AVX512VL__) && defined(__AVX512FP16__))
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVX512BF16__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512BF16__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
+#if !defined(__SCE__) || __has_feature(modules) || \
(defined(__AVX512VL__) && defined(__AVX512BF16__))
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__PKU__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__PKU__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__VPCLMULQDQ__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__VPCLMULQDQ__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__VAES__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__VAES__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__GFNI__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__GFNI__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVXVNNIINT8__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVXVNNIINT8__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVXNECONVERT__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVXNECONVERT__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__SHA512__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SHA512__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__SM3__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SM3__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__SM4__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SM4__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AVXVNNIINT16__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVXVNNIINT16__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__RDPID__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__RDPID__)
/// Reads the value of the IA32_TSC_AUX MSR (0xc0000103).
///
/// \headerfile
@@ -304,8 +254,7 @@ _rdpid_u32(void) {
}
#endif // __RDPID__
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__RDRND__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__RDRND__)
/// Returns a 16-bit hardware-generated random value.
///
/// \headerfile
@@ -367,8 +316,7 @@ _rdrand64_step(unsigned long long *__p)
}
#endif /* __RDRND__ */
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__FSGSBASE__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__FSGSBASE__)
#ifdef __x86_64__
/// Reads the FS base register.
///
@@ -481,8 +429,7 @@ _writegsbase_u64(unsigned long long __V)
#endif
#endif /* __FSGSBASE__ */
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__MOVBE__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__MOVBE__)
/* The structs used below are to force the load/store to be unaligned. This
* is accomplished with the __packed__ attribute. The __may_alias__ prevents
@@ -598,139 +545,118 @@ _storebe_i64(void * __P, long long __D) {
#endif
#endif /* __MOVBE */
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__RTM__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__RTM__)
#include
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__SHA__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SHA__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__FXSR__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__FXSR__)
#include
#endif
/* No feature check desired due to internal MSC_VER checks */
#include
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__XSAVEOPT__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__XSAVEOPT__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__XSAVEC__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__XSAVEC__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__XSAVES__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__XSAVES__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__SHSTK__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SHSTK__)
#include
#endif
/* Intrinsics inside adcintrin.h are available at all times. */
#include
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__ADX__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__ADX__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__RDSEED__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__RDSEED__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__WBNOINVD__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__WBNOINVD__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__CLDEMOTE__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__CLDEMOTE__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__WAITPKG__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__WAITPKG__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__MOVDIRI__) || defined(__MOVDIR64B__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__MOVDIRI__) || \
+ defined(__MOVDIR64B__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__PCONFIG__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__PCONFIG__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__SGX__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SGX__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__PTWRITE__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__PTWRITE__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__INVPCID__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__INVPCID__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AMX_FP16__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AMX_FP16__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__KL__) || defined(__WIDEKL__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__KL__) || \
+ defined(__WIDEKL__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AMX_TILE__) || defined(__AMX_INT8__) || defined(__AMX_BF16__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AMX_TILE__) || \
+ defined(__AMX_INT8__) || defined(__AMX_BF16__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__AMX_COMPLEX__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AMX_COMPLEX__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
+#if !defined(__SCE__) || __has_feature(modules) || \
defined(__AVX512VP2INTERSECT__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
+#if !defined(__SCE__) || __has_feature(modules) || \
(defined(__AVX512VL__) && defined(__AVX512VP2INTERSECT__))
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__ENQCMD__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__ENQCMD__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__SERIALIZE__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SERIALIZE__)
#include
#endif
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__TSXLDTRK__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__TSXLDTRK__)
#include
#endif
diff --git a/lib/include/intrin.h b/lib/include/intrin.h
index 9ebaea9fee94..6308c865ca91 100644
--- a/lib/include/intrin.h
+++ b/lib/include/intrin.h
@@ -15,8 +15,10 @@
#ifndef __INTRIN_H
#define __INTRIN_H
+#include
+
/* First include the standard intrinsics. */
-#if defined(__i386__) || defined(__x86_64__)
+#if defined(__i386__) || (defined(__x86_64__) && !defined(__arm64ec__))
#include
#endif
@@ -24,7 +26,7 @@
#include
#endif
-#if defined(__aarch64__)
+#if defined(__aarch64__) || defined(__arm64ec__)
#include
#endif
@@ -131,8 +133,6 @@ void __writefsqword(unsigned long, unsigned __int64);
void __writefsword(unsigned long, unsigned short);
void __writemsr(unsigned long, unsigned __int64);
void *_AddressOfReturnAddress(void);
-unsigned char _BitScanForward(unsigned long *_Index, unsigned long _Mask);
-unsigned char _BitScanReverse(unsigned long *_Index, unsigned long _Mask);
unsigned char _bittest(long const *, long);
unsigned char _bittestandcomplement(long *, long);
unsigned char _bittestandreset(long *, long);
@@ -151,7 +151,6 @@ long _InterlockedExchangeAdd_HLERelease(long volatile *, long);
__int64 _InterlockedExchangeAdd64_HLEAcquire(__int64 volatile *, __int64);
__int64 _InterlockedExchangeAdd64_HLERelease(__int64 volatile *, __int64);
void _ReadBarrier(void);
-void _ReadWriteBarrier(void);
unsigned int _rorx_u32(unsigned int, const unsigned int);
int _sarx_i32(int, unsigned int);
#if __STDC_HOSTED__
@@ -167,7 +166,7 @@ unsigned __int32 xbegin(void);
void _xend(void);
/* These additional intrinsics are turned on in x64/amd64/x86_64 mode. */
-#ifdef __x86_64__
+#if defined(__x86_64__) && !defined(__arm64ec__)
void __addgsbyte(unsigned long, unsigned char);
void __addgsdword(unsigned long, unsigned long);
void __addgsqword(unsigned long, unsigned __int64);
@@ -182,12 +181,6 @@ unsigned char __readgsbyte(unsigned long);
unsigned long __readgsdword(unsigned long);
unsigned __int64 __readgsqword(unsigned long);
unsigned short __readgsword(unsigned long);
-unsigned __int64 __shiftleft128(unsigned __int64 _LowPart,
- unsigned __int64 _HighPart,
- unsigned char _Shift);
-unsigned __int64 __shiftright128(unsigned __int64 _LowPart,
- unsigned __int64 _HighPart,
- unsigned char _Shift);
void __stosq(unsigned __int64 *, unsigned __int64, size_t);
unsigned char __vmx_on(unsigned __int64 *);
unsigned char __vmx_vmclear(unsigned __int64 *);
@@ -236,216 +229,15 @@ unsigned __int64 _shlx_u64(unsigned __int64, unsigned int);
unsigned __int64 _shrx_u64(unsigned __int64, unsigned int);
__int64 __mulh(__int64, __int64);
unsigned __int64 __umulh(unsigned __int64, unsigned __int64);
-__int64 _mul128(__int64, __int64, __int64*);
-unsigned __int64 _umul128(unsigned __int64,
- unsigned __int64,
- unsigned __int64*);
+__int64 _mul128(__int64, __int64, __int64 *);
#endif /* __x86_64__ */
-#if defined(__x86_64__) || defined(__arm__) || defined(__aarch64__)
-
-unsigned char _BitScanForward64(unsigned long *_Index, unsigned __int64 _Mask);
-unsigned char _BitScanReverse64(unsigned long *_Index, unsigned __int64 _Mask);
-
-#endif
-
-#if defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__aarch64__)
-__int64 _InterlockedDecrement64(__int64 volatile *_Addend);
-__int64 _InterlockedExchange64(__int64 volatile *_Target, __int64 _Value);
-__int64 _InterlockedExchangeAdd64(__int64 volatile *_Addend, __int64 _Value);
-__int64 _InterlockedExchangeSub64(__int64 volatile *_Subend, __int64 _Value);
-__int64 _InterlockedIncrement64(__int64 volatile *_Addend);
-__int64 _InterlockedOr64(__int64 volatile *_Value, __int64 _Mask);
-__int64 _InterlockedXor64(__int64 volatile *_Value, __int64 _Mask);
-__int64 _InterlockedAnd64(__int64 volatile *_Value, __int64 _Mask);
-
-#endif
-
-/*----------------------------------------------------------------------------*\
-|* Interlocked Exchange Add
-\*----------------------------------------------------------------------------*/
-#if defined(__arm__) || defined(__aarch64__)
-char _InterlockedExchangeAdd8_acq(char volatile *_Addend, char _Value);
-char _InterlockedExchangeAdd8_nf(char volatile *_Addend, char _Value);
-char _InterlockedExchangeAdd8_rel(char volatile *_Addend, char _Value);
-short _InterlockedExchangeAdd16_acq(short volatile *_Addend, short _Value);
-short _InterlockedExchangeAdd16_nf(short volatile *_Addend, short _Value);
-short _InterlockedExchangeAdd16_rel(short volatile *_Addend, short _Value);
-long _InterlockedExchangeAdd_acq(long volatile *_Addend, long _Value);
-long _InterlockedExchangeAdd_nf(long volatile *_Addend, long _Value);
-long _InterlockedExchangeAdd_rel(long volatile *_Addend, long _Value);
-__int64 _InterlockedExchangeAdd64_acq(__int64 volatile *_Addend, __int64 _Value);
-__int64 _InterlockedExchangeAdd64_nf(__int64 volatile *_Addend, __int64 _Value);
-__int64 _InterlockedExchangeAdd64_rel(__int64 volatile *_Addend, __int64 _Value);
-#endif
-/*----------------------------------------------------------------------------*\
-|* Interlocked Increment
-\*----------------------------------------------------------------------------*/
-#if defined(__arm__) || defined(__aarch64__)
-short _InterlockedIncrement16_acq(short volatile *_Value);
-short _InterlockedIncrement16_nf(short volatile *_Value);
-short _InterlockedIncrement16_rel(short volatile *_Value);
-long _InterlockedIncrement_acq(long volatile *_Value);
-long _InterlockedIncrement_nf(long volatile *_Value);
-long _InterlockedIncrement_rel(long volatile *_Value);
-__int64 _InterlockedIncrement64_acq(__int64 volatile *_Value);
-__int64 _InterlockedIncrement64_nf(__int64 volatile *_Value);
-__int64 _InterlockedIncrement64_rel(__int64 volatile *_Value);
-#endif
-/*----------------------------------------------------------------------------*\
-|* Interlocked Decrement
-\*----------------------------------------------------------------------------*/
-#if defined(__arm__) || defined(__aarch64__)
-short _InterlockedDecrement16_acq(short volatile *_Value);
-short _InterlockedDecrement16_nf(short volatile *_Value);
-short _InterlockedDecrement16_rel(short volatile *_Value);
-long _InterlockedDecrement_acq(long volatile *_Value);
-long _InterlockedDecrement_nf(long volatile *_Value);
-long _InterlockedDecrement_rel(long volatile *_Value);
-__int64 _InterlockedDecrement64_acq(__int64 volatile *_Value);
-__int64 _InterlockedDecrement64_nf(__int64 volatile *_Value);
-__int64 _InterlockedDecrement64_rel(__int64 volatile *_Value);
-#endif
-/*----------------------------------------------------------------------------*\
-|* Interlocked And
-\*----------------------------------------------------------------------------*/
-#if defined(__arm__) || defined(__aarch64__)
-char _InterlockedAnd8_acq(char volatile *_Value, char _Mask);
-char _InterlockedAnd8_nf(char volatile *_Value, char _Mask);
-char _InterlockedAnd8_rel(char volatile *_Value, char _Mask);
-short _InterlockedAnd16_acq(short volatile *_Value, short _Mask);
-short _InterlockedAnd16_nf(short volatile *_Value, short _Mask);
-short _InterlockedAnd16_rel(short volatile *_Value, short _Mask);
-long _InterlockedAnd_acq(long volatile *_Value, long _Mask);
-long _InterlockedAnd_nf(long volatile *_Value, long _Mask);
-long _InterlockedAnd_rel(long volatile *_Value, long _Mask);
-__int64 _InterlockedAnd64_acq(__int64 volatile *_Value, __int64 _Mask);
-__int64 _InterlockedAnd64_nf(__int64 volatile *_Value, __int64 _Mask);
-__int64 _InterlockedAnd64_rel(__int64 volatile *_Value, __int64 _Mask);
-#endif
-/*----------------------------------------------------------------------------*\
-|* Bit Counting and Testing
-\*----------------------------------------------------------------------------*/
-#if defined(__arm__) || defined(__aarch64__)
-unsigned char _interlockedbittestandset_acq(long volatile *_BitBase,
- long _BitPos);
-unsigned char _interlockedbittestandset_nf(long volatile *_BitBase,
- long _BitPos);
-unsigned char _interlockedbittestandset_rel(long volatile *_BitBase,
- long _BitPos);
-unsigned char _interlockedbittestandreset_acq(long volatile *_BitBase,
- long _BitPos);
-unsigned char _interlockedbittestandreset_nf(long volatile *_BitBase,
- long _BitPos);
-unsigned char _interlockedbittestandreset_rel(long volatile *_BitBase,
- long _BitPos);
-#endif
-/*----------------------------------------------------------------------------*\
-|* Interlocked Or
-\*----------------------------------------------------------------------------*/
-#if defined(__arm__) || defined(__aarch64__)
-char _InterlockedOr8_acq(char volatile *_Value, char _Mask);
-char _InterlockedOr8_nf(char volatile *_Value, char _Mask);
-char _InterlockedOr8_rel(char volatile *_Value, char _Mask);
-short _InterlockedOr16_acq(short volatile *_Value, short _Mask);
-short _InterlockedOr16_nf(short volatile *_Value, short _Mask);
-short _InterlockedOr16_rel(short volatile *_Value, short _Mask);
-long _InterlockedOr_acq(long volatile *_Value, long _Mask);
-long _InterlockedOr_nf(long volatile *_Value, long _Mask);
-long _InterlockedOr_rel(long volatile *_Value, long _Mask);
-__int64 _InterlockedOr64_acq(__int64 volatile *_Value, __int64 _Mask);
-__int64 _InterlockedOr64_nf(__int64 volatile *_Value, __int64 _Mask);
-__int64 _InterlockedOr64_rel(__int64 volatile *_Value, __int64 _Mask);
-#endif
-/*----------------------------------------------------------------------------*\
-|* Interlocked Xor
-\*----------------------------------------------------------------------------*/
-#if defined(__arm__) || defined(__aarch64__)
-char _InterlockedXor8_acq(char volatile *_Value, char _Mask);
-char _InterlockedXor8_nf(char volatile *_Value, char _Mask);
-char _InterlockedXor8_rel(char volatile *_Value, char _Mask);
-short _InterlockedXor16_acq(short volatile *_Value, short _Mask);
-short _InterlockedXor16_nf(short volatile *_Value, short _Mask);
-short _InterlockedXor16_rel(short volatile *_Value, short _Mask);
-long _InterlockedXor_acq(long volatile *_Value, long _Mask);
-long _InterlockedXor_nf(long volatile *_Value, long _Mask);
-long _InterlockedXor_rel(long volatile *_Value, long _Mask);
-__int64 _InterlockedXor64_acq(__int64 volatile *_Value, __int64 _Mask);
-__int64 _InterlockedXor64_nf(__int64 volatile *_Value, __int64 _Mask);
-__int64 _InterlockedXor64_rel(__int64 volatile *_Value, __int64 _Mask);
-#endif
-/*----------------------------------------------------------------------------*\
-|* Interlocked Exchange
-\*----------------------------------------------------------------------------*/
-#if defined(__arm__) || defined(__aarch64__)
-char _InterlockedExchange8_acq(char volatile *_Target, char _Value);
-char _InterlockedExchange8_nf(char volatile *_Target, char _Value);
-char _InterlockedExchange8_rel(char volatile *_Target, char _Value);
-short _InterlockedExchange16_acq(short volatile *_Target, short _Value);
-short _InterlockedExchange16_nf(short volatile *_Target, short _Value);
-short _InterlockedExchange16_rel(short volatile *_Target, short _Value);
-long _InterlockedExchange_acq(long volatile *_Target, long _Value);
-long _InterlockedExchange_nf(long volatile *_Target, long _Value);
-long _InterlockedExchange_rel(long volatile *_Target, long _Value);
-__int64 _InterlockedExchange64_acq(__int64 volatile *_Target, __int64 _Value);
-__int64 _InterlockedExchange64_nf(__int64 volatile *_Target, __int64 _Value);
-__int64 _InterlockedExchange64_rel(__int64 volatile *_Target, __int64 _Value);
-#endif
-/*----------------------------------------------------------------------------*\
-|* Interlocked Compare Exchange
-\*----------------------------------------------------------------------------*/
-#if defined(__arm__) || defined(__aarch64__)
-char _InterlockedCompareExchange8_acq(char volatile *_Destination,
- char _Exchange, char _Comparand);
-char _InterlockedCompareExchange8_nf(char volatile *_Destination,
- char _Exchange, char _Comparand);
-char _InterlockedCompareExchange8_rel(char volatile *_Destination,
- char _Exchange, char _Comparand);
-short _InterlockedCompareExchange16_acq(short volatile *_Destination,
- short _Exchange, short _Comparand);
-short _InterlockedCompareExchange16_nf(short volatile *_Destination,
- short _Exchange, short _Comparand);
-short _InterlockedCompareExchange16_rel(short volatile *_Destination,
- short _Exchange, short _Comparand);
-long _InterlockedCompareExchange_acq(long volatile *_Destination,
- long _Exchange, long _Comparand);
-long _InterlockedCompareExchange_nf(long volatile *_Destination,
- long _Exchange, long _Comparand);
-long _InterlockedCompareExchange_rel(long volatile *_Destination,
- long _Exchange, long _Comparand);
-__int64 _InterlockedCompareExchange64_acq(__int64 volatile *_Destination,
- __int64 _Exchange, __int64 _Comparand);
-__int64 _InterlockedCompareExchange64_nf(__int64 volatile *_Destination,
- __int64 _Exchange, __int64 _Comparand);
-__int64 _InterlockedCompareExchange64_rel(__int64 volatile *_Destination,
- __int64 _Exchange, __int64 _Comparand);
-#endif
-#if defined(__x86_64__) || defined(__aarch64__)
-unsigned char _InterlockedCompareExchange128(__int64 volatile *_Destination,
- __int64 _ExchangeHigh,
- __int64 _ExchangeLow,
- __int64 *_ComparandResult);
-#endif
-#if defined(__aarch64__)
-unsigned char _InterlockedCompareExchange128_acq(__int64 volatile *_Destination,
- __int64 _ExchangeHigh,
- __int64 _ExchangeLow,
- __int64 *_ComparandResult);
-unsigned char _InterlockedCompareExchange128_nf(__int64 volatile *_Destination,
- __int64 _ExchangeHigh,
- __int64 _ExchangeLow,
- __int64 *_ComparandResult);
-unsigned char _InterlockedCompareExchange128_rel(__int64 volatile *_Destination,
- __int64 _ExchangeHigh,
- __int64 _ExchangeLow,
- __int64 *_ComparandResult);
-#endif
-
/*----------------------------------------------------------------------------*\
|* movs, stos
\*----------------------------------------------------------------------------*/
-#if defined(__i386__) || defined(__x86_64__)
+
+#if defined(__i386__) || (defined(__x86_64__) && !defined(__arm64ec__))
static __inline__ void __DEFAULT_FN_ATTRS __movsb(unsigned char *__dst,
unsigned char const *__src,
size_t __n) {
@@ -514,7 +306,7 @@ static __inline__ void __DEFAULT_FN_ATTRS __stosw(unsigned short *__dst,
: "memory");
}
#endif
-#ifdef __x86_64__
+#if defined(__x86_64__) && !defined(__arm64ec__)
static __inline__ void __DEFAULT_FN_ATTRS __movsq(
unsigned long long *__dst, unsigned long long const *__src, size_t __n) {
__asm__ __volatile__("rep movsq"
@@ -533,10 +325,40 @@ static __inline__ void __DEFAULT_FN_ATTRS __stosq(unsigned __int64 *__dst,
/*----------------------------------------------------------------------------*\
|* Misc
\*----------------------------------------------------------------------------*/
-#if defined(__i386__) || defined(__x86_64__)
+#if defined(__i386__) || (defined(__x86_64__) && !defined(__arm64ec__))
static __inline__ void __DEFAULT_FN_ATTRS __halt(void) {
__asm__ volatile("hlt");
}
+
+static inline unsigned char __inbyte(unsigned short port) {
+ unsigned char ret;
+ __asm__ __volatile__("inb %w1, %b0" : "=a"(ret) : "Nd"(port));
+ return ret;
+}
+
+static inline unsigned short __inword(unsigned short port) {
+ unsigned short ret;
+ __asm__ __volatile__("inw %w1, %w0" : "=a"(ret) : "Nd"(port));
+ return ret;
+}
+
+static inline unsigned long __indword(unsigned short port) {
+ unsigned long ret;
+ __asm__ __volatile__("inl %w1, %k0" : "=a"(ret) : "Nd"(port));
+ return ret;
+}
+
+static inline void __outbyte(unsigned short port, unsigned char data) {
+ __asm__ __volatile__("outb %b0, %w1" : : "a"(data), "Nd"(port));
+}
+
+static inline void __outword(unsigned short port, unsigned short data) {
+ __asm__ __volatile__("outw %w0, %w1" : : "a"(data), "Nd"(port));
+}
+
+static inline void __outdword(unsigned short port, unsigned long data) {
+ __asm__ __volatile__("outl %k0, %w1" : : "a"(data), "Nd"(port));
+}
#endif
#if defined(__i386__) || defined(__x86_64__) || defined(__aarch64__)
@@ -548,9 +370,10 @@ static __inline__ void __DEFAULT_FN_ATTRS __nop(void) {
/*----------------------------------------------------------------------------*\
|* MS AArch64 specific
\*----------------------------------------------------------------------------*/
-#if defined(__aarch64__)
+#if defined(__aarch64__) || defined(__arm64ec__)
unsigned __int64 __getReg(int);
long _InterlockedAdd(long volatile *Addend, long Value);
+__int64 _InterlockedAdd64(__int64 volatile *Addend, __int64 Value);
__int64 _ReadStatusReg(int);
void _WriteStatusReg(int, __int64);
@@ -582,18 +405,19 @@ unsigned int _CountLeadingOnes(unsigned long);
unsigned int _CountLeadingOnes64(unsigned __int64);
unsigned int _CountLeadingSigns(long);
unsigned int _CountLeadingSigns64(__int64);
-unsigned int _CountLeadingZeros(unsigned long);
-unsigned int _CountLeadingZeros64(unsigned _int64);
unsigned int _CountOneBits(unsigned long);
unsigned int _CountOneBits64(unsigned __int64);
-void __cdecl __prefetch(void *);
+unsigned int __hlt(unsigned int, ...);
+
+void __cdecl __prefetch(const void *);
+
#endif
/*----------------------------------------------------------------------------*\
|* Privileged intrinsics
\*----------------------------------------------------------------------------*/
-#if defined(__i386__) || defined(__x86_64__)
+#if defined(__i386__) || (defined(__x86_64__) && !defined(__arm64ec__))
static __inline__ unsigned __int64 __DEFAULT_FN_ATTRS
__readmsr(unsigned long __register) {
// Loads the contents of a 64-bit model specific register (MSR) specified in
@@ -607,7 +431,6 @@ __readmsr(unsigned long __register) {
__asm__ ("rdmsr" : "=d"(__edx), "=a"(__eax) : "c"(__register));
return (((unsigned __int64)__edx) << 32) | (unsigned __int64)__eax;
}
-#endif
static __inline__ unsigned __LPTRINT_TYPE__ __DEFAULT_FN_ATTRS __readcr3(void) {
unsigned __LPTRINT_TYPE__ __cr3_val;
@@ -623,6 +446,7 @@ static __inline__ void __DEFAULT_FN_ATTRS
__writecr3(unsigned __INTPTR_TYPE__ __cr3_val) {
__asm__ ("mov {%0, %%cr3|cr3, %0}" : : "r"(__cr3_val) : "memory");
}
+#endif
#ifdef __cplusplus
}
diff --git a/lib/include/intrin0.h b/lib/include/intrin0.h
new file mode 100644
index 000000000000..866c8896617d
--- /dev/null
+++ b/lib/include/intrin0.h
@@ -0,0 +1,247 @@
+/* ===-------- intrin.h ---------------------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+/* Only include this if we're compiling for the windows platform. */
+#ifndef _MSC_VER
+#include_next
+#else
+
+#ifndef __INTRIN0_H
+#define __INTRIN0_H
+
+#if defined(__x86_64__) && !defined(__arm64ec__)
+#include
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+unsigned char _BitScanForward(unsigned long *_Index, unsigned long _Mask);
+unsigned char _BitScanReverse(unsigned long *_Index, unsigned long _Mask);
+void _ReadWriteBarrier(void);
+
+#if defined(__aarch64__) || defined(__arm64ec__)
+unsigned int _CountLeadingZeros(unsigned long);
+unsigned int _CountLeadingZeros64(unsigned _int64);
+unsigned char _InterlockedCompareExchange128_acq(__int64 volatile *_Destination,
+ __int64 _ExchangeHigh,
+ __int64 _ExchangeLow,
+ __int64 *_ComparandResult);
+unsigned char _InterlockedCompareExchange128_nf(__int64 volatile *_Destination,
+ __int64 _ExchangeHigh,
+ __int64 _ExchangeLow,
+ __int64 *_ComparandResult);
+unsigned char _InterlockedCompareExchange128_rel(__int64 volatile *_Destination,
+ __int64 _ExchangeHigh,
+ __int64 _ExchangeLow,
+ __int64 *_ComparandResult);
+#endif
+
+#ifdef __x86_64__ && !defined(__arm64ec__)
+unsigned __int64 _umul128(unsigned __int64, unsigned __int64,
+ unsigned __int64 *);
+unsigned __int64 __shiftleft128(unsigned __int64 _LowPart,
+ unsigned __int64 _HighPart,
+ unsigned char _Shift);
+unsigned __int64 __shiftright128(unsigned __int64 _LowPart,
+ unsigned __int64 _HighPart,
+ unsigned char _Shift);
+#endif
+
+#if defined(__i386__) || (defined(__x86_64__) && !defined(__arm64ec__))
+void _mm_pause(void);
+#endif
+
+#if defined(__x86_64__) || defined(__aarch64__)
+unsigned char _InterlockedCompareExchange128(__int64 volatile *_Destination,
+ __int64 _ExchangeHigh,
+ __int64 _ExchangeLow,
+ __int64 *_ComparandResult);
+#endif
+
+#if defined(__x86_64__) || defined(__arm__) || defined(__aarch64__)
+unsigned char _BitScanForward64(unsigned long *_Index, unsigned __int64 _Mask);
+unsigned char _BitScanReverse64(unsigned long *_Index, unsigned __int64 _Mask);
+#endif
+
+#if defined(__i386__) || defined(__x86_64__) || defined(__arm__) || \
+ defined(__aarch64__)
+__int64 _InterlockedDecrement64(__int64 volatile *_Addend);
+__int64 _InterlockedExchange64(__int64 volatile *_Target, __int64 _Value);
+__int64 _InterlockedExchangeAdd64(__int64 volatile *_Addend, __int64 _Value);
+__int64 _InterlockedExchangeSub64(__int64 volatile *_Subend, __int64 _Value);
+__int64 _InterlockedIncrement64(__int64 volatile *_Addend);
+__int64 _InterlockedOr64(__int64 volatile *_Value, __int64 _Mask);
+__int64 _InterlockedXor64(__int64 volatile *_Value, __int64 _Mask);
+__int64 _InterlockedAnd64(__int64 volatile *_Value, __int64 _Mask);
+#endif
+
+#if defined(__arm__) || defined(__aarch64__) || defined(__arm64ec__)
+/*----------------------------------------------------------------------------*\
+|* Interlocked Exchange Add
+\*----------------------------------------------------------------------------*/
+char _InterlockedExchangeAdd8_acq(char volatile *_Addend, char _Value);
+char _InterlockedExchangeAdd8_nf(char volatile *_Addend, char _Value);
+char _InterlockedExchangeAdd8_rel(char volatile *_Addend, char _Value);
+short _InterlockedExchangeAdd16_acq(short volatile *_Addend, short _Value);
+short _InterlockedExchangeAdd16_nf(short volatile *_Addend, short _Value);
+short _InterlockedExchangeAdd16_rel(short volatile *_Addend, short _Value);
+long _InterlockedExchangeAdd_acq(long volatile *_Addend, long _Value);
+long _InterlockedExchangeAdd_nf(long volatile *_Addend, long _Value);
+long _InterlockedExchangeAdd_rel(long volatile *_Addend, long _Value);
+__int64 _InterlockedExchangeAdd64_acq(__int64 volatile *_Addend,
+ __int64 _Value);
+__int64 _InterlockedExchangeAdd64_nf(__int64 volatile *_Addend, __int64 _Value);
+__int64 _InterlockedExchangeAdd64_rel(__int64 volatile *_Addend,
+ __int64 _Value);
+
+/*----------------------------------------------------------------------------*\
+|* Interlocked Increment
+\*----------------------------------------------------------------------------*/
+short _InterlockedIncrement16_acq(short volatile *_Value);
+short _InterlockedIncrement16_nf(short volatile *_Value);
+short _InterlockedIncrement16_rel(short volatile *_Value);
+long _InterlockedIncrement_acq(long volatile *_Value);
+long _InterlockedIncrement_nf(long volatile *_Value);
+long _InterlockedIncrement_rel(long volatile *_Value);
+__int64 _InterlockedIncrement64_acq(__int64 volatile *_Value);
+__int64 _InterlockedIncrement64_nf(__int64 volatile *_Value);
+__int64 _InterlockedIncrement64_rel(__int64 volatile *_Value);
+
+/*----------------------------------------------------------------------------*\
+|* Interlocked Decrement
+\*----------------------------------------------------------------------------*/
+short _InterlockedDecrement16_acq(short volatile *_Value);
+short _InterlockedDecrement16_nf(short volatile *_Value);
+short _InterlockedDecrement16_rel(short volatile *_Value);
+long _InterlockedDecrement_acq(long volatile *_Value);
+long _InterlockedDecrement_nf(long volatile *_Value);
+long _InterlockedDecrement_rel(long volatile *_Value);
+__int64 _InterlockedDecrement64_acq(__int64 volatile *_Value);
+__int64 _InterlockedDecrement64_nf(__int64 volatile *_Value);
+__int64 _InterlockedDecrement64_rel(__int64 volatile *_Value);
+
+/*----------------------------------------------------------------------------*\
+|* Interlocked And
+\*----------------------------------------------------------------------------*/
+char _InterlockedAnd8_acq(char volatile *_Value, char _Mask);
+char _InterlockedAnd8_nf(char volatile *_Value, char _Mask);
+char _InterlockedAnd8_rel(char volatile *_Value, char _Mask);
+short _InterlockedAnd16_acq(short volatile *_Value, short _Mask);
+short _InterlockedAnd16_nf(short volatile *_Value, short _Mask);
+short _InterlockedAnd16_rel(short volatile *_Value, short _Mask);
+long _InterlockedAnd_acq(long volatile *_Value, long _Mask);
+long _InterlockedAnd_nf(long volatile *_Value, long _Mask);
+long _InterlockedAnd_rel(long volatile *_Value, long _Mask);
+__int64 _InterlockedAnd64_acq(__int64 volatile *_Value, __int64 _Mask);
+__int64 _InterlockedAnd64_nf(__int64 volatile *_Value, __int64 _Mask);
+__int64 _InterlockedAnd64_rel(__int64 volatile *_Value, __int64 _Mask);
+
+/*----------------------------------------------------------------------------*\
+|* Bit Counting and Testing
+\*----------------------------------------------------------------------------*/
+unsigned char _interlockedbittestandset_acq(long volatile *_BitBase,
+ long _BitPos);
+unsigned char _interlockedbittestandset_nf(long volatile *_BitBase,
+ long _BitPos);
+unsigned char _interlockedbittestandset_rel(long volatile *_BitBase,
+ long _BitPos);
+unsigned char _interlockedbittestandreset_acq(long volatile *_BitBase,
+ long _BitPos);
+unsigned char _interlockedbittestandreset_nf(long volatile *_BitBase,
+ long _BitPos);
+unsigned char _interlockedbittestandreset_rel(long volatile *_BitBase,
+ long _BitPos);
+
+/*----------------------------------------------------------------------------*\
+|* Interlocked Or
+\*----------------------------------------------------------------------------*/
+char _InterlockedOr8_acq(char volatile *_Value, char _Mask);
+char _InterlockedOr8_nf(char volatile *_Value, char _Mask);
+char _InterlockedOr8_rel(char volatile *_Value, char _Mask);
+short _InterlockedOr16_acq(short volatile *_Value, short _Mask);
+short _InterlockedOr16_nf(short volatile *_Value, short _Mask);
+short _InterlockedOr16_rel(short volatile *_Value, short _Mask);
+long _InterlockedOr_acq(long volatile *_Value, long _Mask);
+long _InterlockedOr_nf(long volatile *_Value, long _Mask);
+long _InterlockedOr_rel(long volatile *_Value, long _Mask);
+__int64 _InterlockedOr64_acq(__int64 volatile *_Value, __int64 _Mask);
+__int64 _InterlockedOr64_nf(__int64 volatile *_Value, __int64 _Mask);
+__int64 _InterlockedOr64_rel(__int64 volatile *_Value, __int64 _Mask);
+
+/*----------------------------------------------------------------------------*\
+|* Interlocked Xor
+\*----------------------------------------------------------------------------*/
+char _InterlockedXor8_acq(char volatile *_Value, char _Mask);
+char _InterlockedXor8_nf(char volatile *_Value, char _Mask);
+char _InterlockedXor8_rel(char volatile *_Value, char _Mask);
+short _InterlockedXor16_acq(short volatile *_Value, short _Mask);
+short _InterlockedXor16_nf(short volatile *_Value, short _Mask);
+short _InterlockedXor16_rel(short volatile *_Value, short _Mask);
+long _InterlockedXor_acq(long volatile *_Value, long _Mask);
+long _InterlockedXor_nf(long volatile *_Value, long _Mask);
+long _InterlockedXor_rel(long volatile *_Value, long _Mask);
+__int64 _InterlockedXor64_acq(__int64 volatile *_Value, __int64 _Mask);
+__int64 _InterlockedXor64_nf(__int64 volatile *_Value, __int64 _Mask);
+__int64 _InterlockedXor64_rel(__int64 volatile *_Value, __int64 _Mask);
+
+/*----------------------------------------------------------------------------*\
+|* Interlocked Exchange
+\*----------------------------------------------------------------------------*/
+char _InterlockedExchange8_acq(char volatile *_Target, char _Value);
+char _InterlockedExchange8_nf(char volatile *_Target, char _Value);
+char _InterlockedExchange8_rel(char volatile *_Target, char _Value);
+short _InterlockedExchange16_acq(short volatile *_Target, short _Value);
+short _InterlockedExchange16_nf(short volatile *_Target, short _Value);
+short _InterlockedExchange16_rel(short volatile *_Target, short _Value);
+long _InterlockedExchange_acq(long volatile *_Target, long _Value);
+long _InterlockedExchange_nf(long volatile *_Target, long _Value);
+long _InterlockedExchange_rel(long volatile *_Target, long _Value);
+__int64 _InterlockedExchange64_acq(__int64 volatile *_Target, __int64 _Value);
+__int64 _InterlockedExchange64_nf(__int64 volatile *_Target, __int64 _Value);
+__int64 _InterlockedExchange64_rel(__int64 volatile *_Target, __int64 _Value);
+
+/*----------------------------------------------------------------------------*\
+|* Interlocked Compare Exchange
+\*----------------------------------------------------------------------------*/
+char _InterlockedCompareExchange8_acq(char volatile *_Destination,
+ char _Exchange, char _Comparand);
+char _InterlockedCompareExchange8_nf(char volatile *_Destination,
+ char _Exchange, char _Comparand);
+char _InterlockedCompareExchange8_rel(char volatile *_Destination,
+ char _Exchange, char _Comparand);
+short _InterlockedCompareExchange16_acq(short volatile *_Destination,
+ short _Exchange, short _Comparand);
+short _InterlockedCompareExchange16_nf(short volatile *_Destination,
+ short _Exchange, short _Comparand);
+short _InterlockedCompareExchange16_rel(short volatile *_Destination,
+ short _Exchange, short _Comparand);
+long _InterlockedCompareExchange_acq(long volatile *_Destination,
+ long _Exchange, long _Comparand);
+long _InterlockedCompareExchange_nf(long volatile *_Destination, long _Exchange,
+ long _Comparand);
+long _InterlockedCompareExchange_rel(long volatile *_Destination,
+ long _Exchange, long _Comparand);
+__int64 _InterlockedCompareExchange64_acq(__int64 volatile *_Destination,
+ __int64 _Exchange,
+ __int64 _Comparand);
+__int64 _InterlockedCompareExchange64_nf(__int64 volatile *_Destination,
+ __int64 _Exchange, __int64 _Comparand);
+__int64 _InterlockedCompareExchange64_rel(__int64 volatile *_Destination,
+ __int64 _Exchange,
+ __int64 _Comparand);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __INTRIN0_H */
+#endif /* _MSC_VER */
diff --git a/lib/include/inttypes.h b/lib/include/inttypes.h
index 1c894c4aca49..5150d22f8b2e 100644
--- a/lib/include/inttypes.h
+++ b/lib/include/inttypes.h
@@ -13,6 +13,9 @@
#if !defined(_AIX) || !defined(_STD_TYPES_T)
#define __CLANG_INTTYPES_H
#endif
+#if defined(__MVS__) && __has_include_next()
+#include_next
+#else
#if defined(_MSC_VER) && _MSC_VER < 1800
#error MSVC does not have inttypes.h prior to Visual Studio 2013
@@ -94,4 +97,5 @@
#define SCNxFAST32 "x"
#endif
+#endif /* __MVS__ */
#endif /* __CLANG_INTTYPES_H */
diff --git a/lib/include/iso646.h b/lib/include/iso646.h
index e0a20c6f1891..b53fcd9b4e53 100644
--- a/lib/include/iso646.h
+++ b/lib/include/iso646.h
@@ -9,6 +9,9 @@
#ifndef __ISO646_H
#define __ISO646_H
+#if defined(__MVS__) && __has_include_next()
+#include_next
+#else
#ifndef __cplusplus
#define and &&
@@ -24,4 +27,5 @@
#define xor_eq ^=
#endif
+#endif /* __MVS__ */
#endif /* __ISO646_H */
diff --git a/lib/include/keylockerintrin.h b/lib/include/keylockerintrin.h
index 1994ac42070a..f76e91b4d4b3 100644
--- a/lib/include/keylockerintrin.h
+++ b/lib/include/keylockerintrin.h
@@ -28,8 +28,7 @@
#ifndef _KEYLOCKERINTRIN_H
#define _KEYLOCKERINTRIN_H
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__KL__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__KL__)
/* Define the default attributes for the functions in this file. */
#define __DEFAULT_FN_ATTRS \
@@ -327,11 +326,9 @@ _mm_aesdec256kl_u8(__m128i* __odata, __m128i __idata, const void *__h) {
#undef __DEFAULT_FN_ATTRS
-#endif /* !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) \
- || defined(__KL__) */
+#endif /* !defined(__SCE__ || __has_feature(modules) || defined(__KL__) */
-#if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
- defined(__WIDEKL__)
+#if !defined(__SCE__) || __has_feature(modules) || defined(__WIDEKL__)
/* Define the default attributes for the functions in this file. */
#define __DEFAULT_FN_ATTRS \
@@ -524,7 +521,7 @@ _mm_aesdecwide256kl_u8(__m128i __odata[8], const __m128i __idata[8], const void*
#undef __DEFAULT_FN_ATTRS
-#endif /* !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) \
- || defined(__WIDEKL__) */
+#endif /* !defined(__SCE__) || __has_feature(modules) || defined(__WIDEKL__) \
+ */
#endif /* _KEYLOCKERINTRIN_H */
diff --git a/lib/include/limits.h b/lib/include/limits.h
index 15e6bbe0abcf..56dffe568486 100644
--- a/lib/include/limits.h
+++ b/lib/include/limits.h
@@ -9,6 +9,10 @@
#ifndef __CLANG_LIMITS_H
#define __CLANG_LIMITS_H
+#if defined(__MVS__) && __has_include_next()
+#include_next
+#else
+
/* The system's limits.h may, in turn, try to #include_next GCC's limits.h.
Avert this #include_next madness. */
#if defined __GNUC__ && !defined _GCC_LIMITS_H_
@@ -122,4 +126,5 @@
#define ULONG_LONG_MAX (__LONG_LONG_MAX__*2ULL+1ULL)
#endif
+#endif /* __MVS__ */
#endif /* __CLANG_LIMITS_H */
diff --git a/lib/include/llvm_libc_wrappers/assert.h b/lib/include/llvm_libc_wrappers/assert.h
index de650ca8442a..610ed96a458c 100644
--- a/lib/include/llvm_libc_wrappers/assert.h
+++ b/lib/include/llvm_libc_wrappers/assert.h
@@ -1,4 +1,4 @@
-//===-- Wrapper for C standard assert.h declarations on the GPU ------------===//
+//===-- Wrapper for C standard assert.h declarations on the GPU -*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
diff --git a/lib/include/mm3dnow.h b/lib/include/mm3dnow.h
index 22ab13aa3340..afffba3a9c75 100644
--- a/lib/include/mm3dnow.h
+++ b/lib/include/mm3dnow.h
@@ -7,151 +7,16 @@
*===-----------------------------------------------------------------------===
*/
+// 3dNow intrinsics are no longer supported.
+
#ifndef _MM3DNOW_H_INCLUDED
#define _MM3DNOW_H_INCLUDED
+#ifndef _CLANG_DISABLE_CRT_DEPRECATION_WARNINGS
+#warning "The header is deprecated, and 3dNow! intrinsics are unsupported. For other intrinsics, include , instead."
+#endif
+
#include
#include
-typedef float __v2sf __attribute__((__vector_size__(8)));
-
-/* Define the default attributes for the functions in this file. */
-#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("3dnow"), __min_vector_width__(64)))
-
-static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("3dnow")))
-_m_femms(void) {
- __builtin_ia32_femms();
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pavgusb(__m64 __m1, __m64 __m2) {
- return (__m64)__builtin_ia32_pavgusb((__v8qi)__m1, (__v8qi)__m2);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pf2id(__m64 __m) {
- return (__m64)__builtin_ia32_pf2id((__v2sf)__m);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pfacc(__m64 __m1, __m64 __m2) {
- return (__m64)__builtin_ia32_pfacc((__v2sf)__m1, (__v2sf)__m2);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pfadd(__m64 __m1, __m64 __m2) {
- return (__m64)__builtin_ia32_pfadd((__v2sf)__m1, (__v2sf)__m2);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pfcmpeq(__m64 __m1, __m64 __m2) {
- return (__m64)__builtin_ia32_pfcmpeq((__v2sf)__m1, (__v2sf)__m2);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pfcmpge(__m64 __m1, __m64 __m2) {
- return (__m64)__builtin_ia32_pfcmpge((__v2sf)__m1, (__v2sf)__m2);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pfcmpgt(__m64 __m1, __m64 __m2) {
- return (__m64)__builtin_ia32_pfcmpgt((__v2sf)__m1, (__v2sf)__m2);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pfmax(__m64 __m1, __m64 __m2) {
- return (__m64)__builtin_ia32_pfmax((__v2sf)__m1, (__v2sf)__m2);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pfmin(__m64 __m1, __m64 __m2) {
- return (__m64)__builtin_ia32_pfmin((__v2sf)__m1, (__v2sf)__m2);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pfmul(__m64 __m1, __m64 __m2) {
- return (__m64)__builtin_ia32_pfmul((__v2sf)__m1, (__v2sf)__m2);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pfrcp(__m64 __m) {
- return (__m64)__builtin_ia32_pfrcp((__v2sf)__m);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pfrcpit1(__m64 __m1, __m64 __m2) {
- return (__m64)__builtin_ia32_pfrcpit1((__v2sf)__m1, (__v2sf)__m2);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pfrcpit2(__m64 __m1, __m64 __m2) {
- return (__m64)__builtin_ia32_pfrcpit2((__v2sf)__m1, (__v2sf)__m2);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pfrsqrt(__m64 __m) {
- return (__m64)__builtin_ia32_pfrsqrt((__v2sf)__m);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pfrsqrtit1(__m64 __m1, __m64 __m2) {
- return (__m64)__builtin_ia32_pfrsqit1((__v2sf)__m1, (__v2sf)__m2);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pfsub(__m64 __m1, __m64 __m2) {
- return (__m64)__builtin_ia32_pfsub((__v2sf)__m1, (__v2sf)__m2);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pfsubr(__m64 __m1, __m64 __m2) {
- return (__m64)__builtin_ia32_pfsubr((__v2sf)__m1, (__v2sf)__m2);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pi2fd(__m64 __m) {
- return (__m64)__builtin_ia32_pi2fd((__v2si)__m);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pmulhrw(__m64 __m1, __m64 __m2) {
- return (__m64)__builtin_ia32_pmulhrw((__v4hi)__m1, (__v4hi)__m2);
-}
-
-/* Handle the 3dnowa instructions here. */
-#undef __DEFAULT_FN_ATTRS
-#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("3dnowa"), __min_vector_width__(64)))
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pf2iw(__m64 __m) {
- return (__m64)__builtin_ia32_pf2iw((__v2sf)__m);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pfnacc(__m64 __m1, __m64 __m2) {
- return (__m64)__builtin_ia32_pfnacc((__v2sf)__m1, (__v2sf)__m2);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pfpnacc(__m64 __m1, __m64 __m2) {
- return (__m64)__builtin_ia32_pfpnacc((__v2sf)__m1, (__v2sf)__m2);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pi2fw(__m64 __m) {
- return (__m64)__builtin_ia32_pi2fw((__v2si)__m);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pswapdsf(__m64 __m) {
- return (__m64)__builtin_ia32_pswapdsf((__v2sf)__m);
-}
-
-static __inline__ __m64 __DEFAULT_FN_ATTRS
-_m_pswapdsi(__m64 __m) {
- return (__m64)__builtin_ia32_pswapdsi((__v2si)__m);
-}
-
-#undef __DEFAULT_FN_ATTRS
-
#endif
diff --git a/lib/include/mmintrin.h b/lib/include/mmintrin.h
index 08849f01071a..4e154e2d8593 100644
--- a/lib/include/mmintrin.h
+++ b/lib/include/mmintrin.h
@@ -105,28 +105,23 @@ _mm_cvtm64_si64(__m64 __m)
return (long long)__m;
}
-/// Converts 16-bit signed integers from both 64-bit integer vector
-/// parameters of [4 x i16] into 8-bit signed integer values, and constructs
-/// a 64-bit integer vector of [8 x i8] as the result. Positive values
-/// greater than 0x7F are saturated to 0x7F. Negative values less than 0x80
-/// are saturated to 0x80.
+/// Converts, with saturation, 16-bit signed integers from both 64-bit integer
+/// vector parameters of [4 x i16] into 8-bit signed integer values, and
+/// constructs a 64-bit integer vector of [8 x i8] as the result.
+///
+/// Positive values greater than 0x7F are saturated to 0x7F. Negative values
+/// less than 0x80 are saturated to 0x80.
///
/// \headerfile
///
/// This intrinsic corresponds to the PACKSSWB instruction.
///
/// \param __m1
-/// A 64-bit integer vector of [4 x i16]. Each 16-bit element is treated as a
-/// 16-bit signed integer and is converted to an 8-bit signed integer with
-/// saturation. Positive values greater than 0x7F are saturated to 0x7F.
-/// Negative values less than 0x80 are saturated to 0x80. The converted
-/// [4 x i8] values are written to the lower 32 bits of the result.
+/// A 64-bit integer vector of [4 x i16]. The converted [4 x i8] values are
+/// written to the lower 32 bits of the result.
/// \param __m2
-/// A 64-bit integer vector of [4 x i16]. Each 16-bit element is treated as a
-/// 16-bit signed integer and is converted to an 8-bit signed integer with
-/// saturation. Positive values greater than 0x7F are saturated to 0x7F.
-/// Negative values less than 0x80 are saturated to 0x80. The converted
-/// [4 x i8] values are written to the upper 32 bits of the result.
+/// A 64-bit integer vector of [4 x i16]. The converted [4 x i8] values are
+/// written to the upper 32 bits of the result.
/// \returns A 64-bit integer vector of [8 x i8] containing the converted
/// values.
static __inline__ __m64 __DEFAULT_FN_ATTRS
@@ -135,28 +130,23 @@ _mm_packs_pi16(__m64 __m1, __m64 __m2)
return (__m64)__builtin_ia32_packsswb((__v4hi)__m1, (__v4hi)__m2);
}
-/// Converts 32-bit signed integers from both 64-bit integer vector
-/// parameters of [2 x i32] into 16-bit signed integer values, and constructs
-/// a 64-bit integer vector of [4 x i16] as the result. Positive values
-/// greater than 0x7FFF are saturated to 0x7FFF. Negative values less than
-/// 0x8000 are saturated to 0x8000.
+/// Converts, with saturation, 32-bit signed integers from both 64-bit integer
+/// vector parameters of [2 x i32] into 16-bit signed integer values, and
+/// constructs a 64-bit integer vector of [4 x i16] as the result.
+///
+/// Positive values greater than 0x7FFF are saturated to 0x7FFF. Negative
+/// values less than 0x8000 are saturated to 0x8000.
///
/// \headerfile
///
/// This intrinsic corresponds to the PACKSSDW instruction.
///
/// \param __m1
-/// A 64-bit integer vector of [2 x i32]. Each 32-bit element is treated as a
-/// 32-bit signed integer and is converted to a 16-bit signed integer with
-/// saturation. Positive values greater than 0x7FFF are saturated to 0x7FFF.
-/// Negative values less than 0x8000 are saturated to 0x8000. The converted
-/// [2 x i16] values are written to the lower 32 bits of the result.
+/// A 64-bit integer vector of [2 x i32]. The converted [2 x i16] values are
+/// written to the lower 32 bits of the result.
/// \param __m2
-/// A 64-bit integer vector of [2 x i32]. Each 32-bit element is treated as a
-/// 32-bit signed integer and is converted to a 16-bit signed integer with
-/// saturation. Positive values greater than 0x7FFF are saturated to 0x7FFF.
-/// Negative values less than 0x8000 are saturated to 0x8000. The converted
-/// [2 x i16] values are written to the upper 32 bits of the result.
+/// A 64-bit integer vector of [2 x i32]. The converted [2 x i16] values are
+/// written to the upper 32 bits of the result.
/// \returns A 64-bit integer vector of [4 x i16] containing the converted
/// values.
static __inline__ __m64 __DEFAULT_FN_ATTRS
@@ -165,28 +155,23 @@ _mm_packs_pi32(__m64 __m1, __m64 __m2)
return (__m64)__builtin_ia32_packssdw((__v2si)__m1, (__v2si)__m2);
}
-/// Converts 16-bit signed integers from both 64-bit integer vector
-/// parameters of [4 x i16] into 8-bit unsigned integer values, and
-/// constructs a 64-bit integer vector of [8 x i8] as the result. Values
-/// greater than 0xFF are saturated to 0xFF. Values less than 0 are saturated
-/// to 0.
+/// Converts, with saturation, 16-bit signed integers from both 64-bit integer
+/// vector parameters of [4 x i16] into 8-bit unsigned integer values, and
+/// constructs a 64-bit integer vector of [8 x i8] as the result.
+///
+/// Values greater than 0xFF are saturated to 0xFF. Values less than 0 are
+/// saturated to 0.
///
/// \headerfile
///
/// This intrinsic corresponds to the PACKUSWB instruction.
///
/// \param __m1
-/// A 64-bit integer vector of [4 x i16]. Each 16-bit element is treated as a
-/// 16-bit signed integer and is converted to an 8-bit unsigned integer with
-/// saturation. Values greater than 0xFF are saturated to 0xFF. Values less
-/// than 0 are saturated to 0. The converted [4 x i8] values are written to
-/// the lower 32 bits of the result.
+/// A 64-bit integer vector of [4 x i16]. The converted [4 x i8] values are
+/// written to the lower 32 bits of the result.
/// \param __m2
-/// A 64-bit integer vector of [4 x i16]. Each 16-bit element is treated as a
-/// 16-bit signed integer and is converted to an 8-bit unsigned integer with
-/// saturation. Values greater than 0xFF are saturated to 0xFF. Values less
-/// than 0 are saturated to 0. The converted [4 x i8] values are written to
-/// the upper 32 bits of the result.
+/// A 64-bit integer vector of [4 x i16]. The converted [4 x i8] values are
+/// written to the upper 32 bits of the result.
/// \returns A 64-bit integer vector of [8 x i8] containing the converted
/// values.
static __inline__ __m64 __DEFAULT_FN_ATTRS
@@ -400,11 +385,13 @@ _mm_add_pi32(__m64 __m1, __m64 __m2)
return (__m64)__builtin_ia32_paddd((__v2si)__m1, (__v2si)__m2);
}
-/// Adds each 8-bit signed integer element of the first 64-bit integer
-/// vector of [8 x i8] to the corresponding 8-bit signed integer element of
-/// the second 64-bit integer vector of [8 x i8]. Positive sums greater than
-/// 0x7F are saturated to 0x7F. Negative sums less than 0x80 are saturated to
-/// 0x80. The results are packed into a 64-bit integer vector of [8 x i8].
+/// Adds, with saturation, each 8-bit signed integer element of the first
+/// 64-bit integer vector of [8 x i8] to the corresponding 8-bit signed
+/// integer element of the second 64-bit integer vector of [8 x i8].
+///
+/// Positive sums greater than 0x7F are saturated to 0x7F. Negative sums
+/// less than 0x80 are saturated to 0x80. The results are packed into a
+/// 64-bit integer vector of [8 x i8].
///
/// \headerfile
///
@@ -422,12 +409,13 @@ _mm_adds_pi8(__m64 __m1, __m64 __m2)
return (__m64)__builtin_ia32_paddsb((__v8qi)__m1, (__v8qi)__m2);
}
-/// Adds each 16-bit signed integer element of the first 64-bit integer
-/// vector of [4 x i16] to the corresponding 16-bit signed integer element of
-/// the second 64-bit integer vector of [4 x i16]. Positive sums greater than
-/// 0x7FFF are saturated to 0x7FFF. Negative sums less than 0x8000 are
-/// saturated to 0x8000. The results are packed into a 64-bit integer vector
-/// of [4 x i16].
+/// Adds, with saturation, each 16-bit signed integer element of the first
+/// 64-bit integer vector of [4 x i16] to the corresponding 16-bit signed
+/// integer element of the second 64-bit integer vector of [4 x i16].
+///
+/// Positive sums greater than 0x7FFF are saturated to 0x7FFF. Negative sums
+/// less than 0x8000 are saturated to 0x8000. The results are packed into a
+/// 64-bit integer vector of [4 x i16].
///
/// \headerfile
///
@@ -445,11 +433,12 @@ _mm_adds_pi16(__m64 __m1, __m64 __m2)
return (__m64)__builtin_ia32_paddsw((__v4hi)__m1, (__v4hi)__m2);
}
-/// Adds each 8-bit unsigned integer element of the first 64-bit integer
-/// vector of [8 x i8] to the corresponding 8-bit unsigned integer element of
-/// the second 64-bit integer vector of [8 x i8]. Sums greater than 0xFF are
-/// saturated to 0xFF. The results are packed into a 64-bit integer vector of
-/// [8 x i8].
+/// Adds, with saturation, each 8-bit unsigned integer element of the first
+/// 64-bit integer vector of [8 x i8] to the corresponding 8-bit unsigned
+/// integer element of the second 64-bit integer vector of [8 x i8].
+///
+/// Sums greater than 0xFF are saturated to 0xFF. The results are packed
+/// into a 64-bit integer vector of [8 x i8].
///
/// \headerfile
///
@@ -467,11 +456,12 @@ _mm_adds_pu8(__m64 __m1, __m64 __m2)
return (__m64)__builtin_ia32_paddusb((__v8qi)__m1, (__v8qi)__m2);
}
-/// Adds each 16-bit unsigned integer element of the first 64-bit integer
-/// vector of [4 x i16] to the corresponding 16-bit unsigned integer element
-/// of the second 64-bit integer vector of [4 x i16]. Sums greater than
-/// 0xFFFF are saturated to 0xFFFF. The results are packed into a 64-bit
-/// integer vector of [4 x i16].
+/// Adds, with saturation, each 16-bit unsigned integer element of the first
+/// 64-bit integer vector of [4 x i16] to the corresponding 16-bit unsigned
+/// integer element of the second 64-bit integer vector of [4 x i16].
+///
+/// Sums greater than 0xFFFF are saturated to 0xFFFF. The results are packed
+/// into a 64-bit integer vector of [4 x i16].
///
/// \headerfile
///
@@ -552,12 +542,13 @@ _mm_sub_pi32(__m64 __m1, __m64 __m2)
return (__m64)__builtin_ia32_psubd((__v2si)__m1, (__v2si)__m2);
}
-/// Subtracts each 8-bit signed integer element of the second 64-bit
-/// integer vector of [8 x i8] from the corresponding 8-bit signed integer
-/// element of the first 64-bit integer vector of [8 x i8]. Positive results
-/// greater than 0x7F are saturated to 0x7F. Negative results less than 0x80
-/// are saturated to 0x80. The results are packed into a 64-bit integer
-/// vector of [8 x i8].
+/// Subtracts, with saturation, each 8-bit signed integer element of the second
+/// 64-bit integer vector of [8 x i8] from the corresponding 8-bit signed
+/// integer element of the first 64-bit integer vector of [8 x i8].
+///
+/// Positive results greater than 0x7F are saturated to 0x7F. Negative
+/// results less than 0x80 are saturated to 0x80. The results are packed
+/// into a 64-bit integer vector of [8 x i8].
///
/// \headerfile
///
@@ -575,12 +566,13 @@ _mm_subs_pi8(__m64 __m1, __m64 __m2)
return (__m64)__builtin_ia32_psubsb((__v8qi)__m1, (__v8qi)__m2);
}
-/// Subtracts each 16-bit signed integer element of the second 64-bit
-/// integer vector of [4 x i16] from the corresponding 16-bit signed integer
-/// element of the first 64-bit integer vector of [4 x i16]. Positive results
-/// greater than 0x7FFF are saturated to 0x7FFF. Negative results less than
-/// 0x8000 are saturated to 0x8000. The results are packed into a 64-bit
-/// integer vector of [4 x i16].
+/// Subtracts, with saturation, each 16-bit signed integer element of the
+/// second 64-bit integer vector of [4 x i16] from the corresponding 16-bit
+/// signed integer element of the first 64-bit integer vector of [4 x i16].
+///
+/// Positive results greater than 0x7FFF are saturated to 0x7FFF. Negative
+/// results less than 0x8000 are saturated to 0x8000. The results are packed
+/// into a 64-bit integer vector of [4 x i16].
///
/// \headerfile
///
@@ -1149,7 +1141,7 @@ _mm_xor_si64(__m64 __m1, __m64 __m2)
/// [8 x i8] to determine if the element of the first vector is equal to the
/// corresponding element of the second vector.
///
-/// The comparison yields 0 for false, 0xFF for true.
+/// Each comparison returns 0 for false, 0xFF for true.
///
/// \headerfile
///
@@ -1171,7 +1163,7 @@ _mm_cmpeq_pi8(__m64 __m1, __m64 __m2)
/// [4 x i16] to determine if the element of the first vector is equal to the
/// corresponding element of the second vector.
///
-/// The comparison yields 0 for false, 0xFFFF for true.
+/// Each comparison returns 0 for false, 0xFFFF for true.
///
/// \headerfile
///
@@ -1193,7 +1185,7 @@ _mm_cmpeq_pi16(__m64 __m1, __m64 __m2)
/// [2 x i32] to determine if the element of the first vector is equal to the
/// corresponding element of the second vector.
///
-/// The comparison yields 0 for false, 0xFFFFFFFF for true.
+/// Each comparison returns 0 for false, 0xFFFFFFFF for true.
///
/// \headerfile
///
@@ -1215,7 +1207,7 @@ _mm_cmpeq_pi32(__m64 __m1, __m64 __m2)
/// [8 x i8] to determine if the element of the first vector is greater than
/// the corresponding element of the second vector.
///
-/// The comparison yields 0 for false, 0xFF for true.
+/// Each comparison returns 0 for false, 0xFF for true.
///
/// \headerfile
///
@@ -1237,7 +1229,7 @@ _mm_cmpgt_pi8(__m64 __m1, __m64 __m2)
/// [4 x i16] to determine if the element of the first vector is greater than
/// the corresponding element of the second vector.
///
-/// The comparison yields 0 for false, 0xFFFF for true.
+/// Each comparison returns 0 for false, 0xFFFF for true.
///
/// \headerfile
///
@@ -1259,7 +1251,7 @@ _mm_cmpgt_pi16(__m64 __m1, __m64 __m2)
/// [2 x i32] to determine if the element of the first vector is greater than
/// the corresponding element of the second vector.
///
-/// The comparison yields 0 for false, 0xFFFFFFFF for true.
+/// Each comparison returns 0 for false, 0xFFFFFFFF for true.
///
/// \headerfile
///
diff --git a/lib/include/module.modulemap b/lib/include/module.modulemap
index 56a13f69bc05..9ffc249c8d1a 100644
--- a/lib/include/module.modulemap
+++ b/lib/include/module.modulemap
@@ -44,7 +44,6 @@ module _Builtin_intrinsics [system] [extern_c] {
textual header "avxintrin.h"
textual header "avx2intrin.h"
textual header "avx512fintrin.h"
- textual header "avx512erintrin.h"
textual header "fmaintrin.h"
header "x86intrin.h"
@@ -203,6 +202,11 @@ module _Builtin_stdarg [system] {
export *
}
+ explicit module header_macro {
+ header "__stdarg_header_macro.h"
+ export *
+ }
+
explicit module va_arg {
header "__stdarg_va_arg.h"
export *
@@ -232,6 +236,10 @@ module _Builtin_stdbool [system] {
module _Builtin_stddef [system] {
textual header "stddef.h"
+ explicit module header_macro {
+ header "__stddef_header_macro.h"
+ export *
+ }
// __stddef_max_align_t.h is always in this module, even if
// -fbuiltin-headers-in-system-modules is passed.
explicit module max_align_t {
@@ -315,3 +323,8 @@ module opencl_c {
header "opencl-c.h"
header "opencl-c-base.h"
}
+
+module ptrauth {
+ header "ptrauth.h"
+ export *
+}
diff --git a/lib/include/opencl-c-base.h b/lib/include/opencl-c-base.h
index 2494f6213fc5..786678b9d8a7 100644
--- a/lib/include/opencl-c-base.h
+++ b/lib/include/opencl-c-base.h
@@ -46,6 +46,10 @@
#define __opencl_c_ext_fp32_global_atomic_min_max 1
#define __opencl_c_ext_fp32_local_atomic_min_max 1
#define __opencl_c_ext_image_raw10_raw12 1
+#define cl_khr_kernel_clock 1
+#define __opencl_c_kernel_clock_scope_device 1
+#define __opencl_c_kernel_clock_scope_work_group 1
+#define __opencl_c_kernel_clock_scope_sub_group 1
#endif // defined(__SPIR__) || defined(__SPIRV__)
#endif // (defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200)
diff --git a/lib/include/opencl-c.h b/lib/include/opencl-c.h
index 288bb18bc654..20719b74b6b8 100644
--- a/lib/include/opencl-c.h
+++ b/lib/include/opencl-c.h
@@ -17314,6 +17314,21 @@ half __ovld __conv sub_group_clustered_rotate(half, int, uint);
#endif // cl_khr_fp16
#endif // cl_khr_subgroup_rotate
+#if defined(cl_khr_kernel_clock)
+#if defined(__opencl_c_kernel_clock_scope_device)
+ulong __ovld clock_read_device();
+uint2 __ovld clock_read_hilo_device();
+#endif // __opencl_c_kernel_clock_scope_device
+#if defined(__opencl_c_kernel_clock_scope_work_group)
+ulong __ovld clock_read_work_group();
+uint2 __ovld clock_read_hilo_work_group();
+#endif // __opencl_c_kernel_clock_scope_work_group
+#if defined(__opencl_c_kernel_clock_scope_sub_group)
+ulong __ovld clock_read_sub_group();
+uint2 __ovld clock_read_hilo_sub_group();
+#endif // __opencl_c_kernel_clock_scope_sub_group
+#endif // cl_khr_kernel_clock
+
#if defined(cl_intel_subgroups)
// Intel-Specific Sub Group Functions
float __ovld __conv intel_sub_group_shuffle( float , uint );
diff --git a/lib/include/prfchwintrin.h b/lib/include/prfchwintrin.h
index d2f91aa0123e..eaea5f3cf8fe 100644
--- a/lib/include/prfchwintrin.h
+++ b/lib/include/prfchwintrin.h
@@ -8,16 +8,17 @@
*/
#if !defined(__X86INTRIN_H) && !defined(_MM3DNOW_H_INCLUDED)
-#error "Never use directly; include or instead."
+#error "Never use directly; include instead."
#endif
#ifndef __PRFCHWINTRIN_H
#define __PRFCHWINTRIN_H
/// Loads a memory sequence containing the specified memory address into
-/// all data cache levels. The cache-coherency state is set to exclusive.
-/// Data can be read from and written to the cache line without additional
-/// delay.
+/// all data cache levels.
+///
+/// The cache-coherency state is set to exclusive. Data can be read from
+/// and written to the cache line without additional delay.
///
/// \headerfile
///
@@ -32,10 +33,11 @@ _m_prefetch(void *__P)
}
/// Loads a memory sequence containing the specified memory address into
-/// the L1 data cache and sets the cache-coherency to modified. This
-/// provides a hint to the processor that the cache line will be modified.
-/// It is intended for use when the cache line will be written to shortly
-/// after the prefetch is performed.
+/// the L1 data cache and sets the cache-coherency state to modified.
+///
+/// This provides a hint to the processor that the cache line will be
+/// modified. It is intended for use when the cache line will be written to
+/// shortly after the prefetch is performed.
///
/// Note that the effect of this intrinsic is dependent on the processor
/// implementation.
diff --git a/lib/include/ptrauth.h b/lib/include/ptrauth.h
new file mode 100644
index 000000000000..154b599862a8
--- /dev/null
+++ b/lib/include/ptrauth.h
@@ -0,0 +1,330 @@
+/*===---- ptrauth.h - Pointer authentication -------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __PTRAUTH_H
+#define __PTRAUTH_H
+
+typedef enum {
+ ptrauth_key_asia = 0,
+ ptrauth_key_asib = 1,
+ ptrauth_key_asda = 2,
+ ptrauth_key_asdb = 3,
+
+ /* A process-independent key which can be used to sign code pointers. */
+ ptrauth_key_process_independent_code = ptrauth_key_asia,
+
+ /* A process-specific key which can be used to sign code pointers. */
+ ptrauth_key_process_dependent_code = ptrauth_key_asib,
+
+ /* A process-independent key which can be used to sign data pointers. */
+ ptrauth_key_process_independent_data = ptrauth_key_asda,
+
+ /* A process-specific key which can be used to sign data pointers. */
+ ptrauth_key_process_dependent_data = ptrauth_key_asdb,
+
+ /* The key used to sign return addresses on the stack.
+ The extra data is based on the storage address of the return address.
+ On AArch64, that is always the storage address of the return address + 8
+ (or, in other words, the value of the stack pointer on function entry) */
+ ptrauth_key_return_address = ptrauth_key_process_dependent_code,
+
+ /* The key used to sign C function pointers.
+ The extra data is always 0. */
+ ptrauth_key_function_pointer = ptrauth_key_process_independent_code,
+
+ /* The key used to sign C++ v-table pointers.
+ The extra data is always 0. */
+ ptrauth_key_cxx_vtable_pointer = ptrauth_key_process_independent_data,
+
+ /* Other pointers signed under the ABI use private ABI rules. */
+
+} ptrauth_key;
+
+/* An integer type of the appropriate size for a discriminator argument. */
+typedef __UINTPTR_TYPE__ ptrauth_extra_data_t;
+
+/* An integer type of the appropriate size for a generic signature. */
+typedef __UINTPTR_TYPE__ ptrauth_generic_signature_t;
+
+/* A signed pointer value embeds the original pointer together with
+ a signature that attests to the validity of that pointer. Because
+ this signature must use only "spare" bits of the pointer, a
+ signature's validity is probabilistic in practice: it is unlikely
+ but still plausible that an invalidly-derived signature will
+ somehow equal the correct signature and therefore successfully
+ authenticate. Nonetheless, this scheme provides a strong degree
+ of protection against certain kinds of attacks. */
+
+/* Authenticating a pointer that was not signed with the given key
+ and extra-data value will (likely) fail by trapping. */
+
+/* The null function pointer is always the all-zero bit pattern.
+ Signing an all-zero bit pattern will embed a (likely) non-zero
+ signature in the result, and so the result will not seem to be
+ a null function pointer. Authenticating this value will yield
+ a null function pointer back. However, authenticating an
+ all-zero bit pattern will probably fail, because the
+ authentication will expect a (likely) non-zero signature to
+ embedded in the value.
+
+ Because of this, if a pointer may validly be null, you should
+ check for null before attempting to authenticate it with one
+ of these intrinsics. This is not necessary when using the
+ __ptrauth qualifier; the compiler will perform this check
+ automatically. */
+
+#if __has_feature(ptrauth_intrinsics)
+
+/* Strip the signature from a value without authenticating it.
+
+ If the value is a function pointer, the result will not be a
+ legal function pointer because of the missing signature, and
+ attempting to call it will result in an authentication failure.
+
+ The value must be an expression of pointer type.
+ The key must be a constant expression of type ptrauth_key.
+ The result will have the same type as the original value. */
+#define ptrauth_strip(__value, __key) __builtin_ptrauth_strip(__value, __key)
+
+/* Blend a constant discriminator into the given pointer-like value
+ to form a new discriminator. Not all bits of the inputs are
+ guaranteed to contribute to the result.
+
+ On arm64e, the integer must fall within the range of a uint16_t;
+ other bits may be ignored.
+
+ For the purposes of ptrauth_sign_constant, the result of calling
+ this function is considered a constant expression if the arguments
+ are constant. Some restrictions may be imposed on the pointer.
+
+ The first argument must be an expression of pointer type.
+ The second argument must be an expression of integer type.
+ The result will have type uintptr_t. */
+#define ptrauth_blend_discriminator(__pointer, __integer) \
+ __builtin_ptrauth_blend_discriminator(__pointer, __integer)
+
+/* Return a signed pointer for a constant address in a manner which guarantees
+ a non-attackable sequence.
+
+ The value must be a constant expression of pointer type which evaluates to
+ a non-null pointer.
+ The key must be a constant expression of type ptrauth_key.
+ The extra data must be a constant expression of pointer or integer type;
+ if an integer, it will be coerced to ptrauth_extra_data_t.
+ The result will have the same type as the original value.
+
+ This can be used in constant expressions. */
+#define ptrauth_sign_constant(__value, __key, __data) \
+ __builtin_ptrauth_sign_constant(__value, __key, __data)
+
+/* Add a signature to the given pointer value using a specific key,
+ using the given extra data as a salt to the signing process.
+
+ This operation does not authenticate the original value and is
+ therefore potentially insecure if an attacker could possibly
+ control that value.
+
+ The value must be an expression of pointer type.
+ The key must be a constant expression of type ptrauth_key.
+ The extra data must be an expression of pointer or integer type;
+ if an integer, it will be coerced to ptrauth_extra_data_t.
+ The result will have the same type as the original value. */
+#define ptrauth_sign_unauthenticated(__value, __key, __data) \
+ __builtin_ptrauth_sign_unauthenticated(__value, __key, __data)
+
+/* Authenticate a pointer using one scheme and resign it using another.
+
+ If the result is subsequently authenticated using the new scheme, that
+ authentication is guaranteed to fail if and only if the initial
+ authentication failed.
+
+ The value must be an expression of pointer type.
+ The key must be a constant expression of type ptrauth_key.
+ The extra data must be an expression of pointer or integer type;
+ if an integer, it will be coerced to ptrauth_extra_data_t.
+ The result will have the same type as the original value.
+
+ This operation is guaranteed to not leave the intermediate value
+ available for attack before it is re-signed.
+
+ Do not pass a null pointer to this function. A null pointer
+ will not successfully authenticate.
+
+ This operation traps if the authentication fails. */
+#define ptrauth_auth_and_resign(__value, __old_key, __old_data, __new_key, \
+ __new_data) \
+ __builtin_ptrauth_auth_and_resign(__value, __old_key, __old_data, __new_key, \
+ __new_data)
+
+/* Authenticate a pointer using one scheme and resign it as a C
+ function pointer.
+
+ If the result is subsequently authenticated using the new scheme, that
+ authentication is guaranteed to fail if and only if the initial
+ authentication failed.
+
+ The value must be an expression of function pointer type.
+ The key must be a constant expression of type ptrauth_key.
+ The extra data must be an expression of pointer or integer type;
+ if an integer, it will be coerced to ptrauth_extra_data_t.
+ The result will have the same type as the original value.
+
+ This operation is guaranteed to not leave the intermediate value
+ available for attack before it is re-signed. Additionally, if this
+ expression is used syntactically as the function expression in a
+ call, only a single authentication will be performed. */
+#define ptrauth_auth_function(__value, __old_key, __old_data) \
+ ptrauth_auth_and_resign(__value, __old_key, __old_data, \
+ ptrauth_key_function_pointer, 0)
+
+/* Authenticate a data pointer.
+
+ The value must be an expression of non-function pointer type.
+ The key must be a constant expression of type ptrauth_key.
+ The extra data must be an expression of pointer or integer type;
+ if an integer, it will be coerced to ptrauth_extra_data_t.
+ The result will have the same type as the original value.
+
+ This operation traps if the authentication fails. */
+#define ptrauth_auth_data(__value, __old_key, __old_data) \
+ __builtin_ptrauth_auth(__value, __old_key, __old_data)
+
+/* Compute a constant discriminator from the given string.
+
+ The argument must be a string literal of char character type. The result
+ has type ptrauth_extra_data_t.
+
+ The result value is never zero and always within range for both the
+ __ptrauth qualifier and ptrauth_blend_discriminator.
+
+ This can be used in constant expressions.
+*/
+#define ptrauth_string_discriminator(__string) \
+ __builtin_ptrauth_string_discriminator(__string)
+
+/* Compute a constant discriminator from the given type.
+
+ The result can be used as the second argument to
+ ptrauth_blend_discriminator or the third argument to the
+ __ptrauth qualifier. It has type size_t.
+
+ If the type is a C++ member function pointer type, the result is
+ the discriminator used to signed member function pointers of that
+ type. If the type is a function, function pointer, or function
+ reference type, the result is the discriminator used to sign
+ functions of that type. It is ill-formed to use this macro with any
+ other type.
+
+ A call to this function is an integer constant expression. */
+#define ptrauth_type_discriminator(__type) \
+ __builtin_ptrauth_type_discriminator(__type)
+
+/* Compute a signature for the given pair of pointer-sized values.
+ The order of the arguments is significant.
+
+ Like a pointer signature, the resulting signature depends on
+ private key data and therefore should not be reliably reproducible
+ by attackers. That means that this can be used to validate the
+ integrity of arbitrary data by storing a signature for that data
+ alongside it, then checking that the signature is still valid later.
+ Data which exceeds two pointers in size can be signed by either
+ computing a tree of generic signatures or just signing an ordinary
+ cryptographic hash of the data.
+
+ The result has type ptrauth_generic_signature_t. However, it may
+ not have as many bits of entropy as that type's width would suggest;
+ some implementations are known to compute a compressed signature as
+ if the arguments were a pointer and a discriminator.
+
+ The arguments must be either pointers or integers; if integers, they
+ will be coerce to uintptr_t. */
+#define ptrauth_sign_generic_data(__value, __data) \
+ __builtin_ptrauth_sign_generic_data(__value, __data)
+
+/* C++ vtable pointer signing class attribute */
+#define ptrauth_cxx_vtable_pointer(key, address_discrimination, \
+ extra_discrimination...) \
+ [[clang::ptrauth_vtable_pointer(key, address_discrimination, \
+ extra_discrimination)]]
+
+#else
+
+#define ptrauth_strip(__value, __key) \
+ ({ \
+ (void)__key; \
+ __value; \
+ })
+
+#define ptrauth_blend_discriminator(__pointer, __integer) \
+ ({ \
+ (void)__pointer; \
+ (void)__integer; \
+ ((ptrauth_extra_data_t)0); \
+ })
+
+#define ptrauth_sign_constant(__value, __key, __data) \
+ ({ \
+ (void)__key; \
+ (void)__data; \
+ __value; \
+ })
+
+#define ptrauth_sign_unauthenticated(__value, __key, __data) \
+ ({ \
+ (void)__key; \
+ (void)__data; \
+ __value; \
+ })
+
+#define ptrauth_auth_and_resign(__value, __old_key, __old_data, __new_key, \
+ __new_data) \
+ ({ \
+ (void)__old_key; \
+ (void)__old_data; \
+ (void)__new_key; \
+ (void)__new_data; \
+ __value; \
+ })
+
+#define ptrauth_auth_function(__value, __old_key, __old_data) \
+ ({ \
+ (void)__old_key; \
+ (void)__old_data; \
+ __value; \
+ })
+
+#define ptrauth_auth_data(__value, __old_key, __old_data) \
+ ({ \
+ (void)__old_key; \
+ (void)__old_data; \
+ __value; \
+ })
+
+#define ptrauth_string_discriminator(__string) \
+ ({ \
+ (void)__string; \
+ ((ptrauth_extra_data_t)0); \
+ })
+
+#define ptrauth_type_discriminator(__type) ((ptrauth_extra_data_t)0)
+
+#define ptrauth_sign_generic_data(__value, __data) \
+ ({ \
+ (void)__value; \
+ (void)__data; \
+ ((ptrauth_generic_signature_t)0); \
+ })
+
+
+#define ptrauth_cxx_vtable_pointer(key, address_discrimination, \
+ extra_discrimination...)
+
+#endif /* __has_feature(ptrauth_intrinsics) */
+
+#endif /* __PTRAUTH_H */
diff --git a/lib/include/riscv_vector.h b/lib/include/riscv_vector.h
index 083a13587766..c99ceb802174 100644
--- a/lib/include/riscv_vector.h
+++ b/lib/include/riscv_vector.h
@@ -14,10 +14,6 @@
#include
#include
-#ifndef __riscv_vector
-#error "Vector intrinsics require the vector extension."
-#endif
-
#ifdef __cplusplus
extern "C" {
#endif
diff --git a/lib/include/sifive_vector.h b/lib/include/sifive_vector.h
index 42d7224db614..4e67ad6fca26 100644
--- a/lib/include/sifive_vector.h
+++ b/lib/include/sifive_vector.h
@@ -13,4 +13,106 @@
#pragma clang riscv intrinsic sifive_vector
+#define __riscv_sf_vc_x_se_u8mf4(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint8_t)rs1, 8, 6, vl)
+#define __riscv_sf_vc_x_se_u8mf2(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint8_t)rs1, 8, 7, vl)
+#define __riscv_sf_vc_x_se_u8m1(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint8_t)rs1, 8, 0, vl)
+#define __riscv_sf_vc_x_se_u8m2(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint8_t)rs1, 8, 1, vl)
+#define __riscv_sf_vc_x_se_u8m4(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint8_t)rs1, 8, 2, vl)
+#define __riscv_sf_vc_x_se_u8m8(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint8_t)rs1, 8, 3, vl)
+
+#define __riscv_sf_vc_x_se_u16mf2(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint16_t)rs1, 16, 7, vl)
+#define __riscv_sf_vc_x_se_u16m1(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint16_t)rs1, 16, 0, vl)
+#define __riscv_sf_vc_x_se_u16m2(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint16_t)rs1, 16, 1, vl)
+#define __riscv_sf_vc_x_se_u16m4(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint16_t)rs1, 16, 2, vl)
+#define __riscv_sf_vc_x_se_u16m8(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint16_t)rs1, 16, 3, vl)
+
+#define __riscv_sf_vc_x_se_u32m1(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint32_t)rs1, 32, 0, vl)
+#define __riscv_sf_vc_x_se_u32m2(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint32_t)rs1, 32, 1, vl)
+#define __riscv_sf_vc_x_se_u32m4(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint32_t)rs1, 32, 2, vl)
+#define __riscv_sf_vc_x_se_u32m8(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint32_t)rs1, 32, 3, vl)
+
+#define __riscv_sf_vc_i_se_u8mf4(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 8, 7, vl)
+#define __riscv_sf_vc_i_se_u8mf2(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 8, 6, vl)
+#define __riscv_sf_vc_i_se_u8m1(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 8, 0, vl)
+#define __riscv_sf_vc_i_se_u8m2(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 8, 1, vl)
+#define __riscv_sf_vc_i_se_u8m4(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 8, 2, vl)
+#define __riscv_sf_vc_i_se_u8m8(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 8, 3, vl)
+
+#define __riscv_sf_vc_i_se_u16mf2(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 16, 7, vl)
+#define __riscv_sf_vc_i_se_u16m1(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 16, 0, vl)
+#define __riscv_sf_vc_i_se_u16m2(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 16, 1, vl)
+#define __riscv_sf_vc_i_se_u16m4(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 16, 2, vl)
+#define __riscv_sf_vc_i_se_u16m8(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 16, 3, vl)
+
+#define __riscv_sf_vc_i_se_u32m1(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 32, 0, vl)
+#define __riscv_sf_vc_i_se_u32m2(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 32, 1, vl)
+#define __riscv_sf_vc_i_se_u32m4(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 32, 2, vl)
+#define __riscv_sf_vc_i_se_u32m8(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 32, 3, vl)
+
+#if __riscv_v_elen >= 64
+#define __riscv_sf_vc_x_se_u8mf8(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint8_t)rs1, 8, 5, vl)
+#define __riscv_sf_vc_x_se_u16mf4(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint16_t)rs1, 16, 6, vl)
+#define __riscv_sf_vc_x_se_u32mf2(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint32_t)rs1, 32, 7, vl)
+
+#define __riscv_sf_vc_i_se_u8mf8(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 8, 5, vl)
+#define __riscv_sf_vc_i_se_u16mf4(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 16, 6, vl)
+#define __riscv_sf_vc_i_se_u32mf2(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 32, 7, vl)
+
+#define __riscv_sf_vc_i_se_u64m1(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 64, 0, vl)
+#define __riscv_sf_vc_i_se_u64m2(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 64, 1, vl)
+#define __riscv_sf_vc_i_se_u64m4(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 64, 2, vl)
+#define __riscv_sf_vc_i_se_u64m8(p27_26, p24_20, p11_7, simm5, vl) \
+ __riscv_sf_vc_i_se(p27_26, p24_20, p11_7, simm5, 64, 3, vl)
+
+#if __riscv_xlen >= 64
+#define __riscv_sf_vc_x_se_u64m1(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint64_t)rs1, 64, 0, vl)
+#define __riscv_sf_vc_x_se_u64m2(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint64_t)rs1, 64, 1, vl)
+#define __riscv_sf_vc_x_se_u64m4(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint64_t)rs1, 64, 2, vl)
+#define __riscv_sf_vc_x_se_u64m8(p27_26, p24_20, p11_7, rs1, vl) \
+ __riscv_sf_vc_x_se(p27_26, p24_20, p11_7, (uint64_t)rs1, 64, 3, vl)
+#endif
+#endif
+
#endif //_SIFIVE_VECTOR_H_
diff --git a/lib/include/smmintrin.h b/lib/include/smmintrin.h
index 005d7db9c3c3..b3fec474e35a 100644
--- a/lib/include/smmintrin.h
+++ b/lib/include/smmintrin.h
@@ -1188,6 +1188,8 @@ static __inline__ int __DEFAULT_FN_ATTRS _mm_testnzc_si128(__m128i __M,
/// Compares each of the corresponding 64-bit values of the 128-bit
/// integer vectors for equality.
///
+/// Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///
/// \headerfile
///
/// This intrinsic corresponds to the